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实现移动到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 且我们的interest(MyMin_constexpr(1,3))表达式是常量表达式时,我们才能调用.如果我们替换1或3使用非常量参数,那么通用lambda l将通过SFINAE丢失方法.

因此,以下两个测试是等效的:

• 是StaticStruct::MyMin_constexpr(1,3)一个不变的表达？
• 可以l通过l(StaticStruct{})吗？

人们很容易简单地删除auto ty,并decltype(ty)从上面的拉姆达.但这会产生一个硬错误(在非常数情况下),而不是一个很好的替换失败.因此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__)

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是假的)所以不需要使用no_symbol声明extern但永远不会定义(并且throw()不能使用编译时).

如果使用MyMin()运行时,throw(no_symbol)则编译并no_symbol在链接阶段给出错误.

更一般地说,有一个提案(来自Scott Schurr),但我不知道实现.

---编辑---

正如TC所指出的那样(谢谢!)这个解决方案工作(如果工作和工作时)只是因为编译器没有在点上进行优化以了解a != a永远是错误的.

特别是,MyMin()工作(没有很好的优化),因为在这个例子中,我们使用浮点数,a != a如果a是NaN 则可以是真的,因此编译器检测到该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) ;
 }

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

当它是一个应该给出错误(编译或运行)的自然错误情况时,它是不同的:编译器无法优化和技巧工作.

示例:if 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()部分.