C++中const与指针、引用的分析

C++中函数的参数相比C语言中的函数参数要复杂的多，其中主要的原因是C++中引入了引用以及const限定符。这两个对象的引入，使得C++中的函数参数变得异常的复杂多变，每一种类型都具有比较适合的使用范围。

本文详细的分析const与指针、引用在一起存在情况下的情况分析。
首先介绍引用
引用是对象的别名，必须在初始化的过程中与一个具体的对象绑定起来，绑定完成以后就再也不能够修改了，引用貌似和指针有很大的相似性，但是引用是引用，是一个别名，而指针是一个变量，只是变量中保存的是对象的地址，引用并不分配新的内存空间。因此一个引用与一块内存区域绑定，是这块内存区域的别名，就如同数组名一样，数组是内存中的一块区域，数组名是这块区域的名字，但是在内存中并不存在额外的区域保存数组名。引用就是一块内存区域的别名。C++中变量实质上就是一块内存区域，我们在用&i就可以得到变量i的地址，也就是说变量是这块区域的名字。对变量的操作实质上就是对这块内存中内容的操作。别名是这块区域的另一个名字。采用任何一个名字对这块区域修改都会影响区域的内容。

1.int vari = 10；

2.int &refr = vari；

3.vari = 20；

4.cout << refr << " " << vari << endl;

5.refr = 30;

6.cout << refr << " " << vari << endl;

上面的int &refr = vari实质上就是变量vari的别名，也就是保存vari变量地址的别名，这个地址中保存的是一个int类型的数据，数据可以通过vari来操作，可以修改。因为refr是一个别名，也可以通过该别名对这块内存区域进行操作。也就是说别名的操作就是针对一块特定的内存区域，这个通过变量操作的效果是一致的。

其次说说const限定符

const的引入使得在函数操作中的一些问题复杂了，但是更加的合理了，const限定符是指上是指一个常量。这个常量在一般的情况下就是限定变量不能修改，但是当这个限定符与引用、指针结合在一起时，使得很多的问题不在明朗。

1、const与指针

1.int *ptr；

2.const int *ciptr；

3.int const *icptr；

4.int * const cptr；

5.const int * const cicptr；

上面是关于const与指针结合时的各种情况，这并不只是C++中经常遇到的问题，在C语言中也会有类似的讨论，虽然const并不是C语言中的关键字。

int * ptr 是指定义一个指向int 类型的指针ptr。

const int ciptr 是指定义一个指向const int 类型的指针ciptr,这是const 限定的是( ciptr)，也就是对指针解引用，即const限定的就是数据本身，而非指针。所以ciptr是一个指向常int型数据的指针。

int const * icptr其实和上面的const int *ciptr是一致的因为const只是一个限定符，在int前还是后都 没有影响，他限定的仍然是(*icptr)，并不是icptr,也就是icptr也是指向常int型数据的指针，也就是说在icptr这个指针看来，它指向的数据是常数，是不能改变的，但是是否真的不能改变，需要依据实际的类型的分析，只是不能通过这个指针来改变。也就是说该指针是一个自以为自己指向常量的指针。

int * const cptr 这时候我们还是结合const的位置分析，const限定的是cptr，cptr我们可以知道是一个指针，也就是说const限定的是一个指针，而不是指针指向的数据，也就是说这种定义实质上是定义一个常指针，也就是指针指向的地址是不变的，也就是cptr是不能被赋值的，不能采用这个指针指向其他的对象或者地址。但是这个地址中的数据并不是常数，是可以改变的，可以通过对*cptr进行修改。这种指针实质上也就使得指针的效果大大减小，并不常用。

const int * const cicptr 这种定义结合上面的分析我们知道是一个指向常量的常指针，也就说这个指针指向的地址是一个常地址，指针不能指向其他的对象或者地址。同时对指针cicptr来说，我指向的这个地址中的内容也是不能修改的，是一个常量，是不能修改的，但是该地址的数据能否修改还需要进行实际的分析。

2、关于指针的初始化、赋值的问题

