const in C/C++

1.const 对象必须初始化，因为一旦创建后值不能改变。

Eg：

　　const int i = GetSize(); //正确:运行时初始化

　　const int j = 42;   //正确：编译时初始化

　　j = 33;   //错误：试图向const对象写值

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

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

若想在多个文件内工作，只在一个文件中定义const，而在其他多个文件中声明并使用它。

解决办法，对于const变量，不论声明定义都加extern，这样只需定义一次即可。

Eg：

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

　　Extern const int bufSize = fcn();

　　//file1.h

　　Extern const int bufSize; //与file1.cc 中定义的bufSize是同一个

3.把引用绑定到const对象上，称之为 对常量的引用

Eg1：

　　const int c = 1024;

　　const int &r1 = c;    //正确

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

　　int &r2 = c;       //错误：试图让一个非常量引用指向一个常量引用

Eg2:  int i = 42；

const int &r1 = i; //允许将const int& 绑定到一个普通int上

const int &r2 = 42;    //正确：r2是一个常量引用

const int &r3 = r1*2;   //正确：r3是一个常量引用

int &r4 = r1 * 2;      //错误：r4是一个普通的非常量引用

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

Eg:   int i = 42;

int &r1 = i;

const int &r2 = i; //r2绑定对象i，但不允许通过r2修改i值

r1 = 0; //r1并非常量，i的值为0

r2 = 0; //错误：r2是一个常量引用

引用一个非const对象,即对象是个非常量，所以允许通过其他途径改变其值。

4.const指针

指针是对象，允许把指针本身定为常量。常量指针必须初始化，则指针的值(存放指针中的地址)不能再改变了。

把*放在const前，用以说明指针是一个常量，即不变的是指针本身而非指向的值。

Eg： int errNumb = 0;

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

const double pi = 3.14159;

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

从右往左读：

①离curErr最近的是const，意味着curErr本身是一个常量对象。

②下一个是*，curErr是一个常量指针。

③int：常量指针指向一个int对象

同理，pip是一个常量指针，指向一个双精度浮点型常量。

指针本身是一个常量并不意味着不能通过指针修改其所指对象的值。

Eg：分析int const *p,  const int*p,  int *const p , const int *const p的异同之处

int const *p,  const int*p这两个没区别，p指向的地址可变，p指向的内容不可变，

int *const p , p指向的地址不可变，p指向的内容可变

const int *const p  p指向的地址不可变，p指向的内容不可变

5.顶层const

顶层const 表示指针本身是个常量。

底层const 表示指针所指的对象是一个常量。

Eg：int i = 0;

　　int *const p1 = &i; //不能改变p1值，顶层

　　const int ci = 42; //不能改变ci值，顶层

　　const int *p2 = &ci;     //允许改变p2值，底层

　　const int *const p3 = p2;    //靠右的const顶层，靠左底层

　　const int & r =ci; //用于声明引用的const都是底层const

执行对象拷贝操作：

顶层const不受影响：不会改变被拷贝对象的值，无影响。

Eg： i = ci; //正确：拷贝ci值，ci顶层const，无影响

p2 =p3; //正确：p2 p3指向对象类型相同。p3顶层const的部分不影响

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

Eg： int *p = p3; //错误：p3包含底层const，p1无

p2 = p3; //正确：p2 p3 都是底层const

p2 = &i; //正确：int * 能转换成 const int *

int &r = ci; //错误：试图让一个非常量引用指向一个常量引用

const int &r2 = i; //正确：r2绑定对象i，但不允许通过r2修改i值

　　　　　　　　　　//(对const引用可能引用一个非const对象)