概括編譯時和運行時評估

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();
}

Answer 2

在類似duplicate情況下，您可以使用函數，而不是類或結構：

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

int duplicate(int value)
{
    return value * 2;
}

現在您可以說：

int main() 
{
    // 2 is known at compile-time, calls a "templatized" version of `duplicate`
    int value1 = duplicate<2>(); 

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