const限定符

有时候我们希望定义这样一种变量，它的值不能被改变。

为了满足这一要求，可以用关键字const对变量的类型加以限定：

const int haif = 512;//int型变量haif的值将不能被改变

---

#include <iostream>
using namespace std;int main() {const int haif = 512;haif = 250;//给haif赋值为250return 0;
}

任何试图为haif赋值的行为都将引发错误：

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

#include <iostream>
using namespace std;int main() {const int haif = 512;//正确const int xiaom;//错误return 0;
}

---

const类型与非const类型的区别，也是const类型的主要限制：
只能在const类型的对象上执行不改变其内容的操作。

---

初始化和const

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

#include <iostream>
using namespace std;int main() {int i = 42;const int ci = i;//正确；i的值被拷贝给了ciint j = ci;//正确；ci的值被拷贝给了j
}

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

---

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

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

让我们看看下面这行代码：

const int haif = 512;

编译器将在编译过程中把用到该变量的地方都替换成对应的值。也就是说，编译器会找到代码中所有用到haif的地方，然后用512替换。
为了执行上述替换，编译器必须知道变量的初始值。如果程序包含多个文件，则每个用了const对象的文件都必须得能访问到它的初始值才行。要做到这一点，就必须在每一个用到变量的文件中都有对它的定义。为了支持这一用法，同时避免对同一变量的重复定义，默认情况下，const对象仅在文件内有效。

---

有时候，我们需要只在一个文件中定义const，而在其他多个文件中声明并使用它。

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

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

const引用

我们把引用绑定到const对象上称为对常量的引用。

#include <iostream>
using namespace std;int main() {const int haif = 1024;const int &r1 = haif;//正确；引用及其对应的对象都是常量。return 0;
}

---

#include <iostream>
using namespace std;int main() {const int haif = 1024;int &r2 = haif;//错误；试图让一个非常量引用指向一个常量对象return 0;
}

假设该初始化合法，则可以通过r2来改变它引用对象的值，这显然是不正确的，因此，对r2的初始化是错误的。

初始化和对const的引用

首先，我们将“对const的引用”简称为常量引用。

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

第一种例外情况就是在初始化常量引用时，允许用任意表达式作为初始值，只要该表达式的结果能转换成引用的类型即可。

#include <iostream>
using namespace std;int main() {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 haif = 3.14;const int &r5 = haif;//正确。return 0;
}

为什么只要是常量引用，就允许用任意表达式作为初始值呢？

让我们看下面的代码：

	double haif = 3.14;const int &r5 = haif;//正确。

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

const int tmp = haif;
const int &r5 = tmp;

这里的tmp我们称为临时量。

那么因为这里的r5的常量引用，我们肯定不能通过r5改变其绑定的值，但是，如果r5不是常量引用，而是一个普通的非常量引用，那么我们可以看到此时r5绑定的并非haif，而是tmp，那我们想通过r5改变haif的值，肯定不是不可行的，因此C++语言也就把这种行为归为非法。

#include <iostream>
using namespace std;int main() {double haif = 3.14;int &r5 = haif;//非法return 0;
}

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

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

#include <iostream>
using namespace std;int main() {int haif = 42;int &r1 = haif;const int &r2 = haif;r1 = 0;r2 = 0;//错误，r2是一个常量引用，我们不能通过r2改变haif的值cout << haif << endl;return 0;
}

我们用r1改变了haif的值。

指针和const

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

#include <iostream>
using namespace std;int main() {const double haif = 3.14;//haif是个常量，它的值不能被改变double *r1 = &haif;//错误；r1是一个普通指针const double *r2 = &haif;//正确;r2可以指向一个双精度常量*r2 = 42;//错误；不能给*r2赋值return 0;
}

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

#include <iostream>
using namespace std;int main() {double a1 = 3.14;const double *r1;r1 = &a1;//正确double a2 = 3.14;const int *r2;r2 = &a1;//错误return 0;
}

tip：
试试这样想吧：所谓指向常量的指针或引用，不过是指针或引用“自以为是”罢了，它们觉得自己指向了常量，所以自觉地不去改变所指对象的值。

const指针

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

#include <iostream>
using namespace std;int main() {int haif = 0;int *const r1 = &haif;//r1将一直指向haifconst double pi = 3.14159;const double *const r2 = &pi;//r2是一个指向常量对象的常量指针return 0;
}

note：
指向常量的指针，其指针所指的对象的值不能改变。
常量指针，其指针所值的地址不能改变，也就是对象不能改变。
指向常量的常量指针，两者都不能改变。

顶层const

指针本身是一个对象，它又可以指向另外一个对象。因此，指针本身是不是常量以及指针所指的是不是一个常量就是两个相互独立的问题。用名词顶层const（top-level const）表示指针本身是个常量，而用名词底层const（low-level const）表示指针所指的对象是一个常量。

#include <iostream>
using namespace std;int main() {int i = 0;int *const p1 = &i;//不能改变pi的值，这是一个顶层constconst int ci = 42;//不能改变ci的值，这是一个顶层constconst int *p2 = &ci;//允许改变p2的值，这是一个底层constconst int *const p3 = p2;//靠右的const是顶层const，靠左的是底层constconst int &r = ci;//用于声明引用的const都是底层constreturn 0;
}

当执行对象的拷贝操作时，常量是顶层const还是底层const区别明显。其中，顶层const不受什么影响

底层const的限制却不能忽视。当执行对象的拷贝操作时，拷入和拷出的对象必须具有相同的底层const资格，或者两个对象的数据类型必须能够转换。一般来说，非常量可以转换成常量，反之则不行

#include <iostream>
using namespace std;int main() {int i = 0;int *const p1 = &i;//不能改变pi的值，这是一个顶层constconst int ci = 42;//不能改变ci的值，这是一个顶层constconst int *p2 = &ci;//允许改变p2的值，这是一个底层constconst int *const p3 = p2;//靠右的const是顶层const，靠左的是底层constconst int &r = ci;//用于声明引用的const都是底层consti = ci;//正确；拷贝ci的值，ci是一个顶层const，对此操作无影响p2 = p3;//正确；p2和p3指向的对象类型相同，p3顶层const的部分不影响int *p = p3;//错误;p3包含底层const含义，而p没有p2 = p3;//正确；p2和p3都是底层constp2 = &i;//正确;int*能转换成const int *int &r = ci;//错误;普通的int&不能绑定到int常量const int &r2 = i;//正确;const int& 可以绑定到一个普通的int上return 0;
}

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

创作不易！！！点个赞再走咯！！！