对于const类型的数据，如果需要定义指针，这时候只能定义const类型的数据，这是为什么呢？因为对于const对象来说，数据是肯定不能修改的，如果定义指向非const的指针，程序员可能就会通过指针来修改对象的值，但是const对象是不能被修改的，肯定会出现错误。因此const的变量只能采用指向常量的指针来指向。一般来说如果将一个非const指针指向了一个const对象，编译的过程中就会抛出如下的错误：

1. invalid conversion from ‘const int*’ to ‘int*’

   但是对于指向常量的指针并不一定指向的数据就是常量，这是一个非常重要的技术点，指向常量的指针指向的数据只是针对这个指针而言，他认为自己指向的数据是常量，休想通过他来修改指向的对象。也就是说指向常量的指针在初始化、赋值的时可以初始化或者赋值为非const变量的地址，即可以指向非const的对象，只是不能通过该指针来修改对象罢了。

   同时需要注意：对于指向const的指针，初始化过程比较方便，不要求是const对象的地址，可以采用非const对象的地址初始化，甚至还可以采用指向非const的指针直接赋值初始化，这时指针自己认为自己指向的对象是常量。但是不能将指向const的指针直接赋值给指向非const的指针，如果不小心赋值也会出现上面出现的问题。下面参看一段小的代码，说明其中的一些问题。

1.#include <iostream>

2.#include <string>

3.#include <vector>

4.

5.using namespace std;

6.

7.int main()

8.{

9.        int num = 20; 

10.        const int array_size = 10; 

11.

12.    

13.        int *pnum = &num;

14.        const int * cpnum = &num;

15.        /*const int *指针可以采用int *指针直接初始化*/

16.        const int *csize1 = pnum; 

17.

18.

19.        /*但是int * 指针不能采用const int *制作初始化*/

20.        //int *psize = &array_size;

21.        /*const类型数据只能采用指向const的指针来指向*/

22.        const int *csize = &array_size;

23.

24.        cout << "Before change..." << endl;

25.        cout << "The num of num = " << num << endl;

26.        cout << "*pnum = " << *pnum << " " 

27.                << "*cpnum = " << *cpnum << " " 

28.                << "csize1 = " << *csize1 << endl;

29.

30.        num = 30; 

31.    

32.        cout << "After changed..." << endl;

33.        cout << "The num of num = " << num << endl;

34.        cout << "*pnum = " << *pnum << " " 

35.                << "*cpnum = " << *cpnum << " " 

36.                << "csize1 = " << *csize1 << endl;

37.

38.        return 0;

39.}

从上面的结果我们可以知道指向const的指针可以采用非const变量的地址进行初始化或者赋值操作，同时也可以采用指向非const指针直
接初始化指向const的指针。同时指向const的指针不能赋值给指向非const的指针，会出现const int 不能转换到int 的问题。

3、const与引用

关于const和引用在一起情况下也存在一些类似于指针的情况，但是毕竟引用相比指针要简单，这时候情况也比较简单.但是我认为分析引用应该与分析指针是一样也存在类似的问题。但是引用就只有两种，非const的引用和const的引用。

1.int num = 10；

2.

3.int &newname = num；

4.const int &othername = num；

引用主要是上面的两种，这两种的区别相对来说比较大，而且加入了const限定符以后，引用的能力往往变的更加的强大。

一般来说对于const对象而言，一般只能采用const引用，这与前面的const对象只能采用指向const对象的原因是一样的，如果对引用没有进行限定，可能会通过引用修改数据，这是不允许的。也就是说const引用与指向const对象的指针有一定的相似性，即不能通过这个引用或者指针来修改原来的数据。保证数据的const特性。也就是说非const引用不能引用const对象，如果不小心引用编译器会出现下面的错误：

1.invalid initialization of reference of type ‘int&’ from expression of type ‘const int’

因此非const引用只能针对非const的同类型数据。这是需要注意的。比如string，和字符串字面值都不能直接引用。因为类型不相同，这是在C++函数定义中经常出现的问题，在后期的博文中再分析。在引用中加入const的就是对于这个引用而言，不能通过自己来修改原始的数据，这与指向const的指针有很大的相似性，

