const指針和const引用

文章轉自：http://blog.csdn.net/tianshuai1111/article/details/7771309

一，入門

const 指針

         指針指向的內容不能變，指針可以改變指向

常量指針

         指針不可以改變指向，指針指向內容可以變

#include "stdio.h" 

int main() 
{ 
   //const 指針 （指針指向的內容不能變，指針可以改變指向） 
	int a = 5; 　　
	int b = 6; 　　
	const int *ptr = &a; 　　
	*ptr = 8; //error 　　
	ptr = &b; //ok; 　　
	
	//常量指針 （指針不可以改變指向，指針指向內容可以變）
	int a = 5; 　　
	int b = 6; 　　
	int * const ptr = &a; 　　
	*ptr = 8; //ok 　　
     ptr = &b; //error
} 

二，深度解析

         大致說來其可分爲三種情況: const修飾指針,const修飾引用,const修飾指針的引用. 

const修飾指針 
       const修飾指針本身 
       const修飾指針所指的變量(或對象) 
       const修飾指針本身和指針所指的變量(或對象) 

1）const修飾指針本身 
             這種情形下,指針本身爲常量,p不可改變,任何修改指針本身的行爲都是非法的.

        例如: 

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; //也可以寫成 int const *pi = &a; 
        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 

 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*便可.

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,不存在這種形式,沒有意義 

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