C++ Primer：2.4 const限定符

其他章节：C++ Primer 学习心得

对值不能被改变的变量，使用关键字const对加以限定。

• 对已定义为const的对象的赋值行为将引发错误。
• const对象一旦创建后其值就不能再改变，const对象必须初始化。

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

初始化和const

• const类型的对象上只能执行不改变其内容的操作。
• 初始化不改变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.c 定义并初始化了一个常量，该常量能被其他文件访问
extern const int bufSize = fcn();  // extern加以限定才能被其他文件使用
// file_l.h头文件
extern const int bufSize; // 与file_l.c中定义的bufSize是同一个
// extern指明bufsize并非本文件独有，定义将出现在别处

---

如果想在多个文件之间共享const对象，必须在变量的定义之前添加extern关键字。

const的引用（常量引用）

把引用绑定到const对象上，称之为对常量的引用，对常量的引用不能被用作修改它所绑定的对象。

const int ci = 1024;
const int &r1 = ci;     // 正确:引用及其对应的对象都是常量
r1 = 42;                // 错误:r1是对常量的引用
int &r2 = ci;           // 错误:试图让一个非常量引用指向一个常量对象
// 不允许直接为ci赋值，也不能通过引用去改变ci，对r2的初始化时错误的。

初始化对const的引用

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

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

double dval = 3.14;
const int &ri = dval;
// 编译器将上述代码转换为：
const int temp = dval;  // 由双精度浮点数生成一个临时的整型常量
const int &ri =temp;    // 让ri绑定这个临时量

对const的引用并非const的对象

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

int i = 42;         
int &rl = 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指针

指针是对象而引用不是，允许把指针本身定为常量。常量指针必须初始化，初始化完成则它的值（存放在指针的地址）就不能再改了。不变的是指针本身的值。

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

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

*pip = 2.72;    // 错误：pip是指向常量的指针
*curErr = 0;    // 正确：

---

int i = -1, &r = 0;       // 不合法，&r不是常量引用
int *const p2 = &i2;      // 合法，如果i2是const int则非法
const int i = -1, &r = 0; // 合法，&r常量引用
const int *const p3 = &i2;// 合法
const int *p1 = &i2;      // 合法
const int &const r2;      // 不合法，没有初始化
const int i2 = i, &r = i; // 合法

int i, *const cp;        // 不合法，常量指针必须初始化
int *p1, *const p2;      // 不合法，常量指针必须初始化
const int ic, &r = ic;   // 不合法，常量ic必须初始化
const int *const p3;     // 不合法，常量指针必须初始化
const int *p;            // 合法，指向常量的指针可以不初始化

i = ic;          // 合法
p1 = p3;         // 不合法，常量p3必须使用指向常量的指针
p1 = ⁣        // 不合法，常量ic必须使用指向常量的指针
p3 = ⁣        // 不合法，p3常量指针不能再次赋值
p2 = p1;         // 不合法，p2常量指针不能再次赋值
ic = *p3;        // 不合法，ic是const int，不能再次赋值

顶层const

指针本身是一个对象，又可以指向另外一个对象。
指针本身是不是常量以及指针所指的是不是常量是两个独立的问题。

• 顶层const表示指针本身是个常量，可以表示任意的对象是常量，对任何数据类型都适用（算术类型、类、指针const int v = 0;）。
• 底层const表示指针所指的对象是一个常量，与指针和引用等复合类型的基本类型部分有关。

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

执行对象的拷贝操作时，顶层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上

constexpr和常量表达式

常量表达式是指值不会改变并且在编译过程中就能得到计算结果的表达式。

• 字面值属于常量表达式，常量表达式初始化的const对象也是常量表达式。
• 一个对象或表达式是不是常量表达式由它的数据类型和初始值共同决定。

const int maxfiles = 20;     // max files是常量表达式
const int limit = max_files + 1; // limit是常量表达式，编译过程就能得到计算结果。
const int sz = get_size();   // sz不是常量表达式，sz是常量，但具体的值在运行时才能得到。

constexpr变量

将变量声明为constexpr类型以便由编译器来验证变量的值是否是一个常量表达式。
constexpr的变量一定是一个变量，必须用常量表达式初始化。

• 允许定义一种特殊的constexpr函数，编译时就能计算得到结果，可以用constexpr函数来初始化constexpr变量。

---

认定变量是一个常量表达式，就把它声明成constexpr类型。

字面值类型

算术类型、引用和指针都属于字面值类型，可定义为constexpr。
自定义类不属于字面值类型，不能定义为constexpr。

• 指针和引用定义为constexpr其初始值受到严格限制，constexpr指针的初始值必须是nullptr或者0，或者是存储于某个固定地址中的对象。

指针和constexpr

在constexpr声明中定义了一个指针，限定符constexpr仅对指针有效，对指针所指对象无关。

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

constexpr把它所定义的对象置为顶层const。
constexpr指针既可以指向常量也可以指向一个非常量。