constexpr 真的需要吗？

Question

我一直在研究 C++ 的新 constexpr 功能，但我并不完全理解它的必要性。

例如，以下代码：

constexpr int MaxSize()
{
    ...

    return ...;
}

void foo()
{
    int vec[MaxSize()];
}

可以替换为：

int MaxSize()
{
    ...

    return ...;
}

static const int s_maxSize = MaxSize();

foo()
{
    int vec[s_maxSize];
}

Update

第二个示例实际上不是标准 ISO C++（感谢几位用户指出了这一点），但某些编译器（例如 gcc）支持它。因此，使程序有效的不是 const，而是 gcc 支持这种非标准功能。 （据我所知，只有当数组被定义为函数或方法的本地数组时，这才是可能的，因为全局数组的大小在编译时仍然必须已知。）如果我在不使用选项 -std= 的情况下进行编译c++98 -pedantic-errors，甚至代码

int MaxSize()
{
    return 10;
}

void foo()
{
    int vec[MaxSize()];
}

也会用 gcc 编译。

因此，我将尝试重新表述我的问题，考虑到目前为止收到的反馈（以及我同时完成的一些进一步阅读）。

我大量使用 const 关键字。使用 const，我可以定义一个在其整个生命周期内具有特定值的常量。常量可以使用任何表达式进行初始化，该表达式会计算一次，即在创建常量时。对于这些情况，我认为 constexpr 非常无用：它会引入一个非常小的优化，因为定义常量值的表达式将在编译时而不是运行时计算。每次我需要一个具有复杂初始化的运行时常量时，我​​都会使用关键字const。

因此，在我们需要在编译时初始化常量的情况下，constexpr 可能会派上用场。一个例子是向量定义：该标准不支持在运行时定义大小。另一个示例是具有一个或多个非类型参数的模板。

在这种情况下，我通常使用宏：

#define MAX_SIZE (10)

void foo()
{
    int vec[MAX_SIZE];
}

但是，如果我理解正确的话，constexpr 函数比宏更强大，因为它们允许在其定义中递归调用 constexpr 函数。然而，我想不出任何实际应用程序中我曾经想要使用如此复杂的计算来定义编译时常量。

因此，即使它可能是一个有趣的功能，我仍然想知道是否需要它（即它多久可以解决宏不够的情况）。也许看一些现实生活中无法用宏解决的例子会帮助我改变这个观点。

Answer 1

int vec[s_maxSize]; 在第二个示例中实际上是非法的，因此在 C++ 中不可能做到这一点。但你的第一个例子是完全合法的 C++0x。

这就是你的答案。实际上你不能按照你在 C++ 中建议的那样去做。它只能在 C++0x 中使用 constexpr 完成。

我还想指出，这段代码也适用于 C++0x。在 C++ 中执行此操作需要一些非常奇特的类模板。

constexpr unsigned int gcd(unsigned int const a, unsigned int const b)
{
   return (a < b) ? gcd(b, a) : ((a % b == 0) ? b : gcd(b, a % b));
}

char vec[gcd(30, 162)];

当然，在C++0x中你仍然必须使用三元运算符而不是if语句。但是，它可以工作，并且仍然比您在 C++ 中强制使用的模板版本更容易理解：

template <unsigned int a, unsigned int b>
class gcdT {
 public:
   static unsigned int const value = gcdT<b, a % b>::value;
};

template <unsigned int a>
class gcdT<a, 0> {
 public:
   static unsigned int const value = a;

};

char vec[gcdT<30, 162>::value];

然后，当然，在 C++ 中您仍然需要编写 gcd如果您需要在运行时计算事物，则可以使用 函数，因为模板不能与运行时变化的参数一起使用。 C++0x 会获得额外的优化提升，因为它知道函数的结果完全由传入的参数决定，这一事实只能用 C++ 中的编译器扩展来表达。

Answer 2

您可以使用 constexpr 执行但无法使用宏或模板执行的操作，即在编译时解析/处理字符串： 使用 constexpr 进行编译时字符串处理（更改大小写、排序等）。作为前面链接的一小段摘录，constexpr 允许编写如下代码：

