constexpr

const

在 C++11 之前只有 const 关键字，从功能上来说这个关键字有双重语义：变量只读，修饰常量。
示例如下：

void func(const int num)
{
    const int count = 24;
    // int array[num];          // error，num 是一个只读变量，不是常量
    int array1[count];          // ok，count 是一个常量

    int a1 = 520;
    int a2 = 250;
    const int& b = a1;
    // b = a2;                  // error
    a1 = 1314;
    cout << "b: " << b << endl; // 输出结果为 1314
}

void func(const int num) 的参数 num 表示这个变量是只读的，但不是常量，使用 int array[num]; 这种方式定义一个数组，编译器会报错。
const int count = 24; 中的 count 是一个常量，可以使用这个常量来定义一个静态数组。
另外，变量只读并不等价于常量，二者不能混为一谈。
const int& b = a1; b 是一个常量的引用，所以 b 引用的变量是不能被修改的，b = a2; 这句代码语法是错误的。
const 对于变量 a1 是没有任何约束的，a1 的值改变 b 的值也就变了。引用 b 是只读的，但是并不能保证它的值是不可改变的，它不是常量。

constexpr

在 C++11 中添加了一个新的关键字 constexpr，这个关键字是用来修饰常量表达式的。
所谓常量表达式，指的就是由多个常量（值不会改变）组成并且在编译过程中就得到计算结果的表达式。

gcc/g++ 工作流程，C++ 程序从编写完到执行分为四个阶段：预处理、 编译、汇编和链接 4 个阶段，得到可执行程序之后就可以运行。
注意：常量表达式和非常量表达式的计算时机不同，非常量表达式只能在程序运行阶段计算出结果，但是常量表达式的计算发生在程序的编译阶段，这可以极大提高程序的执行效率，因为表达式只需要在编译阶段计算一次，节省了每次程序运行时都需要计算一次的时间。

编译器如何识别表达式是不是常量表达式呢？
在 C++11 中添加了 constexpr 关键字之后就可以在程序中使用它来修改常量表达式，用来提高程序的执行效率。使用中建议将 const 和 constexpr 的功能区分开，表达“只读”语义的场景都使用 const，表达“常量”语义的场景都使用 constexpr。

在定义常量时，const 和 constexpr 是等价的，都可以在程序的编译阶段计算出结果，例如：

const int i = 520;     // 是一个常量表达式
const int j = i + 1;   // 是一个常量表达式

constexpr int i2 = 520;   // 是一个常量表达式
constexpr int j2 = i + 1; // 是一个常量表达式

对于 C++ 内置类型的数据，可以直接用 constexpr 修饰；
如果是自定义的数据类型（struct 或者 class 实现），直接用 constexpr 修饰是不行的。

如果要定义一个结构体/类常量对象，示例如下：

#include <iostream>
using namespace std;

struct Test
{
    int id;
    int num;
};

int main()
{
    constexpr Test t {1, 2};
    constexpr int id = t.id;
    constexpr int num = t.num;
    // t.num += 100;  // error，不能修改常量
    cout << "id: " << id << ", num: " << num << endl;

    return 0;
}

在代码中 t.num += 100; 的操作是错误的，对象 t 是一个常量，因此它的成员也是常量，常量是不能被修改的。

常量表达式函数

为了提高 C++ 程序的执行效率，可以将程序中值不需要发生变化的变量定义为常量，也可以使用 constexpr 修饰函数的返回值，这种函数被称为常量表达式函数，这些函数主要包括以下几种：普通函数/类成员函数、类的构造函数、模板函数。

修饰函数

constexpr 并不能修改任意函数的返回值。函数成为常量表达式函数，必须要满足以下几个条件：
（1）函数必须要有返回值，并且 return 返回的表达式必须是常量表达式。

// error：没有返回值，不满足常量表达式函数要求
constexpr void func1()
{
    int a = 100;
    cout << "a: " << a << endl;
}

// error：返回值不是常量表达式，不满足常量表达式函数要求
constexpr int func2()
{
    int a = 100;
    return a;
}

（2）函数在使用之前，必须有对应的定义语句。

#include <iostream>
using namespace std;

constexpr int func1();

int main()
{
    constexpr int num = func1(); // error：还没有定义 func1() 就直接调用

    return 0;
}

constexpr int func1()
{
    constexpr int a = 100;
    return a;
}

（3）整个函数的函数体中，不能出现非常量表达式之外的语句。
using 指令、typedef 语句以及 static_assert 断言、return 语句除外。

// error：func1() 是一个常量表达式函数，在函数体内部是不允许出现非常量表达式以外的操作（for 循环是一个非法操作）
constexpr int func1()
{
    constexpr int a = 100;
    constexpr int b = 10;
    for (int i = 0; i < b; ++i)
    {
        cout << "i: " << i << endl;
    }
    return a + b;
}

// ok
constexpr int func2()
{
    using mytype = int;
    constexpr mytype a = 100;
    constexpr mytype b = 10;
    constexpr mytype c = a * b;
    return c - (a + b);
}

以上三条规则不仅对应普通函数适用，对应类的成员函数也适用。

修饰模板函数

C++11 语法中，constexpr 可以修饰函数模板，但由于模板中类型的不确定性，因此函数模板实例化后的模板函数是否符合常量表达式函数的要求也是不确定的。如果 constexpr 修饰的模板函数实例化结果不满足常量表达式函数的要求，则会被自动忽略，该函数就等同于一个普通函数。

#include <iostream>
using namespace std;

struct Person 
{
    const char* name;
    int age;
};

// 定义函数模板
template<typename T>
constexpr T display(T t) 
{
    return t;
}

int main()
{
    struct Person p { "luffy", 19 };
    // 普通函数
    struct Person ret = display(p);
    cout << "luffy's name: " << ret.name << ", age: " << ret.age << endl;

    // 常量表达式函数
    constexpr int ret1 = display(250);
    cout << ret1 << endl;

    constexpr struct Person p1 { "luffy", 19 };
    constexpr struct Person p2 = display(p1);
    cout << "luffy's name: " << p2.name << ", age: " << p2.age << endl;
    
    return 0;
}

示例程序中定义了一个函数模板 display()，但由于其返回值类型未定，因此在实例化之前无法判断其是否符合常量表达式函数的要求：
struct Person ret = dispaly(p); 由于参数 p 是变量，所以实例化后的函数不是常量表达式函数，此时 constexpr 是无效的。
constexpr int ret1 = dispaly(250); 参数是常量，符合常量表达式函数的要求，此时 constexpr 是有效的。
constexpr struct Person p2 = dispaly(p1); 参数是常量，符合常量表达式函数的要求，此时 constexpr 是有效的。

修饰构造函数

如果想用直接得到一个常量对象，也可以使用 constexpr 修饰一个构造函数，这样就可以得到一个常量构造函数。
常量构造函数有一个要求：构造函数的函数体必须为空，并且必须采用初始化列表的方式为各个成员赋值。

#include <iostream>
using namespace std;

struct Person 
{
    constexpr Person(const char* p, int age) : name(p), age(age)
    {}
    
    const char* name;
    int age;
};

int main()
{
    constexpr struct Person p1("luffy", 19);
    cout << "luffy's name: " << p1.name << ", age: " << p1.age << endl;
    
    return 0;
}

参考资料

https://subingwen.cn/cpp/constexpr/