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

Question

当constexpr在C ++ 11中引入时，我很兴奋，但遗憾的是我对其有用性做出了乐观的假设。 我假设我们可以在任何地方使用constexpr来捕获文字编译时常量或文字编译时常量的任何constexpr结果，包括这样的事情：

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

因为仅将函数的返回类型限定为constexpr并不将其使用限制为编译时，并且还必须在运行时可调用，所以我认为这将是确保MyMin只能与编译时计算的常量一起使用的一种方法，这将确保编译器永远不会允许它在运行时执行，让我可以编写另一个更加运行时友好的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。

（ 这个答案从@Yakk的答案中得出了我去年提出的一个问题）。

我不确定我推动标准的程度。 这是在clang 3.9上测试的，但是导致g ++ 6.2给出“内部编译器错误”。 我将在下周发送一个错误报告（如果没有其他人先做错！）

第一步是将constexpr实现作为constexpr static方法移动到struct中。 更简单地说，您可以保留当前的constexpr ，并从新struct的constexpr static方法中调用它。

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.

只有当参数ty是StaticStruct类型并且我们感兴趣的表达式（ MyMin_constexpr(1,3) ）是一个常量表达式时，我们才能调用l 。 如果我们用非常量参数替换1或3 ，那么通用lambda l将通过SFINAE丢失方法。

因此，以下两个测试是等效的：

• StaticStruct::MyMin_constexpr(1,3)是一个常量表达式吗？
• 可以l通过被称为l(StaticStruct{})

简单地从上面的lambda中删除auto ty和decltype(ty)是很诱人的。 但这会产生一个硬错误（在非常数情况下），而不是一个很好的替换失败。 因此，我们使用auto ty来获取替换失败（我们可以有效地检测）而不是错误。

接下来的这个代码是返回一个简单的事情std:true_type当且仅当f （我们的通用拉姆达）可以被称为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__)

Answer 2

我认为这将是一种确保MyMin只能与编译时计算的常量一起使用的方法，这将确保编译器永远不会允许它在运行时执行

是; 有一种方法。

并且也适用于C ++ 11。

Google-ing我发现了一种奇怪的中毒方式 （Scott Schurr）：简而言之，以下内容

extern int no_symbol;

constexpr float MyMin (float a, float b)
 {
   return a != a ? throw (no_symbol)
                 : (a < b ? a : b) ;
 }

int main()
 {
   constexpr  float  m0 { MyMin(2.0f, 3.0f) }; // OK

   float  f1 { 2.0f };

   float  m1 { MyMin(f1, 3.0f) };  // linker error: undefined "no_symbol"
 }

如果我理解得很好，其背后的想法是，如果MyMin()执行编译时间，则从不使用throw(no_symbol) （ a != a永远是假的）所以不需要使用声明为extern no_symbol但是从未定义过（并且throw()不能用于编译时）。

如果使用MyMin()运行时，则会编译throw(no_symbol) ，并且no_symbol会在链接阶段出错。

更一般地说，有一个提案 （来自Scott Schurr），但我不知道实现。

---编辑---

正如TC所指出的那样（谢谢！）这个解决方案的工作（如果工作和工作时）只是因为编译器没有优化点，以了解a != a永远是错误的。

特别是， MyMin()工作（没有很好的优化）因为，在这个例子中，我们正在使用浮点数，如果a是NaN，则a != a可以为真，因此编译器检测到throw()更难throw()部分是无用的。 如果MyMin()是整数函数，则可以编写正文（使用test float(a) != float(a)来尝试阻止compliler优化）

constexpr int MyMin (int a, int b)
 {
   return float(a) != float(a) ? throw (no_symbol)
                 : (a < b ? a : b) ;
 }

但对于没有“自然”可抛出错误情况的函数来说，它不是真正的解决方案。

当它是一个应该给出错误（编译或运行）的自然错误情况时，它是不同的：编译器无法优化和技巧工作。

示例：如果MyMin()返回a和b之间a最小值，但a和b是不同的，或者MyMin()应该给出编译器错误（不是一个很好的例子......我知道），所以

constexpr float MyMin (float a, float b)
 {
   return a != b ? throw (no_symbol)
                 : (a < b ? a : b) ;
 }

因为编译器不能优化a != b并且必须编译（给出链接器错误） throw()部分。