概括编译时间和运行时间评估

Generalizing compile-time and run-time evaluation

本文关键字：运行时间 评估 时间 编译      更新时间：2023-10-16

在某些情况下，我可能需要使用相同的行为/代码，其中有时在运行时和编译时已知。这导致代码重复：

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

您不能使模板在运行时实例化，但是您可以完全抛弃模板并使用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();
}

在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);
}
相关文章：