#include "my_constexpr_string.h"
int main()
{
   using namespace hel;
   #define SDUMP(...) static_assert(__VA_ARGS__, "")

   SDUMP(tail("abc") == "bc");
   SDUMP( append("abc", "efgh") == "abcefgh" );
   SDUMP( prepend("abc", "efgh") == "efghabc" );
   SDUMP( extract<1,3>("help") == "el" );
   SDUMP( insert<1>("jim", "abc") == "jabcim" );
   SDUMP( remove("zabzbcdzaz", 'z') == "abbcdazzzz" );
   SDUMP( erase("z12z34z5z", 'z') == "12345"  );
   SDUMP( map("abc", ToUpper()) == "ABC" );
   SDUMP( find("0123456777a", '7') == 7 );
   SDUMP( isort("03217645") == "01234567");  
}

作为一个有用的示例，它可以促进某些解析器和正则表达式有限状态机的编译时计算/构造用文字字符串指定。可以推迟到编译时的处理越多，运行时执行的处理就越少。

Answer 3

int MaxSize() {
    ...

    return ...; }

static const int s_maxSize = MaxSize();

int vec[s_maxSize];

不，不能。那不是合法的 C++03。您有一个可以分配可变长度数组的编译器扩展。

Answer 4

constexpr 的另一个巧妙技巧允许 if 检测 编译时未定义的行为，这看起来是一个非常有用的工具。以下示例取自我链接的问题，使用 SFINAE 来检测添加是否会导致溢出：

#include <iostream>
#include <limits>

template <typename T1, typename T2>
struct addIsDefined
{
     template <T1 t1, T2 t2>
     static constexpr bool isDefined()
     {
         return isDefinedHelper<t1,t2>(0) ;
     }

     template <T1 t1, T2 t2, decltype( t1 + t2 ) result = t1+t2>
     static constexpr bool isDefinedHelper(int)
     {
         return true ;
     }

     template <T1 t1, T2 t2>
     static constexpr bool isDefinedHelper(...)
     {
         return false ;
     }
};


int main()
{    
    std::cout << std::boolalpha <<
      addIsDefined<int,int>::isDefined<10,10>() << std::endl ;
    std::cout << std::boolalpha <<
     addIsDefined<int,int>::isDefined<std::numeric_limits<int>::max(),1>() << std::endl ;
    std::cout << std::boolalpha <<
      addIsDefined<unsigned int,unsigned int>::isDefined<std::numeric_limits<unsigned int>::max(),std::numeric_limits<unsigned int>::max()>() << std::endl ;
}

这会导致 (现场观看）：

true
false
true

Answer 5

constexpr 允许以下内容工作：

#include<iostream>
using namespace std;

constexpr int n_constexpr() { return 3; }
int n_NOTconstexpr() { return 3; }


template<size_t n>
struct Array { typedef int type[n]; };

typedef Array<n_constexpr()>::type vec_t1;
typedef Array<n_NOTconstexpr()>::type vec_t2; // fails because it's not a constant-expression

static const int s_maxSize = n_NOTconstexpr();
typedef Array<s_maxSize>::type vec_t3; // fails because it's not a constant-expression

template 参数确实需要是常量表达式。您的示例有效的唯一原因是可变长度数组 (VLA) - 标准 C++ 中不存在的功能，但可能作为扩展出现在许多编译器中。

一个更有趣的问题可能是：为什么不在每个（const）函数上放置 constexpr ？有没有什么害处啊！

Answer 6

根据这个推理，您通常不需要常量，甚至不需要 #define。没有内联函数或任何东西。

与许多关键字一样，constexpr 的要点是让您更好地表达您的意图，以便编译器准确理解您想要的，而不仅仅是你告诉它的内容，这样它就可以在幕后为你做更好的优化。

在此示例中，它允许您编写可维护的函数来计算向量大小，而不仅仅是一遍又一遍地复制和粘贴的纯文本。