const修饰指针和引用的用法

 

  const修饰指针和引用的用法,对于初学C++的人直是讳莫如深,不知所云.
    一旦你了解了其用法,一切便不值一哂了.下面我为读者一一释疑:

   大致说来其可分为三种情况: const修饰指针,const修饰引用,const修饰指针的引用.
  
  1.const修饰指针
    
    const修饰指针又可分为三种情况:
    
       a.const修饰指针本身
       
       b.const修饰指针所指的变量(或对象)
       
       c.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喜欢前者,这也没什么技术上的优劣之分,

        //也就是说constint与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;(仅仅是表达需要)，将constpi看作一体，就与上述分类(2)符合。
       只要含有int*便可.

2.const修饰引用
 
      这种情况比较简单，没有象修饰指针那样繁复，因为引用和引用对象是一体的，

   所以引用被const修饰只有一种类型。
   const修饰引用,引用本身不可变,但引用的变量(或对象)可以改变.例如:
   constint& ri = a; //or int const & ri =a; ok, ri 本身是常量,引用不区分类型
   constint& 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 *constri,因为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
     言尽于此,希望对初学者有所助益!