C++变量和基本类型4--const限定符

const说明

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

const int i =0;
i =10; //错误，试图向const对象写值

 　　因为const对象一旦创建后其值就不能再改变，所以const对象必须初始化，初始值可以是任意复杂的表达式。

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

初始化和const
 　　与非const类型所能参与的操作相比，const类型的对象能完成其中大部分，但也不是所有的操作都适合。主要的限制就是只能在const类型的对象上执行不改变其内容的操作。

默认状态下，const对象仅在文件内有效
 　　当多个文件中出现同名的const变量时，其实等同与在不同文件中分别定义了独立的变量。如果想要让一个const变量在其他文件中也能使用，解决办法是对于const变量不管是声明还是定义都添加extern关键字。

extern const int i = get_size(); //file1.cpp定义并初始化了一个常量，该常量能被其他文件访问
extern const int i; //file1.h指明i并非本文件所独有，它的定义将在别处出现

1.const的引用

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

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

 　　引用不允许直接为ci赋值，当然也就不能通过引用去改变ci。因此，r2的初始化是错误的。假设初始化合法，则可以通过r2来改变它的引用对象的值，这显然是不正确的。

常量引用是对const的引用
　　C++程序员经常把词组“对const的引用”简称为“常量引用”，这个简称还是挺靠谱的，不过前提是你得时刻记得这个就是一个简称而已。严格来说，并不存常量引用。因为引用不是一个对象，所以我们没法让引用本身恒定不变。事实上，由于C++语言并不允许随意改变引用绑定的对象，所以从这层意义上理解所有的引用又都算是常量。引用的对象是常量还是非常量可以决定其所能参与的操作，却无论如何都不会影响到引用和对象的绑定关系本身。

初始化和对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是一个普通的非常量引用

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

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

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

const int temp = dval; //由双精度浮点数生成一个临时的整型常量
const int &r = temp; //让引用绑定这个临时量

 　　在这种情况下，r绑定了一个临时量对象。所谓临时量对象就是当编译器需要一个空间来暂存表达式的求值结果时临时创建的一个未命名的对象，C++程序员常把临时量对象简称为临时量。
接下来探讨当r不是常量时，如果执行了类似上面的初始化过程将带来什么样的后果。如果r不是常量，就允许对r赋值，这样就会改变r所引用对象的值。注意，此时绑定的对象是一个临时量而非dval。程序员既然让r引用dval，就肯定想通过r改变dval的值，否则干什么要给r赋值呢。如此看来，既然大家基本不会想着把引用绑定到临时量上，C++语言也就把这种行为归为非法。

对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.指针和const

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

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

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

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

 　　和常量引用一样，指向常量的指针也没有规定其所指的对象必须是一个常量。所谓指向常量的指针仅仅要求不能通过该指针改变对象的值，而没有规定那个对象的值不能通过其他途径改变。
试试这样想，所谓指向常量的指针或者引用，不过是指针或引用“自以为是”摆了，它们觉得自己指向了常量，所以自觉地不去改变所指对象的值。

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

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

 　　要弄清楚这些声明的含义最行之有效的办法就是从右往左阅读。比如离i最近的符号是const，意味着i本身是一个常量对象，对象的类型由声明符的其余部分确定。声明符中的下一个符号是*，意思是i是一个常量指针。最后，该声明语句的基本数据类型部分确定了常量指针指向的是一个int对象。与之相似，我们也能推断出，pip是一个常量指针，它指向的是一个双精度浮点型常量。

3.顶层const和顶层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上

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

4.constexpr和常量表达式

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

const int max_files = 20; //max_files是常量表达式
const int limit = max_files+1; //limit是常量表达式
int staff_size = 27; //staff_size不是常量表达式
const int sz = get_size(); //sz不是常量表达式

 　　尽管staff_size的初始值是字面值，但由于它的数据类型只是一个普通int而非const int，所以它不属于常量表达式。另一方面，尽管本身是一个常量，但它的具体值直到运行时才能获取到，所以也不是常量表达式。

constexpr变量
 　　在一个复杂的系统中，很难分辨一个初始值到底是不是常量表达式。当然可以定义一个const变量并把它的初始值设为我们认为的某个常量表达式，但在实际使用时，尽管要求如此却常常发现初始值并非常量表达式的情况。可以这么说，在此种情况下，对象的定义和使用根本就是两回事。
 　　C++11新标准规定，允许将变量声明为constexpr类型以便由编译器来验证变量的值是否是一个常量表达式。声明为constexpr的变量一定是一个常量，而且必须用常量表达式初始化：

constexpr int mf = 20;  //20是常量表达式
constexpr int limit = mf + 1; //mf+1是常量表达式
constexpr int sz = get_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是一个底层const，指向整型常量的指针
constexpr int *q = nullptr; //q是一个顶层const，指向整型的常量指针

 　　p和q的类型相差甚远，p是一个指向常量的值，而q是一个常量指针，其中的关键在于constexpr把它所定义的对象置为了顶层const。
 　　与其他常量指针类似，constexpr指针既可以指向常量也可以指向一个非常量：

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