在我看来，拥有“总是返回5的功能”正在破坏或淡化“调用函数”的含义。必须有一个原因，或者需要这种能力，或者它不会出现在C ++ 11中。为什么会这样？
// preprocessor.
#define MEANING_OF_LIFE 42
// constants:
const int MeaningOfLife = 42;
// constexpr-function:
constexpr int MeaningOfLife () { return 42; }
在我看来，如果我编写了一个返回字面值的函数，并且我进行了代码审查，有人会告诉我，我应该声明一个常量值而不是写回返5。
答案 0 :(得分：279)
假设它做了一些更复杂的事情。
constexpr int MeaningOfLife ( int a, int b ) { return a * b; }
constexpr int meaningOfLife = MeaningOfLife( 6, 7 );
现在，您可以将某些内容评估为常量，同时保持良好的可读性，并允许稍微复杂的处理，而不仅仅是将常量设置为数字。
它基本上为可维护性提供了很好的帮助，因为它正在变得更加明显。以max( a, b )为例：
template< typename Type > constexpr Type max( Type a, Type b ) { return a < b ? b : a; }
这是一个非常简单的选择，但它确实意味着如果用常量值调用max，它将在编译时显式计算，而不是在运行时计算。
另一个很好的例子是DegreesToRadians函数。每个人都发现学位比弧度更容易阅读。虽然您可能知道180度是弧度，但更清楚地写如下：
constexpr float oneeighty = DegreesToRadians( 180.0f );
这里有很多好消息：
答案 1 :(得分：129)
constexpr没有被引入作为告诉实现可以在需要常量表达式的上下文中评估某些内容的方法;符合实现已经能够在C ++ 11之前证明这一点。
某个实现无法证明的是某段代码的 intent ：
constexpr的世界会是什么？假设您正在开发一个库并意识到您希望能够计算区间(0,N]中每个整数的总和。
int f (int n) {
return n > 0 ? n + f (n-1) : n;
}
如果传递的参数在翻译期间是已知的，编译器可以很容易地证明上述函数可以在常量表达式中调用;但你没有宣称这是一个意图 - 事实恰恰相反。
现在别人出现，读取你的功能，做与编译器相同的分析; “哦，这个函数可用于常量表达式！”，并写下以下代码。
T arr[f(10)]; // freakin' magic
作为“awesome”库开发人员，您决定f在调用时应该缓存结果;谁想要一遍又一遍地计算同一组价值？
int func (int n) {
static std::map<int, int> _cached;
if (_cached.find (n) == _cached.end ())
_cached[n] = n > 0 ? n + func (n-1) : n;
return _cached[n];
}
通过介绍你的愚蠢优化，你就破坏了你的函数的每一种用法，这些用法恰好出现在需要常量表达式的上下文中。
你从未承诺该函数可用于常量表达式，如果没有constexpr，就无法提供这样的承诺。
constexpr？constexpr 的主要用途是声明 intent 。
如果实体未标记为constexpr - 它从未打算用于常量表达式;即使它是，我们依靠编译器来诊断这样的上下文（因为它忽略了我们的意图）。
答案 2 :(得分：89)
拿std::numeric_limits<T>::max()：无论出于何种原因，这是一种方法。 constexpr在这里会很有用。
另一个例子：你想要声明一个与另一个数组一样大的C数组（或std::array）。目前这样做的方式是这样的：
int x[10];
int y[sizeof x / sizeof x[0]];
但能写的不是更好：
int y[size_of(x)];
感谢constexpr，您可以：
template <typename T, size_t N>
constexpr size_t size_of(T (&)[N]) {
return N;
}
答案 3 :(得分：17)
constexpr函数非常好用，是c ++的一个很好的补充。但是，你是对的，因为它解决的大部分问题都可以用宏来解决。
但是，constexpr的一个用法没有C ++ 03等效的类型常量。
// This is bad for obvious reasons.
#define ONE 1;
// This works most of the time but isn't fully typed.
enum { TWO = 2 };
// This doesn't compile
enum { pi = 3.1415f };
// This is a file local lvalue masquerading as a global
// rvalue. It works most of the time. But May subtly break
// with static initialization order issues, eg pi = 0 for some files.
static const float pi = 3.1415f;
// This is a true constant rvalue
constexpr float pi = 3.1415f;
// Haven't you always wanted to do this?
// constexpr std::string awesome = "oh yeah!!!";
// UPDATE: sadly std::string lacks a constexpr ctor
struct A
{
static const int four = 4;
static const int five = 5;
constexpr int six = 6;
};
int main()
{
&A::four; // linker error
&A::six; // compiler error
// EXTREMELY subtle linker error
int i = rand()? A::four: A::five;
// It not safe use static const class variables with the ternary operator!
}
//Adding this to any cpp file would fix the linker error.
//int A::four;
//int A::six;
答案 4 :(得分：14)
根据我的阅读，constexpr的需求来自元编程中的一个问题。 Trait类可能有常量表示为函数，think：numeric_limits :: max（）。使用constexpr，这些类型的函数可用于元编程，或作为数组边界等。
另一个例子是，对于类接口，您可能希望派生类型为某些操作定义自己的常量。
编辑：
答案 5 :(得分：11)
来自Stroustrup在“Going Native 2012”中的演讲：
template<int M, int K, int S> struct Unit { // a unit in the MKS system
enum { m=M, kg=K, s=S };
};
template<typename Unit> // a magnitude with a unit
struct Value {
double val; // the magnitude
explicit Value(double d) : val(d) {} // construct a Value from a double
};
using Speed = Value<Unit<1,0,-1>>; // meters/second type
using Acceleration = Value<Unit<1,0,-2>>; // meters/second/second type
using Second = Unit<0,0,1>; // unit: sec
using Second2 = Unit<0,0,2>; // unit: second*second
constexpr Value<Second> operator"" s(long double d)
// a f-p literal suffixed by ‘s’
{
return Value<Second> (d);
}
constexpr Value<Second2> operator"" s2(long double d)
// a f-p literal suffixed by ‘s2’
{
return Value<Second2> (d);
}
Speed sp1 = 100m/9.8s; // very fast for a human
Speed sp2 = 100m/9.8s2; // error (m/s2 is acceleration)
Speed sp3 = 100/9.8s; // error (speed is m/s and 100 has no unit)
Acceleration acc = sp1/0.5s; // too fast for a human
答案 6 :(得分：7)
另一个用途（尚未提及）是constexpr构造函数。这允许创建编译时常量，这些常量不必在运行时初始化。
const std::complex<double> meaning_of_imagination(0, 42);
将其与用户定义的文字对，并且您完全支持文字用户定义的类。
3.14D + 42_i;
答案 7 :(得分：6)
曾经存在元编程模式：
template<unsigned T>
struct Fact {
enum Enum {
VALUE = Fact<T-1>*T;
};
};
template<>
struct Fact<1u> {
enum Enum {
VALUE = 1;
};
};
// Fact<10>::VALUE is known be a compile-time constant
我相信引入constexpr是为了让你编写这样的结构，而不需要模板和带有特化，SFINAE和东西的奇怪结构 - 但就像你编写一个运行时函数一样，但有保证结果将在编译时确定。
但请注意：
int fact(unsigned n) {
if (n==1) return 1;
return fact(n-1)*n;
}
int main() {
return fact(10);
}
使用g++ -O3对此进行编译，您会发现fact(10)在编译时确实已被评估！
一个支持VLA的编译器（所以C99模式下的C编译器或带有C99扩展名的C ++编译器）甚至可以允许你这样做：
int main() {
int tab[fact(10)];
int tab2[std::max(20,30)];
}
但目前它是非标准的C ++ - constexpr看起来像是一种解决这个问题的方法（即使没有VLA，在上面的例子中）。而且仍然存在需要将“正式”常量表达式作为模板参数的问题。
答案 8 :(得分：5)
刚刚开始将项目切换到c ++ 11并且遇到了constexpr非常好的情况，它清理了执行相同操作的替代方法。这里的关键点是，只有在声明constexpr时，才能将函数放入数组大小声明中。在很多情况下，我可以看到这对我所涉及的代码区域非常有用。
constexpr size_t GetMaxIPV4StringLength()
{
return ( sizeof( "255.255.255.255" ) );
}
void SomeIPFunction()
{
char szIPAddress[ GetMaxIPV4StringLength() ];
SomeIPGetFunction( szIPAddress );
}
答案 9 :(得分：2)
所有其他答案都很棒，我只是想举一个很好的例子，你可以用constexpr做一件令人惊奇的事情。 See-Phit（https://github.com/rep-movsd/see-phit/blob/master/seephit.h）是一个编译时HTML解析器和模板引擎。这意味着您可以将HTML放入并获取可以操作的树。在编译时完成解析可以为您提供一些额外的性能。
从github页面示例：
#include <iostream>
#include "seephit.h"
using namespace std;
int main()
{
constexpr auto parser =
R"*(
<span >
<p color="red" height='10' >{{name}} is a {{profession}} in {{city}}</p >
</span>
)*"_html;
spt::tree spt_tree(parser);
spt::template_dict dct;
dct["name"] = "Mary";
dct["profession"] = "doctor";
dct["city"] = "London";
spt_tree.root.render(cerr, dct);
cerr << endl;
dct["city"] = "New York";
dct["name"] = "John";
dct["profession"] = "janitor";
spt_tree.root.render(cerr, dct);
cerr << endl;
}
答案 10 :(得分：1)
你的基本例子与常量本身的论点相同。为什么要使用
static const int x = 5;
int arr[x];
在
int arr[5];
因为它更易于维护。使用constexpr比现有的元编程技术更快，更快速地编写和读取。
答案 11 :(得分：0)
它可以启用一些新的优化。 const传统上是类型系统的提示，不能用于优化（例如const成员函数可以const_cast并且无论如何都要合法地修改对象，所以const无法信任优化）。
constexpr表示表达式真正是常量，前提是函数的输入是const。考虑：
class MyInterface {
public:
int GetNumber() const = 0;
};
如果在某个其他模块中公开了这一点，编译器就不能相信GetNumber()每次调用时都不会返回不同的值 - 即使连续没有非const调用 - 因为{{1可能已经在实现中抛弃了。 （显然任何执行此操作的程序员都应该被枪杀，但语言允许，因此编译器必须遵守规则。）
添加const：
constexpr编译器现在可以应用优化，其中class MyInterface {
public:
constexpr int GetNumber() const = 0;
};
的返回值被缓存，并消除对GetNumber()的额外调用，因为GetNumber()是一个更强的保证，返回值不会变化
答案 12 :(得分：0)
何时使用org.jumpmind.symmetric.ext.ISymmetricEngineAware：
答案 13 :(得分：-2)
对于像
这样的东西很有用// constants:
const int MeaningOfLife = 42;
// constexpr-function:
constexpr int MeaningOfLife () { return 42; }
int some_arr[MeaningOfLife()];
将它与特征类或类似物结合起来，它变得非常有用。