const 限定符

定义 const 对象 

const 限定符提供了一个解决办法，它把一个对象转换成一个常量。 

因为常量在定义后就不能被修改，所以定义时必须初始化 ：

const std::string hi = "hello!"; // ok: initialized
const int i, j = 0; // error: i is uninitialized const

const 对象默认为文件的局部变量

在全局作用域里定义非 const 变量时，它在整个程序中都可以访问。我们可以把一个非 const 变更定义在一个文件中，假设已经做了合适的声明，就可在另外的文件中使用这个变量：

// file_1.cc
int counter; // definition
// file_2.cc
extern int counter; // uses counter from file_1
++counter; // increments counter defined in file_1

与其他变量不同，除非特别说明，在全局作用域声明的 const 变量是定义该对象的文件的局部变量。此变量只存在于那个文件中，不能被其他文件访问。

通过指定 const 变更为 extern，就可以在整个程序中访问 const 对象：

// file_1.cc
// defines and initializes a const that is accessible to other files
extern const int bufSize = fcn();
// file_2.cc
extern const int bufSize; // uses bufSize from file_1
// uses bufSize defined in file_1
for (int index = 0; index != bufSize; ++index)
// ...

非 const 变量默认为 extern。要使 const 变量能够在其他的文件中访问，必须地指定它为 extern。

const的引用

 

可以把引用绑定到const对象上，就像绑定到其它对象上一样，我们称之为对常量的引用。与普通引用不同的是，对常量的引用不能被用作修改它所绑定的对象：

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

因为不允许直接为ival赋值，当然也就不能通过引用改变ival。

初始化和对const引用

引用的类型必须与其所引用的对象类型一致，但是有两个例外：

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

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

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

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

int i = 42;
int &r1 = i;    
const int &r2 = i;    
r1 = 0;        //r1并非常量，i的值修改为0
r2 = 0;        //错误，r2是一个常量引用

r2绑定整数i是合法的，然而不允许通过r2修改i的值。虽然如此，i的值仍然可以通过其它途径修改，既可以直接给i赋值，也可以通过像r1一样绑定到i的其它引用来修改。

指针和const

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

const double pi = 3.14;
double *ptr = π    //错误，ptr是一个普通指针
const double *cptr = π    //正确
*cptr = 42;        //错误，不能给*cptr赋值

通常指针的类型必须与其所指对象的类型一致，但是其中一个例外，就是允许令一个指向常量的指针指向非常量对象：

double dval = 3.14;
const double *cptr = &dval;        //正确，但是不能通过cptr改变dval的值

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

const指针

指针本身也可以是常量，常量指针必须初始化，而且一旦初始化完成，则它的值也就是存放在指针中的那个地址就不能再改变了。把*放在const关键字之前用以说明指针是一个常量，这样写的隐藏的含义是：不变的是指针本身的值而非指针指向的那个值：

int errnumb = 0;
int *const curerr = &errnumb;
const double pi = 3.14;
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 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上

p3既是顶层const也是底层const，拷贝p3时可以不在乎它是一个顶层const，但是必须清除它指向的对象是一个常量，因此不能用p3去初始化p，因为p指向的是一个普通的整数。另一方面，p3的值可以赋给p2，是因为这两个指针都是都是底层const，尽管p3同时也是一个常量指针即顶层指针，也就此次赋值而言不会有什么影响。

constexpr和常量表达式 

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

字面值属于常量表达式，用常量表达式初始化的const对象也是常量表达式。 

一个对象或表达式是不是常量表达式由它的数据类型和初始值共同决定：

const int max_flies = 20;    //max_flies是常量表达式
const int limit = max_files + 1;    //limit是常量表达式
int staff_size = 27;    //staff_size不是常量表达式
const int sz = get_size();    //sz不是常量表达式，sz的具体值只有运行时才能得到

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仅仅对指针有效，对指针所指的对象无关：

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

constexpr int *np = nullptr;    //np是一个指向整数的常量指针，其值为空
int j = 0;
constexpr int i = 42;    //i的类型是整型常量
constexpr const int *p = &i;    //p是常量指针，指向整型常量i
constexpr int *p1 = &j;    //p1是常量指针，指向整数j