C++ 关于const的一些细节

 转自：点击打开链接

    感觉这个讲的比较清楚：

     如果const在*左边      ,const   修饰值               int   const   *pi        
     如果const在*右边      ,const   修饰指针         int   *const   pi; 

      其实这种问题你可以这样看，const后面如果有*p之类的，就是p能改，*p不能改，也就是指针能改，指针的值不能改，   int   const   *p   后面有*p，所以是*p不能改，int   *   const   p是p不能改，*p能改～！其他的类似。

  eg:

   const   int   *p;  
   int   const   *q;  
   int   *   const   r=&i;  
     
   1,   声明了一个指针p,   它指向一个int型的常量，p可以再指向别的变量，但这个int型的值不能被改变  
   2,   同上.  
   3,   声明了一个常指针p,   它被一个int型变量的地址初始化，这个指针将不再允许指向别的变量，而这个int变量的值是可以改变的。

  const修饰指针和引用的用法,对于初学C++的人直是讳莫如深,不知所云.一旦你了解了其用法,一切便不值一哂了.下面我为读者一一释疑:     
            大致说来其可分为三种情况:   const修饰指针,const修饰引用,const修饰指针的引用.     
   1.const修饰指针     
                  const修饰指针又可分为三种情况:     
                  const修饰指针本身     
                  const修饰指针所指的变量(或对象)     
                  const修饰指针本身和指针所指的变量(或对象)      

   (1).const修饰指针本身     
               这种情形下,指针本身为常量,不可改变,任何修改指针本身的行为都是非法的.例如:     
   const   int   a   =   1;     
   const   int   b   =   2;     
   int   i   =   3;     
   int   j   =   4;     
   int*   const   pi   =   &i;   //ok,   pi的类型为int*   const   ,   &i的类型为int*   const     
   int*   const   pi   =   &a;   //error,   pi的类型为int*   const,   &a的类型为const   int*   const     
   pi   =   &j;   //error,   指针是常量,不可变     
   *pi   =   a;   //ok,   *pi并没有限定是常量   ,可变     
               由此看出，pi是常量，常量在初始化和赋值时，类型必须严格一致。也就是     
   const修饰指针本身时，=号两边的变量类型必须严格一致，否则不能匹配。     
  

   (2).const修饰指针指向的变量(或对象)     
               此种情形下,通过间接引用指针不可改变变量的值,假设指针为p,则*p不可变,下面以例子说明:     
   const   int   *pi   =   &a;     
   //or   int   const   *pi   =   &a;     
   //两者毫无二致,不过BS喜欢前者,这也没什么技术上的优劣之分,也就是说const   int与int   const可以互换.建议大家熟     
   //悉这两种形式,为简洁便,以后统统用前者.     
   //ok,   const并不修饰指针本身,pi对赋值类型     
   //没要求   ,但pi是int*型指针，所以所赋的必须是个地址值。     
   const   int   *pi   =   &i;   //ok   ,pi可赋值常量的地址,又可赋变量的地址     
   const   int   *pi1   =   &a;     
   const   int   *pi   =   pi1;   //ok     
   *pi   =   j;   //error,*pi   不可变,不能更改指针的间接引用形式     
   pi   =   &j;   //ok,pi可变     
   pi   =   &b;   //ok,pi可变     
   pi++;   //ok     
   --pi;   //ok     
           由此可见，pi是变量，可以赋值常量和变量的值,正如一个整型变量可赋整型数和整型变量一样.const修饰的不是指针本身，而是其间接引用，=号两边的 类型不必严格匹配，如：const   int*   pi   =   &a;中，pi的类型为int*,而&a的类型为const   int*   const,只要其中含有int*   就可以。又如：const   int   *pi   =  & j;中，pi的类型为int*,而&j的类型为int*   const,它向pi赋值并无大碍。    
   (3)const修饰指针本身和指针所指的变量(或对象)     
                  设有指针p,此种情形下,p和*p都不可变.举例如下:     
   const   int*   const   pi   =   &a;     
   //or   int   const*   const   pi   =   &a;     
  //将const   pi看作一体,就与(2)所述相同,只是要求pi必须为const,正如上所说，=号两边的类型不必严格匹配，但必须含有int*,  & a的类型为const   int*   const,含有int*,   所以可以赋值。    
   const   int*   const   pi   =   &i;   //ok,   &i类型为int*   const,含有int*,   可赋值。     
   const   int   *pi1   =   &j;     
   const   int   *const   pi   =   pi1;   //ok,      pi1类型为int*     
   pi   =   &b;   //error,   pi不可变     
   pi   =   &j;   //error,   pi不可变     
   *pi   =   b;   //error,   *pi不可变     
   *pi   =   j;   //error,   *pi不可变     
   pi++;   //error   ，pi不可变     
   ++i;   //ok,   =号右边的变量(或对象)与所修饰的变量无关     
   a--;   //error,   a为const     
            这种情况，跟以上两种情形有联系。对const   int*   const   pi   =  & a;我们可以这样看：const   int*(   const   pi   )=  & a;(仅仅是表达需要)，将const   pi看作一体，就与上述分类(2)符合。只要含有int*便可.    
     
   2.const修饰引用     
               这种情况比较简单，没有象修饰指针那样繁复，因为引用和引用对象是一体的，所以引用被const修饰只有一种类型。     
   const修饰引用,引用本身不可变,但引用的变量(或对象)可以改变.例如:     
   const   int&   ri   =   a;   //or   int   const   &   ri   =   a;   ok,   ri   本身是常量,引用不区分类型     
   const   int&   ri   =   i;   //ok,引用不区分类型     
   ri++;   //error,   ri为常量,不可变     
   i++;   //ok,=右边的变量与引用无关     
   ri=b;   //error,   ri为常量     
   i=j;   //ok,=右边的变量与引用无关     
   int   &   const   ri   =   i;   //error,不存在这种形式,没有意义     
     
   3.const修饰指针的引用     
               引用只是个别名,这里与修饰指针类似,又分为三种情况:     
   (1)     
                  先给个例子：     
   const   int   *pi   =   &a;     
   const   int   *&ri   =   pi;     
   //or   int   const   *&ri   =   pi;     
         引用是引用对象的别名，正因为如此，ri是pi的别名，所以ri的类型必须与pi完全一致才行。这里pi的类型为int*,ri的类型也为int*，赋值 可行。若const   int   *&ri   =  & a;正不正确？分析一下就知晓。ri类型为int*,&a的类型则为const   int*   const不匹配。    
   const   int   *&ri   =   &i;   //error,类型不匹配，一为int*,一为int*   const     
   ri   =   &a;   //ok     
   ri   =   &i;   //ok     
   const   int   *pi1=&a;     
   const   int   *pi2=&i;     
   ri   =   pi1;   //ok     
   ri   =   pi2;   //ok     
   *ri   =   i;   //error     
   *ri   =   a;   //error     
                  注意这与1-(2)的区别. 

     
   (2)     
                  用例子说明:     
   int   *const   &ri   =   &i;     
               去掉ri左边的&号,则为int   *const   ri,因为ri是别名,故ri的类型应与赋值的数类型一致,ri类型为int   *const,&i为int   *const,可以这么做.     
   int   *const   &ri   =   pi;   //error,类型不合,一为int   *const   ,一为int   *     
   int   *const   &ri   =   &a;   //error,类型不合,一为int   *const,一为const   int*   const     
   (*ri)++;   //ok     
   i++;   //ok     
   ri   =   &i;   //error     
            这种情况下,ri为常量,不可更改.     

   (3)     
                  用例子说明：     
   const   int*   pi   =   &j;     
   const   int*   const   &ri   =   pi;   //or   int   const   *   const   &ri   =   pi;ok     
   const   int*   const   &ri   =   &i;   //ok     
            ri是pi的别名，pi的类型应与ri一致。拿掉&，得const   int*   const   ri  ，把const     ri看作一体,很容易得出ri的类型信息，就象前面2-(3)所讨论的一样，可以得到赋给ri的只要含有类型int*  即可。pi的类型为int*,&i的类型为int*   const   ,可以这么做.    
   const   int   *   const   &ri   =   &a;   //ok     
   ri++;      //error     
   *ri   =   6;      //error