c++ - constexpr 函数中的编译时或运行时检测

Question

当 constexpr 在 C++11 中被引入时，我很兴奋，但不幸的是，我对其有用性做出了乐观的假设。我假设我们可以在任何地方使用 constexpr 来捕获文字编译时常量或文字编译时常量的任何 constexpr 结果，包括以下内容:

constexpr float MyMin(constexpr float a, constexpr float b) { return a<b?a:b; }

因为仅将函数的返回类型限定为 constexpr 并不限制其在编译时的使用，并且还必须在运行时可调用，所以我认为这将是确保 MyMin 只能用于 compile-时间评估的常量，这将确保编译器永远不会允许它在运行时执行，让我可以自由地编写一个对运行时更友好的 MyMin 版本，理想情况下与使用 _mm_min_ss 内在函数的名称相同，确保编译器不会生成运行时分支代码。不幸的是，函数参数不能是 constexpr，所以似乎无法做到这一点，除非这样的事情是可能的:

constexpr float MyMin(float a, float b)
{
#if __IS_COMPILE_TIME__
    return a<b?a:b;
#else
    return _mm_cvtss_f32(_mm_min_ss(_mm_set_ss(a),_mm_set_ss(b)));
#endif
}

我非常怀疑 MSVC++ 是否有类似的东西，但我希望 GCC 或 clang 至少有一些东西可以完成它，无论它看起来多么不雅。

当然，我提供的示例非常简单，但是如果您可以发挥想象力，在很多情况下您可以随意做一些事情，例如在您知道只能在以下位置执行的函数中大量使用分支语句编译时间，因为如果它在运行时执行，性能会受到影响。

Answer 1

可以检测给定的函数调用表达式是否为常量表达式，从而在两个不同的实现之间进行选择。下面使用的通用 lambda 需要 C++14。

(这个答案源 self 去年提出的一个问题 this answer from @Yakk)。

我不确定我将标准推到多远。这是在 clang 3.9 上测试的，但会导致 g++ 6.2 给出“内部编译器错误”。我将在下周发送错误报告(如果没有其他人先发送!)

第一步是移动constexpr实现到 struct作为 constexpr static方法。更简单地说，您可以离开当前的 constexpr按原样从 constexpr static 调用它新方法struct .

struct StaticStruct {
    static constexpr float MyMin_constexpr (float a, float b) {
        return a<b?a:b;
    }
};

另外，定义这个(即使它看起来没用!):

template<int>
using Void = void;

基本思想是Void<i>要求 i是一个常数表达式。更准确地说，以下 lambda 仅在某些情况下才会有合适的重载:

auto l = [](auto ty)-> Void<(decltype(ty)::   MyMin_constexpr(1,3)   ,0)>{};
                                              \------------------/
                                               testing if this
                                               expression is a
                                               constant expression.

我们可以调用l仅当参数 ty是 StaticStruct 类型并且如果我们的兴趣表达 (MyMin_constexpr(1,3)) 是一个常量表达式。如果我们替换 1或 3带有非常量参数，然后是通用 lambda l将丢失通过 SFINAE 的方法。

因此，以下两个测试是等价的:

• Is StaticStruct::MyMin_constexpr(1,3) a constant expression?
• Can l be called via l(StaticStruct{})?

很容易删除auto ty和 decltype(ty)从上面的 lambda。但这将给出一个硬错误(在非常量情况下)，而不是一个很好的替换失败。因此我们使用 auto ty得到替换失败(我们可以有效地检测到)而不是错误。

接下来的代码很容易返回 std:true_type 当且仅当 f (我们的通用 lambda)可以用 a 调用(StaticStruct):

template<typename F,typename A>
constexpr
auto
is_a_constant_expression(F&& f, A&& a)
    -> decltype( ( std::forward<F>(f)(std::forward<A>(a)) , std::true_type{} ) )
{ return {}; }
constexpr
std::false_type is_a_constant_expression(...)
{ return {}; }

接下来，演示一下它的使用:

int main() {
    {
        auto should_be_true = is_a_constant_expression(
            [](auto ty)-> Void<(decltype(ty)::   MyMin_constexpr(1,3)   ,0)>{}
            , StaticStruct{});
        static_assert( should_be_true ,"");
    }
    {   
        float f = 3; // non-constexpr
        auto should_be_false = is_a_constant_expression(
            [](auto ty)-> Void<(decltype(ty)::   MyMin_constexpr(1,f)   ,0)>{}
            , StaticStruct{});
        static_assert(!should_be_false ,"");
    }
}

---

为了直接解决你原来的问题，我们可以先定义一个宏来保存重复:

(我没有测试过这个宏，如有错别字请见谅。)

#define IS_A_CONSTANT_EXPRESSION( EXPR )                \
     is_a_constant_expression(                          \
         [](auto ty)-> Void<(decltype(ty)::             \
              EXPR                         ,0)>{}       \
         , StaticStruct{})

在这个阶段，也许你可以这样做:

#define MY_MIN(...)                                            \
    IS_A_CONSTANT_EXPRESSION( MyMin_constexpr(__VA_ARGS__) ) ? \
        StaticStruct :: MyMin_constexpr( __VA_ARGS__ )     :   \
                        MyMin_runtime  ( __VA_ARGS__ )

或者，如果您不相信您的编译器会优化 std::true_type和 std::false_type通过?: ，那么也许:

constexpr
float MyMin(std::true_type, float a, float b) { // called if it is a constant expression
    return StaticStruct:: MyMin_constexpr(a,b);
}
float MyMin(std::false_type, float , float ) { // called if NOT a constant expression
    return                MyMin_runtime(a,b);
}

改用这个宏:

#define MY_MIN(...)                                             \
  MyMin( IS_A_CONSTANT_EXPRESSION(MyMin_constexpr(__VA_ARGS__)) \
       , __VA_ARGS__)