第2章 2.4 const限定符

2.4 const限定符

​ 如果用const关键字对变量的类型加以限定，那么这个变量就变成了一个常量。

​ const对象一旦创建后其值就不能改变，因此const对象必须初始化：

const int i = 512;   
i = 5;               // 错误：试图向const对象写值
const int j;         // 错误：j是一个未经初始化的常量

【初始化和const】

​ 在不改变const对象的操作中还有一种是初始化，如果利用一个对象去初始化另外一个对象，则它们是不是const都无关要紧，因为拷贝一个对象的值并不会改变它，一旦拷贝完成，新的对象和原来的对象就没什么关系了：

int i = 1;
const int ci = i;   // 正确：i的值被拷贝给了ci
int j = ci;         // 正确：ci的值被拷贝给了j

【const对象的有效范围】

​ 当以编译时初始化的方式定义一个const对象时，编译器将在编译过程中把用到该变量的地方都替换成对应的值，例如：

const int i = 2;  // 编译器会找到代码中所有用到i的地方，将它的值替换成2

​ 因此为了执行这种替换，编译器必须知道变量的初始值。默认情况下，const对象被设定为尽在文件内有效。当多个文件中出现了同名的const变量时，实际等同于在不同文件中分别定义了独立的变量。

​ 有时候有这样一种const变量，它的初始值不是一个常量表达式，但又确实有必要在文件中共享，那么解决的办法是：对于const变量不管是声明还是定义都添加extern关键字，这样只需要定义一次就可以了：

// file_1.cc定义并初始化了一个常量，该常量能被其它文件访问
extern const int i = 6;
// file_1.h 头文件
extern const int i;   // 与file_1.cc中定义的i是同一个

2.4.1 const的引用

​ 可以把引用绑定到const对象上，这称为对常量的引用。与普通引用不同，对常量的引用不能被用作修改它所绑定的对象：

const int ci = 1024;
const int &r1 = ci;    // 正确：引用及其对应的对象都是常量
r1 = 2;                // 错误：r1是对常量的引用
int &r2 = ci;          // 错误：试图用一个非常量来引用一个常量对象

上例中，由于ci是常量，不允许直接给它赋值，因此也就不能通过引用去改变其值，所以如果上述最后一条语句合法，则可以通过r2改变ci的值，这显然不正确。

【初始化和对const的引用】

​ 引用的类型必须与其所引用对象的类型一致，但也有两个例外，其中一种就是在初始化常量引用时允许用任意表达式作为初始值，只要该表达式的结果可以转换成引用的类型即可。尤其，允许为一个常量引用绑定字面值、非常量的对象，甚至是一个一般表达式:

int i = 42;
const int &r1 = i;      // 正确：允许为一个常量引用绑定非常量的对象
const int &r2 = 42;     // 正确：允许为一个常量引用绑定字面值
const int &r3 = r1 * 2; // 正确：允许为一个表达式
int &r4 = r1 * 2;       // 错误：不能为一个非常量引用绑定一个表达式

【对const的引用可能引用一个并非const的对象】

​ 常量引用仅对引用可参与的操作做出了限定，对于引用的对象本身是不是一个常量未作限定。因为对象也可能是个非常量，所以允许通过其它途径改变它的值：

int i = 42;
int &r1 = i;         // r1绑定对象i
const int &r2 = i;   // r2绑定对象i，但不允许通过r2修改i的值
r1 = 0;              // 正确：r1并非常量，所以可以将i的值改为0
r2 = 0;              // 错误：r2是一个常量引用

上例中，r2绑定（非常量）整数i是合法行往，但是不允许通过r2修改i的值。然而，i的值可以通过其它途径来修改：直接给i赋值，或者通过像r1一样绑定到i的其它引用来修改。

2.4.2 指针和const

​ 与引用一样，也可以令指针指向常量或非常量。类似于常量引用，指向常量的指针不能用于改变其所指对象的值：

const double pi = 3.14;     // pi是一个常量，值不能改变
double *ptr = π          // 错误：ptr是一个普通指针
const double *ptr1 = π   // 正确：ptr1是一个指向常量的指针
*ptr1 = 6.25;               // 错误：ptr1不能改变其所指的对象

​ 指针的类型必须与其所指对象的类型一致，除了两个例外，其中一个就是允许令一个指向常量的指针指向一个非常量对象。这和常量引用一样，指向常量的指针也没有规定其所指的对象一定是个常量。所谓指向常量的指针，仅仅要去不能通过该指针改变对象的值，而没有规定那个对象的值不能通过其它途径改变：

double dval = 3.14;
const double *ptr1 = &dval;  // 正确：但不能通过ptr1改变dval的值
dval = 6.39;                 // 正确：dval是个双精度浮点数，其值可以改变

【const指针】

