概括编译时和运行时评估

Question

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

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, calls a "templatized" version of `duplicate`
    UnknownTime<2>{}.duplicate(); 

    // `value` is known at run time, calls a "run-time" version of `duplicate`
    int value; std::cin >> value;
    UnknownTime<value>{}.duplicate();
}

Answer 1

您不能在运行时使模板实例化,但您可以完全抛弃模板并使用c ++ 11 constexpr,它已完全为此目的添加到语言中:

struct AnyTime
{
    int value;
    constexpr AnyTime(int mValue) : value{mValue} { }
    constexpr int duplicate() const { return value * 2; }
};

int main()
{
    constexpr int compileTime = AnyTime{2}.duplicate();

    int value; std::cin >> value;
    int runTime = AnyTime{value}.duplicate();
}