C++学习笔记—— const 限定符

const 限定符

可以用关键字 const 对变量的类型加以限定。

例如：

const int bufsize = 512;   // 输入缓冲区大小

这样就把 bufsize 定义成了一个常量。 任何试图为 bufsize 赋值的行为都将引发错误：

bufsize = 512；     // 错误：试图向 const 对象写值

const 对象一旦创建后其值就不能再改变，所以 const 对象必须初始化。

初始化可以是任意复杂的表达式：

const int i = get_size();     // 正确：运行时初始化
const int j = 42;             // 正确：编译时初始化
const int k;                  // 错误：k是一个未经初始化的常量

初始化和 const

只能在 const 类型的对象上执行不改变其内容的操作。

例如，const int 和普通的 int 一样都能参与算术运算，也都能转换成一个布尔值，等等。

在不改变 const 对象的操作中还有一种是初始化，如果利用一个对象去初始化另外一个对象，则它们是不是 const 都无关紧要：

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

拷贝一个对象的值并不会改变它，一旦拷贝完成，新的对象就和原来的对象没什么关系了。

默认状态下，const 对象仅在文件内有效

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

为了执行上述替换，编译器必须知道变量的初始值。
如果程序包含多个文件，则每个用了 const 对象的文件都必须得到访问它的初始值才行。
必须在每一个用到变量的文件中都有对它的定义。

默认情况下，const对象被设定为仅在文件内有效。
当多个文件中出现了同名的 const 变量时，其实等同于在不同文件分别定义了独立的变量。

只在一个文件中定义 const ，而在其他多个文件中声明并使用它。
解决的办法是，对于const 变量不管是声明还是定义都添加 extern 关键字，这样只需定义一次就可以了：

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

const 的引用

可以把引用绑定到 const 对象上，就像绑定到其他对象上一样，称之为 对常量的引用。

与普通引用不同的是，对常量的引用不能被用作修改它所绑定的对象：

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

初始化和对 const 的引用

在初始化常量引用时允许用任意表达式作为初始值，只要该表达式的结果能转换成引用的类型即可。
允许为一个常量引用绑定非常量的对象、字面值，甚至是个一般表达式：

int i = 42;              
const int &r1 = i;       // 允许将 const int& 绑定到一个普通int对象上
const int &r2 = 42;      // 正确：r1 是一个常量引用
const int &r3 = r1 * 2;  // 正确：r3 是一个常量引用
int &r4 = r1 * 2;        // 错误：r4 是一个普通的非常量引用

临时量对象就是当编译器需要一个空间来暂存表达式的求值结果时临时创建的一个未命名的对象。
常常把临时量对象简称为临时量。

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

常量引用仅对引用可参与的操作做出了限定，对于引用的对象本身是不是一个常量未作限定。

因为对象也可能是个非常量，所以允许通过其他途径改变它的值：

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

指针和 const

与引用一样，也可以令指针指向常量或非常量。

指向常量的指针不能用于改变其所指对象的值。

要想存放常量对象的地址，只能使用指向常量的指针：

const double pi = 3.14;     // pi是个常量，它的值不能改变
double *ptr = π          // 错误：ptr 是一个普通指针
const double *cptr = π   // 正确：cptr 可以指向一个双精度常量
*cptr = 42;                 // 错误：不能给 *cptr 赋值

指针的类型必须与其所指对象的类型一致，但是有两个例外。
第一种例外情况是允许令一个指向常量的指针指向一个非常量对象：

double dval  = 3.14;      // dval 是一个双精度浮点数，它的值可以改变
cptr = &dval;             // 正确：但是不能通过cptr 改变 dval 的值

和常量引用一样，指向常量的指针也没有规定其所指的对象必须是一个常量。
所谓指向的常量的指针仅仅要求不能通过该指针改变对象的值，而没有规定那个对象的值不能通过其他途径改变。

const 指针

常量指针必须初始化，而且一旦初始化完成，则它的值（也就是存放在指针中的那个地址）就不能再改变了。

把 * 放在 const 关键字之前用以说明指针是一个常量，隐含意味，即不变的是指针本身的值而非指向的那个值。

int errNumb = 0;
int *const curErr = &errNumb;      // curErr 将一直指向 errNumb
const double pi = 3.14159;
const double *const pip = π     // pip 是一个指向常量对象的常量指针

指针本身是一个常量并不意味着不能通过指针修改其所指对象的值，能否这样做完全依赖于所指对象的类型。

顶层 const

指针本身是一个对象，它又可以指向另外一个对象。

用名词顶层 const 表示指针本身是个常量，而用名词底层 const 表示指针所指的对象是一个常量。

顶层const可以表示任意的对象是常量，这一点对任何数据类型都适用，如算术类型、类、指针等。
底层const则与指针和引用等复合类型的基本类型部分有关。

特殊的是，指针类型既可以是顶层const也可以是底层const：

int i = 0;
int *const P1 = &i;    //不能改变P1的值，这是一个顶层const
const int ci = 42;    //不能改变ci的值，这是一个顶层const
const int *p2 = &ci;   //不能改变P2的值，这是一个底层const
const int *const p3 = p2;  //靠右的 const 是顶层 const，靠左的是底层const
const int &r = ci;     //用于声明引用的 const 都是底层 const

当执行对象的拷贝操作时，常量是顶层const 还是底层const区别明显。

i = ci;   //正确：拷贝ci的值，ci是一个顶层const，对此操作无影响
p2 = p3;  //正确：p2 和 p3 指向的对象类型相同，p3顶层const的部分不影响

执行拷贝操作并不会改变被拷贝对象的值，因此，拷入和拷出的对象是否是常量都没什么影响。

底层const的限制却不能忽视。
当执行对象的拷贝操作时，拷入和拷出的对象必须具有相同的底层const资格，或者两个对象的数据类型必须能够转换。

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

学习参考资料：

C++ 中文版 Primer   （第5版）