何时使用constexpr:

只要有编译时间常数。

它在某些方面很有用

// constants:
const int MeaningOfLife = 42;

// constexpr-function:
constexpr int MeaningOfLife () { return 42; }

int some_arr[MeaningOfLife()];

将它与特质类或类似的类联系起来，它会变得非常有用。

它可以实现一些新的优化。Const传统上是类型系统的提示，不能用于优化(例如，Const成员函数可以合法地const_cast并修改对象，因此Const不能用于优化)。

Constexpr表示表达式真的是常量，前提是函数的输入是const。考虑:

class MyInterface {
public:
    int GetNumber() const = 0;
};

如果这在其他模块中公开，编译器不能相信GetNumber()在每次调用时不会返回不同的值——甚至在两次调用之间没有非const调用的情况下也不会返回不同的值——因为const可能已经在实现中被丢弃了。(显然，任何这样做的程序员都应该被枪毙，但语言允许这样做，因此编译器必须遵守这些规则。)

添加constexpr:

class MyInterface {
public:
    constexpr int GetNumber() const = 0;
};

编译器现在可以应用优化，缓存GetNumber()的返回值，并消除对GetNumber()的额外调用，因为constexpr是一个更强的保证，返回值不会改变。

简介

引入Constexpr并不是为了告诉实现可以在需要常量表达式的上下文中求值;一致性实现在c++ 11之前就已经证明了这一点。

实现无法证明的是某段代码的意图:

开发人员想用这个实体表达什么? 我们是否应该盲目地允许在常量表达式中使用代码，仅仅因为它碰巧有效?

没有警察，这个世界将会怎样?

假设您正在开发一个库，并意识到您希望能够计算区间(0,N]中每个整数的和。

int f (int n) {
  return n > 0 ? n + f (n-1) : n;
}

缺乏意图

如果在转换过程中传递的参数是已知的，编译器可以很容易地证明上述函数在常量表达式中是可调用的;但你并没有宣布这是一个意图——这只是碰巧的情况。

现在另一个人来了，读取你的函数，做和编译器一样的分析;“哦，这个函数在常量表达式中可用!”，然后写了下面的代码。

T arr[f(10)]; // freakin' magic

优化

作为一个“了不起的”库开发人员，您决定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的主要用途是声明意图。

如果一个实体没有被标记为constexpr——它从未打算在常量表达式中使用;即使是这样，我们也依赖编译器来诊断这样的上下文(因为它忽略了我们的意图)。

何时使用constexpr:

只要有编译时间常数。

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