***************************************************
更多精彩，歡迎進入：http://shop115376623.taobao.com
***************************************************
const修飾的指針會額外的占內存嗎？
仍然是4，不會占額外的內存。如果確定不會修改的話，加上 const 可以防止被誤修改，這樣可避免一些錯誤。而且有利于 編譯器 幫組優化程序
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 *p ? ?-> ? int * constp
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,引用不區分類型 ? ?//演變：int & ri = i ? ?-> ? ? constint & ri = i
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?
????言盡于此,希望對初學者有所助益!?
