const限定符

　　有时候我们希望定义这样一种变量，它的值不能被改变。例如，用一个变量来表示缓冲区的大小，使用变量的好处是当我们觉得缓冲区大小不再合适时，很容易对其进行调整。另一方面，也应随时警惕防止程序一不小心改变了这个值，为了满足这一要求，可以用关键字const对变量的类型加以限定；

　　const int buffSize = 512；  //输入缓冲区的大小

这样就把buffSize定义成了一个常量，任何试图为buffSize赋值的行为都将引发错误；

　　buffSize = 512；  //错误，试图向const对象写值

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

　　const int i = get_size();  //运行时初始化

　　const int j = 42； //正确，编译时初始化

　　const int k; //错误，k是一个未经初始化的常量。

　　与非const类型所能参与的操作相比，const类型的对象能完成其中大部分，但也不是所有的操作都适合，主要的限制就是只能在const类型的对象上执行不改变其内容的操作。例如，const int和普通的int一样都能参与算术运算，也都能转换成一个布尔值，等等。

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

　　int i = 42；

　　const int ci = i； //正确，i的值

　　int j = ci; //正确，ci的值被拷贝给了j;

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

 

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

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

　　　　const int buffsize = 512；   //输入缓冲区大小

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

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

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

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

　　//file_1.cc定义并初始化了一个常量，该常量能被其他文件访问

　　extern const int buffsize = fcn();

　　//file_1.h 头文件

　　extern const int buffsize; //与file_1.cc中定义的buffsize是同一个

　　如上述程序所示，file_1.cc定义并初始化了buffsize。因为这条语句包含了初始值，所以它是一次定义，然而，因为buffsize是一个常量，必须用extern加以限定使其被其他文件使用。

　　file_1.h头文件中的声明也有extern做了限定，其作用是指明buffsize并非本文件所独有，它的定义将在别处出现。

 

　　const的引用　

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

　　const int ci = 1024;

　　const int &r1 = ci;   //正确，引用及其对应的对象都是常量。

　　r1 = 42;  //错误，r1是对常量的引用。

　　int &r2 = ci;  //错误，试图让一个非常量引用指向一个常量对象

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

 

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

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

　　int i = 42;

　　int &r1 = i; //引用ri绑定对象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的其他引用来修改

 

　　指针和const

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

　　const double pi = 3.14;  //pi是一个常量，它的值不能改变

　　double *ptr = &pi； //错误，ptr是一个普通指针，可以通过ptr修改pi的值

　　const double *cptr = &pi； //正确，cptr可以指向一个双精度常量

　　*cptr = 42； //错误，不能给*cptr赋值

　　但是允许令一个指向常量的指针指向一个非常量对象

　　double dval = 3.14; // dval是一个双精度浮点数，它的值可以改变

　　cptr = &dval； //正确，但是不能通过cptr改变dval的值

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

 

　　const指针

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

　　　　int errNum = 0;

　　　　int *const curErr = &errNum; //curErr 将一直指向errNum

　　　　const double pi = 3.14;

　　　　const double *const pip = π //pip是一个指向常量对象的常量指针

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

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

　　*pip = 2.17 //错误，pi是一个指向常量的指针

　　if（ *curErr ）

　　{

　　　　*curErr = 0; //正确。把curerr所指的对象的值重置

　　}