C++/C中const，常量引用等小细节

引用

引用该博客：点击查看

定义：

引用是对象的别名，引用本身不是对象，它只是已经存在的对象的另一个名字；

故所有对引用的操作均是对它所代表的对象的操作；

 

初始化：

定义一个引用的时候，必须初始化，其初始化值必须是一个对象；一般变量在初始化的时候，初始化值会被拷贝到这个变量对象中去；

由于引用本身不是对象，所以其初始化只是将它绑定到初始值对象上，而且引用一旦初始化完成，引用将始终和它的初始值对象绑定在一起，

无法再绑定其他的对象，因此定义引用必须初始化；

1. int a = 1;

2. int &ra = a;//定义一个引用ra,并将它绑定到a上

3. ra++; //现在ra是a的别名，对ra的操作，其实是对a的操作

引用的类型要与它绑定的对象严格的匹配，并且引用只能绑定到对象上：

以下初始化方式是错误的：

1. int &rb = 10;//错误，初始化值必须是一个对象

2. double d = 3.14;

3. int &rd = d; //错误，类型不匹配

const引用

定义：

将引用绑定到const对象上，则称这个引用为常量引用；

因此不能通过常量引用去修改它绑定的对象的值，因为其对象是const的；

 

初始化常量引用：

与前面普通引用的初始化不同，常量引用允许用任意表达式作为其初始值，只要该表达式的结果可以转换成引用的类型即可；

1. 1. const int &rb = 1;//允许将引用绑定到字面值上

2. 2. const int &rc = r1 * 2;//允许将引用绑定到常量表达式上

3. 3. double d = 3.14;

4. const int &rd = d;//允许

上面的三个例子执行时，由于初始值为不可寻址的值，或者类型不匹配的对象，编译器会生成临时对象，并将常量引用绑定到该临时对象上；如：
3中，编译器会先将double的d经过类型转换放到一个整形的临时对象中，然后将常量引用绑定到这个临时对象：

1. const int tmp = d; //生成临时变量

2. const int &rd = tmp; //绑定临时变量

因此，对于普通的引用，绑定对象必须严格的匹配： 因为如果类型不匹配，那么定义的引用会被绑定到一个临时对象上去，而在对引用做相

应的操作的时候，实际上操作的是临时对象，并非初始化时想要绑定的对象！而对于常量引用，因为其并不能修改绑定的对象，所以讲起绑定到

临时对象也是可以的。

 

由于const引用仅对引用可进行的操作作了限定，而对引用的对象本身是不是const没有做限定：

1. int i = 1;

2. int &ri = i;

3. const int &cri = i;

4. i++; //合法

5. ri++;//合法

6. cri++;//非法，cri是个const引用

 

下面看几个例子：

1. const int ca = 1;

2. int &rca = ca;//类型不匹配，将一个普通引用绑定到一个常量

3.  

4. int a = 1;

5. int *&ra = &a; //错误，因为ra为非常量引用,而a的地址值不是对象，编译器会产生临时对象存储a的地址值

6. const int *&rb = &a; //错误，因为rb也不是常量引用，等价于 int const *&rb = &a; rb为绑定到一个指向int常量的指针的普通引用；

7. const int * const &rc = &a; //正确，rc为绑定到一个指向int常量的指针的常量引用

8.  

9. int *pa = &a;

10. const int *&rd = pa;//正确