C++ 11 新特性 constexpr 使用总结

constexpr 定义

常量表达式，指的就是由多个（≥1）常量组成的表达式。换句话说，如果表达式中的成员都是常量，那么该表达式就是一个常量表达式。这也意味着，常量表达式一旦确定，其值将无法修改。以定义数组为例，数组的长度就必须是一个常量表达式

int url[10];//正确
int url[6 + 4];//正确
int length = 6;
int url[length];//错误，length是变量

C++ 程序的执行过程大致要经历编译、链接、运行这 3 个阶段。
1、非常量表达式只能在程序运行阶段计算出结果；
2、常量表达式的计算往往发生在程序的编译阶段，这可以极大提高程序的执行效率，因为表达式只需要在编译阶段计算一次，节省了每次程序运行时都需要计算一次的时间。

那么在实际开发中，如何才能判定一个表达式是否为常量表达式，进而获得在编译阶段即可执行的“特权”呢？除了人为判定外，C++11 标准提供了 constexpr 关键字。 `constexpr 关键字的功能是使指定的常量表达式获得在程序编译阶段计算出结果的能力，而不必等到程序运行阶段。C++ 11 标准中，constexpr 可用于修饰普通变量、函数（包括模板函数）以及类的构造函数。

constexpr 修饰普通变量

使用 constexpr 修改普通变量时，变量必须经过初始化且初始值必须是一个常量表达式

#include <iostream>
using namespace std;
int main()
{
    constexpr int num = 1 + 2 + 3; 
    int url[num] = {1,2,3,4,5,6};
    couts<< url[1] << endl;  // 输出 2
    return 0;
}

两个尝试
（1） 将 constexpr 删除，此时编译器会提示“url[num] 定义中 num 不可用作常量”。
（2） 将此示例程序中的 constexpr 用const关键字替换也可以正常执行，这是因为 num 的定义同时满足num 是 const 常量且使用常量表达式为其初始化”这 2 个条件，由此编译器会认定 num 是一个常量表达式。

constexpr 修饰函数

constexpr 还可以用于修饰函数的返回值，这样的函数又称为“常量表达式函数” 一个函数要想成为常量表达式函数，必须同时满足如下 4 个条件。

• 1、整个函数的函数体中，除了可以包含 using 、typedef以及static_assert断言外，只能包含一条 return 返回语句。
• 2、该函数必须有返回值

constexpr int display(int x) {
    int ret = 1 + 2 + x; // 无法通过编译的，函数内部包含多条语句
    return ret;          // 替换为 return 1 + 2 + x; 即可通过
}

• 3、函数在使用之前，必须有对应的定义语句。我们知道，函数的使用分为“声明”和“定义”两部分，普通函数调用只需要提前写好该函数的声明部分即可，但常量表达式函数在使用前，必须要有该函数的定义。
• 4、return 返回的表达式必须是常量表达式

int num = 3;
constexpr int display(int x){
    return num + x;
}
int main()
{
    //调用常量表达式函数
    int a[display(3)] = { 1,2,3,4 };  // 该程序无法通过编译，编译器报“display(3) 的结果不是常量”的异常。
    return 0;
}

constexpr 修饰类的构造函数

对于 C++ 内置类型的数据，可以直接用 constexpr 修饰，但如果是自定义的数据类型（用 struct 或者 class 实现），直接用 constexpr 修饰是不行的。当我们想自定义一个可产生常量的类型时，正确的做法是在该类型的内部添加一个常量构造函数

//自定义类型的定义
struct myType {
    constexpr myType(char *name,int age):name(name),age(age){};
    const char* name;
    int age;
    //其它结构体成员
};
int main()
{
    constexpr struct myType mt { "zhangsan", 10 };
    cout << mt.name << " " << mt.age << endl;
    return 0;
}

可以看到，在myType结构体中自定义有一个构造函数，借助此函数，用 constexpr 修饰myType 类型的 my 常量即可通过编译
注意，constexpr 修饰类的构造函数时，要求该构造函数的函数体必须为空，且采用初始化列表的方式为各个成员赋值时，必须使用常量表达式。

constexpr 修饰函数

注意，C++11 标准中，不支持用 constexpr 修饰带有 virtual 的成员方法。

class myType {
public:
    constexpr myType(const char *name,int age):name(name),age(age){};
    constexpr const char * getname(){
        return name;
    }
    constexpr int getage(){
        return age;
    }
private:
    const char* name;
    int age;
  };
 
int main()
{
    constexpr struct myType mt { "zhangsan", 10 };
    constexpr const char * name = mt.getname();
    constexpr int age = mt.getage();
    cout << name << " " << age << endl;
    return 0;
}

constexpr 修饰模板函数

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

struct myType {
    const char* name;
    int age;
};
//模板函数
template<typename T>
constexpr T dispaly(T t){
    return t;
}

int main()
{
struct myType stu{"zhangsan",10};
  // 当模板函数中以自定义结构体 myType 类型进行实例化时，由于该结构体中没有定义常量表达式构造函数，所以实例化后的函数不是常量表达式函数，此时 constexpr 是无效的；
 //普通函数
struct myType ret = dispaly(stu);  
cout << ret.name << " " << ret.age << endl;

   // 模板函数的类型 T 为 int 类型，实例化后的函数符合常量表达式函数的要求，所以该函数的返回值就是一个常量表达式。
    //常量表达式函数
    constexpr int ret1 = dispaly(10);
    cout << ret1 << endl;
    return 0;
}

constexpr 与 const 的区别

主要区别：const 变量的初始化可以延迟到运行时，而 constexpr 变量必须在编译时进行初始化

void dis_1(const int x){
    //错误，x是只读的变量
    array <int,x> myarr{1,2,3,4,5};
    cout << myarr[1] << endl;
}
 
void dis_2(){
    const int x = 5;
    array <int,x> myarr{1,2,3,4,5};
    cout << myarr[1] << endl;
}
 
int main()
{
   dis_1(5);
   dis_2();
}

可以看到，dis_1() 和 dis_2() 函数中都包含一个 const int x，但 dis_1() 函数中的x 无法完成初始化 array 容器的任务，而 dis_2() 函数中的x却可以。
这是因为，dis_1() 函数中的const int x只是想强调x是一个只读的变量，其本质仍为变量，无法用来初始化array 容器；而 dis_2() 函数中的const int x，表明 x 是一个只读变量的同时，x 还是一个值为 5 的常量，所以可以用来初始化 array 容器。
C++ 11标准中，为了解决 const 关键字的双重语义问题，保留了const表示“只读”的语义，而将“常量”的语义划分给了新添加的 constexpr 关键字加粗样式。因此 C++11 标准中，建议将 const 和 constexpr 的功能区分开，即凡是表达“只读”语义的场景都使用 const，表达“常量”语义的场景都使用 constexpr。 在上面的实例程序中，dis_2() 函数中使用const int x是不规范的，应使用 constexpr 关键字。

用 const 修饰了con_b变量，表示该变量“只读”，即无法通过变量自身去修改自己的值。在大部分实际场景中，const 和 constexpr 是可以混用的，例如：

const int a = 5 + 4;
constexpr int a = 5 + 4;

它们是完全等价的，都可以在程序的编译阶段计算出结果。但在某些场景中，必须明确使用 constexpr

constexpr int sqr1(int arg){
    return arg*arg;
}
 
const int sqr2(int arg){
    return arg*arg;
}
 
int main()
{
    array<int,sqr1(10)> mylist1;//可以，因为sqr1时constexpr函数
    array<int,sqr2(10)> mylist1;//不可以，因为sqr2不是constexpr函数
    return 0;
}

其中，因为sqr2()函数的返回值仅有 const 修饰，而没有用更明确的 constexpr 修饰，导致其无法用于初始化 array 容器（只有常量才能初始化array容器）。