但是往往const引用的初始化并不一定要去对象是const的，甚至可以是不同类型的对象，这种优越性是连指针(指针只能指向同一类型的数据，如果一定要指向需要强制类型转换）都没有的，也就是可以将不同类型的非const或者const对象来初始化一个const引用。但是这个const限定符就限定了该引用指向的对象是不能通过该引用来修改的。如果尝试采用const的引用进行修改，编译器会出现如下的错误：

1.error: assignment of read-only reference…

综合上面的描述可知：非const引用只能绑定到该引用同类型（string和字符串字面值（const char *）之间都不可以）的非const对象，而const引用则可以绑定到任意的一种对象上(非const、const、甚至不同类型),这种差别在函数的参数中有较大的体现。

通过下面的例子来说明一下上面的分析：

1.#include <iostream>

2.#include <string>

3.#include <vector>

4.

5.using namespace std;

6.

7.int main()

8.{

9.        int num = 20;

10.        const int array_size = 10;

11.

12.        int &pnum = num;

13.        const int &cpnum = num;

14.        /*采用引用直接初始化const类型的引用*/

15.        const int &csize1 = pnum;

16.

17.        /*const的变量不能采用非const的引用*/

18.        //int &psize = array_size;

19.        /*const类型数据只能采用指向const的指针来指向*/

20.        const int &csize = array_size;

21.

22.        cout << "Before change..." << endl;

23.        cout << "The num of num = " << num << endl;

24.        cout << "pnum = " << pnum << " "

25.                << "cpnum = " << cpnum << " "

26.                << "csize1 = " << csize1 << endl;

27.

28.        num = 30;

29.        cout << "After the first changed..." << endl;

30.        cout << "The num of num = " << num << endl;

31.        cout << "pnum = " << pnum << " " 

32.                << "cpnum = " << cpnum << " " 

33.                << "csize1 = " << csize1 << endl;

34.   

35.        /*通过引用修改变量的值*/

36.        pnum = 40;

37.        cout << "After the second changed..." << endl;

38.        cout << "The num of num = " << num << endl;

39.        cout << "pnum = " << pnum << " "

40.                << "cpnum = " << cpnum << " "

41.                << "csize1 = " << csize1 << endl;

42.

43.        /*不能采用const的引用修改对象，

44.        *这与指向const的指针特性的相似处*/

45.        /*

46.        csize1 = 50;

47.        cout << "After the second changed..." << endl;

48.        cout << "The num of num = " << num << endl;

49.        cout << "pnum = " << pnum << " " 

50.                << "cpnum = " << cpnum << " " 

51.                << "csize1 = " << csize1 << endl;

52.        */

53.

54.        double dnum = 10.1;

55.        /*非const的引用只能绑定相同类型的对象*/

56.        //int &dname = dnum;

57.

58.        /******************************************

59.        *const引用可以绑定不同类型的对象，

60.        *因此const引用就能更加方便的作为函数的形参

61.        *******************************************/

62.        const int &dothername = dnum;

63.

64.        return 0;

65.}

上面的实验结果基本上符合分析的结论。

总结

const的使得引用与指针的变化更加复杂，总体而言，const主要是保证了通过指针或者引用不修改原始的数据，但是至于原始的数据是否可以修改，这就需要参看数据的类型。

在存在const的对象中，只能采用包含限定符const的引用或者指向const的指针来操作。

const的引用比较强大，初始化的过程中可以采用任意的对象,const对象，非const对象，甚至其他类型的数据。const引用支持隐式类型转换。而指向const的指针则不能，只能指向同一类型的数据，但是可以采用强制类型转换，初始化或者赋值过程中对数据类型没有要求，可以是const对象的地址，也可以是非const对象的地址。

const引用和指向const对象的指针都是自己以为自己指向的对象是不能修改的，采用const的指针或者引用就能避免原始数据修改。

转载地址：http://blog.chinaunix.net/uid-20937170-id-3280238.html