const的那些小事

     关于const

为什么需要const?

请看以下语句：

for(int index=0;index!=512;++index)

｛……｝

在此语句中有两个问题：

1、512这个常量含义不明确，也并不清楚index与512比较有什么作用

2、假如在程序中多次使用到512这个常量时，在后来的工作需要把512改为111的话修改的工作量将非常大

为此我们或许会想到定义一个变量来存储此常量

int bufSize=512;

for(int index=0;index!=bufSize;++index)

｛……｝

        这样，程序就能清楚表达出这个循环的作用，以及当需要修改这个常量的值时就在存储这个常量的变量在其初始化时直接修改一次就可以了。

       但此时又出现了新的问题，因为bufSize是一个变量，程序随时都可以对其重新赋值，但如果程序员需要bufSize内存储的值恒定为512的话，程序不知道哪一个操作把bufSize内存储的值给改了，得出的结果就与预想的不一样了。

       由此我们用const限定符把一个对象转换成一个常量，也就是说被const修饰的对象只能读，不能修改其值。

       对比：

    int bufSize=512; //在变量bufSize内存放着常量512

    const int bufSize=512; //bufSize就是512,512就是bufSize。可以把bufSize看成512的一个称呼。“=”右边是一个常量

                                     //定义bufSize为常量并初始化为512.变量bufSize仍然是一个左值，但是这个左值是不可以修改

    bufSize=0; //错误

       

       注意：因为常量在定义以后就不能被修改，所以定义时必须初始化

        const int i,j=0; //错误，i没有初始化

当const遇上引用（&）

       回顾一下引用：引用是别名，因为引用只是它绑定的对象的另一个名字，作用在引用上的所有操作事实上都是作用在该引用绑定的对象。当引用初始化后，只要该引用存在，它就保持绑定到初始化时指向的对象。不可能将引用绑定到另一对象。

       int i=9;

       int &j=i; //注意引用"="右边是一个对象，“=”相当于绑定的意思。

       int &k=10; //错误，引用绑定的是一个对象

       ++j; //此时j=10,同时i=10

       int &x; //错误，引用定义是一定要初始化，把它绑定到一个对象

       可以把引用理解会一个指向恒定不变的指针的解引用（*）

       即：int &j=i;//这里“=”左边是一个引用，右边是一个变量i

       相当于：int *const j=&i;//这里“=”左边是一个指针，其指向恒定不变，右边是变量i的地址

       但实质上两个本质上有差别

       

        const引用

       对象可分为const和非const:

        int i=1; //非const对象

        const int j=1; //const对象

        那么作为它的别名（引用）也应分为const和非const：

        int &x=i; //非const引用绑定非const对象，此时，x和i的值都可以修改，因为两个都是非const

        const int &y=j; //const引用绑定const对象，此时，y和j的值都不能修改，因为两个都是const

        

        其实也可以把const引用绑定非const对象

        const int &z=i;//此时z只能读不能修改，但i可以修改，因为i本身不是一个const对象

                               //可以理解为z是自以为const对象的别名

        z=2; //错误

        i=2；//OK

        

       但不可以把非const引用绑定到const对象

        const int a=1; //const对象

        int &b=a;//错误，把非const引用绑定到const对象

        

        也可以把一个常量赋给const引用，但非const引用不可以

         int &b=1; //error

         const int &a=1;//OK

         系统自动转换成

         int temp=1;

         const int &a=temp;

当const遇上指针（*）

1、指向const对象的指针

        同样地，类似于引用指针也有指向const对象和指向非const对象之分。指向const对象的指针，const修饰的是指针变量所指向的对象（指针变量解引用后的内容），即指针变量所指向的内容不可以改变。

        int a=1; //非const对象

        const int b=1; //const对象

        int *c=&a; //指向非const对象的指针，可以进行a++,c++,*c++

        const int *d=&b; //指向const对象的指针，可以进行d++,不可以进行*d++,b++

        

        也可以把一个非const的对象赋给一个指向const对象的指针

         int x=1;

         const int *y=&x;//此时可以进行y++,x++，但不可以进行*y++,可以理解y为自以为指向const对象的指针

         不可以把一个const的对象赋给一个指向非const对象的指针

         const int x=1; //const对象

         int *y=&x; //错误

2、const指针

        既然对象分为const和非const，指针变量作为一种对象相应地也应分为const和非const。const指针，const修饰的是指针变量，即指针变量恒定指向一个地址。

        int i=1;

        int *p1=&i; //非const指针，可以进行i++,*p1++,p1++

        int *const p2=&i; //const指针，可以进行i++,*p2++，但不可以进行p2++

       

       指向const 对象的const指针

       const int a=1;

       const int *const pi=&a; //不能进行a++,*pi++,pi++

小结：或许可以这样理解指向const对象的指针和const指针:

 使用就近原则：

 指向const对象的指针：把const int *p;看成const int (*p);  const修饰的是*p的内容

 const指针：把int *const p;看成int *const (p);   const修饰的是指针变量p

后言：小的最近初学C++，若以上概念有错，请各位大侠多多指教。。。