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。

（对于我去年提出的一个问题，这个答案长出this answer from @Yakk。

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

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

struct

另外，定义一下（即使它看起来没用！）：

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

基本思想是template<int> using Void = void;要求Void<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，那么通用lambda 3将通过SFINAE丢失该方法。

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

l是常量表达式？

可以通过StaticStruct::MyMin_constexpr(1,3)来调用l吗？

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

下一个代码返回auto ty很简单 if和仅当std:true_type（我们的通用lambda）可以使用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);
}

Answer 2

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

是;有办法。

也适用于C ++ 11。

Google-ing我找到了strange poisoning way（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永远是假的）所以没有必要使用声明为no_symbol但从未定义的extern（并且throw()无法在编译时使用。）

如果您使用MyMin()运行时，throw(no_symbol)已编译，no_symbol在链接阶段出错。

更一般地说，有a proposal（来自Scott Schurr），但我不知道实施。

---编辑---

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

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

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

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

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

示例：如果MyMin()返回a和b之间的最小值，但a和b将是不同的，或者MyMin()应该是constexpr float MyMin (float a, float b) { return a != b ? throw (no_symbol) : (a < b ? a : b) ; }给编译器错误（不是一个很好的例子......我知道），所以

a != b

有效，因为编译器无法优化throw()并且必须编译（给出链接器错误）{{1}}部分。

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

2 个答案: