声明：本文是学习《C++ Primer》（王刚 杨巨峰译）过程中记录下的摘抄笔记。感谢两位译者翻译之功！

有时，我们希望定义这样一种变量：它的值不能被改变。为了满足这一要求，可以使用关键字const对变量加以限定：

const int bufferSize = 512; 

const对象一旦创建后值就无法改变，所以const对象必须初始化。而且因为bufferSize是个常量，所以任何赋值操作都会引发错误；

初始化和const

对象的类型决定了对象所能参与的操作。对于const对象来说，主要的限制就是只能在const对象上执行不修改其内容的操作。例如，const int和int一样都能参与算术运算，也都能转换成布尔值。

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

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

虽然ci是个整型常量，但无论如何ci中的值还是一个整型数。ci的常量特征仅在执行改变ci的操作时才会发生作用。当用ci初始化j时，根本无须在意ci是不是一个常量。拷贝一个对象的值并不会改变它，一旦拷贝完成，新的对象就和原来的对象无甚关系了。

默认情况下，const对象仅在文件内有效

当以编译时初始化的方式定义一个const对象时，就如对bufferSize的定义一样：

const int bufferSize = 512; 

编译器在编译过程中把用到该变量的地方都替换成对应的值。也就是说，编译器会找到代码中所有用到bufferSize的地方，然后用512替换。

为了执行上述替换，编译器必须指导变量的初始值。如果程序包含多个文件，则每个用了const对象的文件都必须能访问得到它的初始值才行。要做到这一点，必须在每一个用到变量的文件中都有对它的定义。为了支持这一用法，同时避免对同一变量的重复定义，默认情况下，const对象被设定为仅在文件内有效。当多个文件中出现了同名的const变量时，其实等同于在不同文件中分别定义了独立的常量。

某些时候有这样一种const常量，它的初始值不是一个常量表达式，但又确实有必要在文件间共享。这种情况下，我们不希望编译器为每个文件分别生成独立的变量。相反，我们想让这类const对象像其他（非常量）对象一样工作，也就是说，只在一个文件中从医const，而在其他多个文件中声明并使用它。

解决的办法就是，对应const常量不管是声明还是定义都加上extern关键字。这样只需定义一次就可以了。：

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

因为buffersSize是个变量，必须用extern加以限定使其被其他文件使用；file_1.h头文件中的声明也由extern做了限定，其作用是指明bufferSize并非本文件独有，它的定义将在别处出现。

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

const的引用

把引用绑定到const对象上，我们称之为对常量的引用（reference to const)。与普通引用不同，对常量的引用不能用作修改它所绑定的对象。

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

初始化和对const的引用

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

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

要想理解这种例外情况的原因，最简单的办法就是弄清楚当一个常量引用被绑定到另外一种类型上时到底发生了什么：

double dval = 3.14;
const int &ri = dval;

此处ri引用了一个int型的数。对ri的操作应该是整数运算，但dval却是一个双精度浮点数而非整数。因此为了确保让ri绑定一个整数，编译器把上述代码变成了如下形式：

const int temp = dval;
const int &ri = temp;

这种情况下，ri绑定了一个临时量对象。所谓临时量对象就是当编译器需要一个空间暂存表达式的求值结果时临时创建的一个未命名的对象。

如果ri不是常量，允许对ri赋值，就会改变ri所引用对象的值。此时绑定的对象时一个临时量而非dval。程序员既然让ri引用dval，就肯定想通过ri改变dval的值，否则干什么要给ri赋值呢？所以C++语言将这种行为视为非法。

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

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

int i  = 42;
int &r1 = i; //应用ri绑定对象i
const int &r2 = i;   //r2也绑定对象 i ，但是不允许通过r2修改 i 的值
r1 = 0;                  // r1并非常量，可对 i 进行修改
r2 = 0;                  // r2为常量引用，不能修改绑定的对象i

指针和const

与引用类似，指针也可指向常量或非常量。指向常量的指针不能用于改变其所指对象的值。要想存放常量对象的地址，只能使用指向常量的指针。

const double pi = 3.14;
double *ptr = π             // 错误：ptr是普通指针，未作const修饰，无法指向常量
const double *cptr = π  // 正确：cptr可指向一个双精度常量
*cptr = 42;                         // 错误：cptr是指向常量的指针，不能赋值

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

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

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

const指针

指针是对象而引用不是，因此就像其他对象类型一样，允许把指针本身定义为常量。常量指针（const pointer)必须被初始化，而且一旦初始化完成，则它的值就不能再改变了。把 * 放在const前面用以说明指针是一个常量，这样的书写形式隐含着一层意味，即不变的是指针本身的值而非指向的那个值。

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

指针本身是一个常量并不意味着不能通过指针修改其所指对象的值，能否这样做完全依赖于所指对象的类型。例如，pip是一个指向常量的常量指针，则不论是pip所指的对象值还是pi自己存储的那个地址都不能改变。相反的，curErr指向的是一个一般的非常量整数，那么就完全可以用curErr去修改errNumb的值：

*pip = 2.3; //错误：pip是一个指向常量的指针
if (*curErr)
{
errorHandler();
*curErr = 0;  // 正确：把curErr所指的对象的值重置
}

顶层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
const int &r = ci;                    //用于声明引用的const都是底层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上

constexpr和常量表达式

常量表达式(const expression)是指值不会改变并且在编译过程就能得到计算结果的表达式。显然，字面值属于常量表达式，用常量表达式初始化的const对象也是常量表达式。

一个对象（或表达式）是不是常量表达式由它的数据类型和初始值共同确定，例如：

const int max_files = 20;          // max_files是常量表达式
const int limit = max_files +1 ;   //limit是常量表达式
int staff_size = 27;               // starff_size值会改变，不是常量表达式
const int sz = get_size();         //sz不是常量表达式，get_size()函数需运行时方能得到结果

constexpr变量

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

constexpr int mf = 20;      //20是常量表达式
constexpr int limit = mf+1; //mf+1是常量表达式
constexpr int sz = size();  //只有当size是一个constexpr函数时，才是一条正确的声明语句

尽管不能用普通函数作为constexpr变量的初始值，但是新标准允许定义一种特殊的constexpr函数。这种函数应该足够简单以使得编译时就可以计算结果，这样就能使用constexpr函数初始化constexpr变量了。

字面值类型

常量表达式的值需要在编译时就得到计算，因此对声明constexpr时用到的类型必须有所限制。因为这些类型一般比较简单、值也显而易见、容易得到，就把他们成为字面值类型。

算术类型、引用和指针都属于字面值类型，自定义类、IO库、string类型则不属于字面值类型，也就不能被定义成constexpr。

尽管指针和引用都能定义成constexpr，但它们的初始值却受到严格限制。一个constexpr指针的初始值必须是nullptr或者0，或者时存储于某个固定地址中的对象。

一般来说，函数体内定义的变量并非存放在固定地址中，因此constexpr指针不能指向这样的变量。相反，定义于函数体外的对象其地址固定不变，能用来初始化constexpr指针。

指针和constexpr

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

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

p和q的类型相差甚远，p是一个指向常量的指针，而q是一个常量指针，其中的关注在于constexpr把它所定义的对象置成了顶层const。