const 和 constexpr

const 和 constexpr

区分只读和常量

程序中用 const 修饰了 con_b 变量，表示该变量“只读”，即无法通过变量自身去修改自己的值，但这并不意味着 con_b 的值不能借助其它变量间接改变。通过改变 a 的值就可以使 con_b 的值发生变化。

#include 
using namespace std;
int main()
{
    int a = 10;
    const int & con_b = a;
    cout << con_b << endl;
    a = 20;
    cout << con_b << endl;
}
1
2
3
4
5
6
7
8
9
10

#include 
#include 
using namespace std;

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;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

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

constexpr 的好处

总的来说在 C++ 11 标准中，const 用于为修饰的变量添加“只读”属性；而 constexpr 关键字则用于指明其后是一个常量（或者常量表达式），编译器在编译程序时可以顺带将其结果计算出来，而无需等到程序运行阶段，这样的优化极大地提高了程序的执行效率。

常量表达式是什么

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

实际开发中，我们经常会用到常量表达式。以定义数组为例，数组的长度就必须是一个常量表达式：

// 1)
int url[10];//正确
// 2)
int url[6 + 4];//正确
// 3)
int length = 6;
int url[length];//错误，length是变量
1
2
3
4
5
6
7

上述代码演示了 3 种定义 url 数组的方式，其中第 1、2 种定义 url 数组时，长度分别为 10 和 6+4，显然它们都是常量表达式，可以用于表示数组的长度；第 3 种 url 数组的长度为 length，它是变量而非常量，因此不是一个常量表达式，无法用于表示数组的长度。

常量表达式的应用场景还有很多，比如匿名枚举、switch-case 结构中的 case 表达式等，感兴趣的读者可自行编码测试，这里不再过多举例。

constexpr 的用法

constexpr 修饰普通变量

C++11 标准中，定义变量时可以用 constexpr 修饰，从而使该变量获得在编译阶段即可计算出结果的能力。

值得一提的是，使用 constexpr 修改普通变量时，变量必须经过初始化且初始值必须是一个常量表达式。举个例子：

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

}
1
2
3
4
5
6
7

程序执行结果为：

2
1

读者可尝试将 constexpr 删除，此时编译器会提示“url[num] 定义中 num 不可用作常量”。

可以看到，程序第 6 行使用 constexpr 修饰 num 变量，同时将 “1+2+3” 这个常量表达式赋值给 num。由此，编译器就可以在编译时期对 num 这个表达式进行计算，因为 num 可以作为定义数组时的长度。

将此示例程序中的 constexpr 用 const 关键字替换也可以正常执行，这是因为 num 的定义同时满足

**“num 是 const 常量且使用常量表达式为其初始化”**这 2 个条件，由此编译器会认定 num 是一个常量表达式。

constexpr 修饰指针

const int *p=nullptr;  //指向常量的指针（返回值不可修改）
constexpr int *q =nullptr; // 常量指针，（指针本身不能修改）
 int *constexpr q =nullptr; // 没有这样的定义
1
2
3

当constexpr 定义了一个指针，那么constexpr 仅仅修饰这个指针本身不变，而不是指针所指向的这个对象

constexpr修饰函数

constexpr 还可以用于修饰函数的返回值，这样的函数又称为“常量表达式函数”。

注意，constexpr 并非可以修改任意函数的返回值。换句话说，一个函数要想成为常量表达式函数，必须满足如下 4 个条件。

只能包含一条 return 返回语句。

\1) 整个函数的函数体中，除了可以包含 using 指令、typedef 语句以及 static_assert 断言外，只能包含一条 return 返回语句。

举个例子：

constexpr int display(int x) {   
int ret = 1 + 2 + x;  
return ret;
}
1
2
3
4

注意，这个函数是无法通过编译的，因为该函数的返回值用 constexpr 修饰，但函数内部包含多条语句。

如下是正确的定义 display() 常量表达式函数的写法：

constexpr int display(int x) {   
//可以添加 using 执行、typedef 语句以及 static_assert 断言   
return 1 + 2 + x;
}
1
2
3
4

可以看到，display() 函数的返回值是用 constexpr 修饰的 int 类型值，且该函数的函数体中只包含一个 return 语句。

返回值类型不能是 void。

\2) 该函数必须有返回值，即函数的返回值类型不能是 void。

举个例子：

constexpr void display() {    //函数体}
1

像上面这样定义的返回值类型为 void 的函数，不属于常量表达式函数。原因很简单，因为通过类似的函数根本无法获得一个常量。

必须有对应的定义语句。

\3) 函数在使用之前，必须有对应的定义语句。

我们知道，函数的使用分为“声明”和“定义”两部分，普通的函数调用只需要提前写好该函数的声明部分即可（函数的定义部分可以放在调用位置之后甚至其它文件中），但常量表达式函数在使用前，必须要有该函数的定义。

举个例子：

#include using namespace std;//普通函数的声明
int noconst_dis(int x);//常量表达式函数的声明
constexpr int display(int x);//常量表达式函数的定义
constexpr int display(int x){ 
return 1 + 2 + x;
}
int main()
{    //调用常量表达式函数   
int a[display(3)] = { 1,2,3,4 };  
cout << a[2] << endl;    //调用普通函数  
cout << noconst_dis(3) << endl;   
return 0;
}//普通函数的定义
int noconst_dis(int x) {  
return 1 + 2 + x;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

程序执行结果为：

3
6
1
2

读者可自行将 display() 常量表达式函数的定义调整到 main() 函数之后，查看编译器的报错信息。

可以看到，普通函数在调用时，只需要保证调用位置之前有相应的声明即可；而常量表达式函数则不同，调用位置之前必须要有该函数的定义，否则会导致程序编译失败。

必须返回常量表达式

\4) return 返回的表达式必须是常量表达式，举个例子：

#include 
using namespace std;
int num = 3;
constexpr int display(int x){
return num + x;
}
int main(){
//调用常量表达式函数    int a[display(3)] = { 1,2,3,4 }; 
return 0;}
1
2
3
4
5
6
7
8
9

该程序无法通过编译，编译器报“display(3) 的结果不是常量”的异常。

常量表达式函数的返回值必须是常量表达式的原因很简单，如果想在程序编译阶段获得某个函数返回的常量，则该函数的 return 语句中就不能包含程序运行阶段才能确定值的变量。

注意，在常量表达式函数的 return 语句中，不能包含赋值的操作（例如 return x=1 在常量表达式函数中不允许的）。另外，用 constexpr 修改函数时，函数本身也是支持递归的，感兴趣的读者可自行尝试编码测试。

参考链接

C++11 constexpr：验证是否为常量表达式（长篇神文） (biancheng.net)

const 和引用

非常量引用不能指向常量对象

const int ci=0;
int &a =ci ; //存在通过a 修改ci 的风险
1
2

常量引用能绑定 非常量的对象，字面值，表达式，

int i=42;
const int &a =i;
const int &b =423;
const int &c =i*2;
const int&d=1.31;//会将1.31 转化为临时对象 1 再赋值给 d
1
2
3
4
5

 int &a =i*2;//错误 普通的非常量引用
1

const 和指针

非const 指针不能指向 常量

const double pi =3.14;
double *ptr =π//错误，存在修改常量的风险
const double *cptr=π
*cptr=11; 错误
1
2
3
4

和常量引用类似 常量指针 所指向的对象 可以不是常量

顶层const

指针（对象）本身是顶层，
1

pi ppi 均为顶层

const pi =5;
int *const ppi=π
1
2

底层 const

指针所指向的对象是常量
1

const int *ptr =25;
1