​ 若一个指针被定位常量，则其称为常量指针。常量指针必须初始化，而且一旦初始化，其值（即存放在这个指针中的那个地址）就不能在改变了，这只是一味着指针本身的值不变，而不是指该指针所指向的那个值不变。把*放在const关键字之前用以说明指针是一个常量：

int i = 0;
int *const j = &i;   // j将一直指向i
const double pi = 3.14;
const double *const k = π // k是一个指向常量对象的常量指针

要弄清楚这些声明的含义最有效的方法就是从右向左读。此例中，离 j 最近的符号是const，意味着 j 本身是个常量对象，对象的类型由声明符剩下的部分决定。声明符中的下一个符号是*，意思是j是一个常量指针。最后，该声明语句的基本数据类型部分确定了常量指针指向的是一个int对象。

【注意】指针本身是个常量，并不意味着不能通过指针修改其所指对象的值，能否这样做完全取决于所指对象的类型。例如：

int i = 0;
int *const j = &i;
*j = 3;             // 正确

2.4.3 顶层const和底层const

​ 顶层const可以表示任意的对象是常量，这一点对任意数据类型都适用，如算术类型、类、指针等。例如可以用顶层const表示指针本身是一个常量。

​ 底层const则与指针和引用等复合类型的基本类型部分有关，例如用底层const表示指针所指的对象是个常量。

​ 比较特殊的，指针类型既可以是底层const，也可以是顶层const，这一点与其他类型相比区别明显：

int i = 0;
int *const ptr1 = &i;  // 顶层const，ptr1的值不能改变
const int j = 0        // 顶层const，j的值不能改变
const int *ptr2 = &j;  // 底层const，ptr2所指向的值不能改变，但ptr2自身的值可变
const int *const ptr3 = &j; // 靠左的const是底层const，靠右的const是顶层const
const int &r = j;      // 用于声明的const都是底层const

​ 当执行对象的拷贝操作时，拷入和拷出的对象必须具有相同的底层const资格，或者两个对象的数据类型必须能够转换，一般来说，非常量可以转换成常量，反之则不行：

int i = 0;
int *const ptr1 = &i;  // 顶层const，ptr1的值不能改变
const int j = 0        // 顶层const，j的值不能改变
const int *ptr2 = &j;  // 底层const，ptr2所指向的值不能改变，但ptr2自身的值可变
const int *const ptr3 = &j; // 靠左的const是底层const，靠右的const是顶层const
const int &r = j;      // 用于声明的const都是底层const

int *ptr = ptr3;  // 错误：ptr3包含底层const，而ptr没有
ptr2 = ptr3;      // 正确：ptr2和ptr3都是底层const
ptr2 = &i;        // 正确：int*可以转换成const int*
int &r = j;       // 错误：普通的int&不能绑定到int常量上
const int &r2 = i; // 正确：const int&可以绑定到一个普通int上

2.4.4 constexpr和常量表达式

​ 常量表达式是指不会改变并且在编译过程中就能得到计算结果的表达式。显然，字面值属于常量表达式，用常量表达式初始化 的const对象也是常量表达式。一个对象（表达式）是否为常量表达式，由它的数据类型和初始值共同决定，例如：

const int i = 20;     // i是常量表达式
const int j = i + 1;  // j是常量表达式
int k = 27;     // 尽管k的初始值是常量，但它的类型不是const int ，所以不是常量表达式
const int a = get();  //尽管a本身是常量，但具体的值需要运行时才知道，所以不是常量表达式

【constexpr变量】

​ c++11新标准规定，允许将变量声明为constexpr类型以便由编译器来验证变量的值是否为一个常量表达式。声明为constexpr的变量一定是一个常量，且必须用常量表达式初始化：

constexpr int m = 20;  // 20是个常量表达式
constexpr int n = m + 1; // m + 1 是常量表达式
constexpr int k = size(); // 只有当size()是一个constexpr函数才是一个正确的声明语句

【指针和constexpr】

​ 在constexpr声明中如果定义了一个指针，限定符constexpr仅对指针有效，与指针所指的对象无关：

const int *p = nullptr;   // p是一个指向整型常量的指针
constexptr int *q = bullptr； // q是一个指向整型的常量指针

上述例子中，p 和 q 相差甚远，p 是一个指向整型常量的指针，其自身的值可以修改；q是一个指向整型的常量指针，其自身的值不能修改，constexptr把它所定义的对象职位了顶层const。

​ 与其它常量指针类似，constexptr指针既可以指向常量也可以指向一个非常量：

constexptr int *ptr = nullptr; // ptr是一个指向整数的常量指针，其值为空
int j = 0;
constexptr int *ptr1 = &j;  //ptr1是常量指针，指向整数j
constexptr int i = 0;  // i的类型是整型常量
constexptr int *ptr2 = &i; // ptr2是常量指针，指向整型常量i