C++ constexpr

编译期的常量表达式，顾名思义是在编译期就求值得表达式。例如：

#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<int&>(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<int&>(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 <iostream>
#include <math.h>
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）代码组织到一起。隐藏数据成员和细节等。

转载于:https://www.cnblogs.com/thomas76/p/8545363.html