一篇文章搞定Const限定符

Const限定符

const对象就是值不能被改变的“变量”，我们只能在const类型的对象上执行不改变其内容的操作。

1 初始化

const对象必须初始化，初始值可以是任意复杂的表达式。

const int i = 512;
const int j = get_size();

我们可以用非const类型的对象去初始化const对象。

int i = 512;
cosnt int ci = i;

默认情况下，const对象仅在文件内有效。如果想在多个文件间共享const对象，必须在变量的定义之前添加extern关键字。

2 const和引用

我们可以引用const对象，称之为对常量的引用（reference to const）。对常量的引用不能被用作修改它所绑定的对象。

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

对常量的引用的初始化

在初始化对常量的引用时允许用任意表达式作为初始值（引用类型和被引用对象不一致的一个特例），只要该表达式的结果能够转化成引用的类型即可，如：非常量的对象、字面值，甚至是一般表达式。

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

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

int i = 42;
const int &r1 = i;

如以上代码所示，我们虽然不能直接通过r1修改i 的值，但是我们可以直接给i赋值。

由于引用本身不是一个对象，所以就没有const引用。

3 const和指针

指向常量的指针（pointer to const）

与常量引用类似，指向常量的指针不能用于改变其所指对象的值。要想存放常量对象的地址，只能使用指向常量的指针。

const double pi = 3.14;		//pi是个常量
double *ptr = π				//错误，ptr是一个普通指针
const double *cptr = π	//正确，cptr是指向常量的指针
*cptr = 42；								//错误，指向常量的指针不能改变其所指对象的值

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

double dval = 1.28;
cptr = dval;

我们可以这样理解，所谓指向常量的指针或者引用，不过是指针和引用“自以为是”，它们觉得它们指向了常量，所以自觉的不去改变所指对象的值。

常量指针（const pointer）

由于指针本身是对象，我们可以把指针本身定为常量，称为常量指针。常量指针必须初始化，而且一旦初始化完成，它的值（也就是存放在指针中的那个地址）就不能改变了。（注意，常量指针要从右往左读）

int errNumb = 0;
int *const curErr = &errNumb;		//curErr将一直指向errNumb，curErr是一个指向int的常量指针
const double pi = 3.1415;
cosnt double *const pip = π	//pip是一个指向double常量的常量指针。

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

*pip = 2.72;	 //错误，pip所指的对象是常量，不能被改变
*curErr = 2；	//正确：curErr所指对象不是常量，可以通过指针改变

4 顶层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;	//p3既是顶层const，又是底层const，右边带*的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上