编译期的常量表达式，顾名思义是在编译期就求值得表达式。例如：
#define SIZE_OF_ARRAY(arr) (sizeof(arr)/sizeof(arr[0]))int main(){ const int N3 = 3 * 3 + 1; //3*3+1是编译期求值的常量表达式 char arr[N3]; std::cout << SIZE_OF_ARRAY(arr) << std::endl; //N3==10} 这些都是老套的传统代码，没什么稀奇的。现在改一下代码，如下所示：
int main(){ int x =0; std::cin>>x; const int N3 = x * x + 1; char arr[N3]; //编译失败，N3不可用作常量} 不奇怪的是，编译器识别出我的代码是傻子逻辑，因为N3是无法在编译期确定的，只能在运行期求值。
引人注意的是地方是，同样的const int 修饰的变量，却具有更隐蔽的性质。一个是具有编译期常量上岗证的，另一个没有编译期常量上岗证。
我们可以区分一下const int变量遇到不同的初始化器时具有的细微差别，代码如下：
int main(){ int x = 3; const int N = x * x + 1; std::cout << "before change. N=" << N << std::endl; //N==10 int& refN = const_cast (N); //强制更改它的值。 refN = 0; //这就是程序员控制一切的Ｃ＋＋世界 std::cout << "after change. N=" << N << std::endl; //N==0} 这里的N不是真的常量。它只是变量上加了个const标记，当不小心写代码改变它的值时（ex. N=100; ）编译器提醒你开车压了实线了。
如果你故意压实线（const_cast）,编译器就管不了了。现在，我们稍微改一下代码：
int main(){ const int N = 3 * 3 + 1; std::cout << "before change. N=" << N << std::endl; //N==10 int& refN = const_cast (N); //强制更改它的值。 refN = 0; // std::cout << "after change. N=" << N << std::endl; //N==10} 现在的N就是一个绝对的常量了。虽然在运行期仍旧可以强制更改它的值，但是当你引用它时，编译器把它当作了文字量一般的对待。
显然，const的这个微妙的区别，需要在语言层面表达出来。constexpr就发明出来了，用于表示“真正的，全生命周期的，真常量“。例如：
int main(){ constexpr int N = 3 * 3 + 1; //等价于 const int N=3*3+1; char arr[N]; std::cout << SIZE_OF_ARRAY(arr) << std::endl;} constexpr用于标记一个常量表达式。如果某个表达式不是编译期能计算的常量表达式，就会引发编译器报错，例如：
int main(){ int x = 3; constexpr int N = x * x + 1;//编译报错。提示x不是编译期可求值的。对比：const int N = x*x+1;可编译成功 char arr[N]; //更加错了。但是前一句先报错，把程序员的注意引导到真正的错误源上。} 既然是常量表达式，在编译期能求值的，我们为什么不人肉计算呢？例如：3*3+1 太繁琐，直接10多好？
答案是，为了避免魔术数字。经过长时间的代码维护阶段，后续的程序员可能无法理解10是什么意思了。
对应于魔术数字，还存在着魔术化的常量表达式。考虑下面的代码：
int main(){ char arr1[3 * 3 + 1]; char arr2[4 * 4 + 1]; char arr3[5 * 5 + 1];} 当需要修改 ”平方+1“这个表达式时，我们需要在全体代码中人肉搜索类似”2*2+1“这样的代码，然后修改之。这就是魔术化代码的弊端。
漏改，错改的可能性很大，软件质量无法保证。传统的解决方案是宏。#define CALCULATE( x) ((x)*(x)+1)
C++11 出现了constexpr标记一个常量表达式。例如：
constexpr int calculate(int x) { return x * x + 1; }int main(){ char arr1[calculate(3)]; char arr2[calculate(4)]; char arr3[calculate(5)]; int x = 6; std::cout << calculate(6) << std::end; //运行期时也能重用”平方+1“的业务逻辑} 对于那些仍旧坚持CALCULATE宏定义技术的人，下面的例子能清楚的说明宏定义弱爆了，代码如下：
constexpr int calculate(int x) { if (x%2==0) { return x * x; } else { return x * x + 1; }}int main(){ char arr[calculate(5)];} 请用宏的方式实现条件选择分支。。。写不出来。constexpr函数中能写if，写while，简直逆天了。（C++14开始支持这个特性）
下面是个小练习，利用编译期计算正弦函数。如何证明是在编译期进行的？最简单的方式，就是运行时无法在调试断点停住。复杂一点的方式，你可以把值赋值给constexpr标记的常量#include <iostream>namespace study
namespace study { //计算x的n次幂 constexpr double pow(double x, int exp) { auto result = 1.0f; for (int i = 0; i < exp; ++i) result *= x; //迭代。for循环 return result; } //计算n的阶乘 constexpr double fac(int n) { if (n > 1) { //条件分支 return n * fac( n-1 ); //递归 } else if (n == 1) { return 1; } } constexpr int sin(double x) { //sin(x) = x - x^3/3! + x^5/5! ... 级数展开 double result = x; //x result -= (pow(x, 3) / fac(3)); //-x^3/3! result += (pow(x, 5) / fac(5)); //+x ^ 5 / 5! return result; } } int main() { constexpr double result = study::sin( 3.14159f / 2 )； //证明sin是在编译期计算的方法。能否赋值给constexpr标记的变量。 std::cout << "result=" << result; //计算二分之一π正弦值，接近1。 } constexpr打开了一扇大门，让编译期的计算不再那么难搞。我们不需要什么奇淫技巧，只是利用正常人的思维，照搬（剽窃）普通函数的算法。
C++17开始，math库都已经改造成constexpr了。这意味着无需自己重复制造study::sin这样子的轮子了。
更引人注目的是，可以把自定义类型的对象（不仅仅是基本数据类型），标注为constexpr。这意味着，对象也能参与到常量表达式计算中。例子：
#include#include namespace study{ class Point { public: constexpr Point(double xVal = 0, double yVal = 0) noexcept : x(xVal), y(yVal) {} constexpr double distance( Point other) const noexcept { return std::sqrt( std::pow((x-other.x) ,2) + std::pow((y-other.y) ,2) ); } constexpr double distance() const noexcept { return std::sqrt(x*x+y*y); } private: double x, y; };}int main(){ using namespace study; constexpr Point pt{ 1.0f ,1.0f}; constexpr double result1 = pt.distance(); const Point other{ 0.0f ,0.0f}; constexpr double result2 = pt.distance(other); std::cout << "result2=" << result2; }
这意味着，在编译期计算时，可以封装数据和算法到一个类中。把多个相关的算法（例如distance）代码组织到一起。隐藏数据成员和细节等。