标签: compile-time

以下编译在VS2017中很好:

#include <type_traits>

struct Foo
{
    int bar;
};

int main()
{
    static_assert(std::is_same_v<decltype(Foo::bar), int>, "Foo::bar isn't an int");
    return 0;
}

如果Foo :: bar的访问在编译时没有强制它是Foo的静态成员吗​​？我试图强制模板类型的特定成员变量是静态的时偶然发现了这一点.

我需要一种方法来验证常量字符串在编译时不包含某个字符.我想过使用static_assert,但是碰到了一堵砖墙,因为我正在尝试使用.find方法,它不是常量.

我可以选择在类的构造函数中进行检查(实例是static const所述类的成员).
但是在咬住子弹之前(因为改变构造函数的行为还有其他含义),我想看看是否还有其他人有一个创造性的开箱即用的想法仍然可以完成,最好是在编译时.

假设我想确保始终使用不同的参数值（编译时）调用该函数。

理想的情况是这样可以编译：

enum en {
   en_A,
   en_B
};
...
foo(en_A);

但这失败了：

enum en {
   en_A,
   en_B
};
...
foo(en_A);
...
foo(en_A);

因此，我们应该只能调用某个函数 foo(en_A) 一次（对于 foo(en_B) 也是如此）。

不太可取但也可以接受的方法是定义 foo_en_A、foo_en_B 并确保它们每个仅被调用一次。

在 C 语言中是否可以做类似编译时的事情？

经常我遇到像黑客一样的黑客

//lets say this is some class that still doesnt support...
//...all the functionality that it should based on the design docs
void MyClass::MyFunction()
{
  throw std::exception("not implemented");
}

我想这是一个不好的做法,但除此之外:
有没有办法在编译期间做同样的事情,但只有在使用函数时(如果它是未使用的编译应该成功).

编辑:我也对虚拟内存功能感兴趣.

如果我有一个定义的结构,如下所示:

struct blank {
    int : 0;
};

编译器会在运行时将其优化为零吗？

我问,因为这个相当受欢迎的SO问题.我想在我自己的C/C++代码中使用类似的编译时检查.我正在尝试使程序尽可能最佳,所以如果我只是将它们用于编译时检查,我不希望这些空结构在运行时闲置.

另一方面,是否有一种C++ - 惯用的方式来实现与链接相同的结果？

在某些情况下,我可能需要使用相同的行为/代码,其值有时在运行时和编译时是已知的.这会导致代码重复:

template<int TValue> struct CompileTime
{
    int duplicate() { return TValue * 2; }
};

struct RunTime
{
    int value;
    RunTime(int mValue) : value{mValue} { }
    int duplicate() { return value * 2; }
};

int main()
{
    // I need to duplicate a compile-time known value first...
    CompileTime<2>{}.duplicate();

    // And now I need to duplicate a run-time value...
    int value; std::cin >> value;
    RunTime{value}.duplicate();
}

显然这个例子真的很愚蠢,但有什么方法可以避免重复这种行为duplicate()？(但是,需要存储该值.)

理想情况下,我想写:

int main() 
{
    // 2 is known at compile-time, …

我有一个带有两个参数的函数（假设两个字符串）：

fn foo(x: String, y: String) -> String {
    x + y
}

我总是x在编译时知道，但y直到运行时我才知道。

我怎样才能编写这个以获得最大效率，而无需为每个函数复制粘贴x？

我想首先说明，当我说同构元组时，我的意思是每个元素的类型都是相同的，或者每个元素都有一个公共成员，该成员在所有元素中都是相同的类型。在这种情况下，公共成员也必须是static constexpr。

这是描述我的问题的一段简化代码：

#include <cstddef>
#include <tuple>
#include <type_traits>
#include <utility>

template <std::size_t N>
struct Int : std::integral_constant<std::size_t, N>
{
    Int() = default;
    Int(const Int&) = delete;
    Int(Int&&) = delete;

    Int& operator=(const Int&) = delete;
    Int& operator=(Int&&) = delete;
};

template <std::size_t... Ns>
struct Stuff
{
    using type = std::tuple<Int<Ns>...>;
    using arr_type = std::array<std::size_t, std::tuple_size_v<type>>;
    static constexpr arr_type arr = {Ns...};
};

我相当确定它是正确的，唯一的问题是最后一行，但希望你明白要点。

现在，数组是使用Ns.... 我希望能够从而type不是构造数组（原因是type已经从元组中删除了重复类型（基于.value），并且还在.value此代码的实际版本中对类型进行了排序（基于））。如果相反，在编译时从数组中排序和删除重复值更容易，那么这也将被接受作为答案。

所以理想情况下，我会编写某种模板化结构来创建数组（因为在结构中会有一个static constexpr …

是否存在这种编译时计算可以使编译器陷入无限循环？

无限循环不会消耗不断增加的内存吗？或者它可能会因缺乏内存而停止。

是否有编译时映射的规范/参考实现，将类型映射到类型？

例如，我需要一个类型映射 fromIBar -> IFoo或 from int -> IFoo。

在编译时，我可以IFoo在给定IBar.

如何使用 C++17 解决这个问题？

编辑：这是一个使用结构的例子https://godbolt.org/z/EEvrYd9PE