今天給大家分享一下這段時間學習c＋＋的總結學習：c＋＋里面的const關鍵字和引用。

一、const關鍵字的總結

1、const什么時候為只讀變量，什么時候又是常量呢？

（1）const常量的判別規則：

只用字面量初始化的const常量才會進入符號表

使用其它變量初始化的const常量仍然是只讀變量

被volatile修飾的const常量不會進入符號表

在編譯期間不能直接確定初始值的const標識符，都被作為只讀變量處理

（2）const引用的類型與初始化變量的類型

相同：初始化變量成為只讀變量

不同：生成一個新的只讀變量

代碼版本一：

＃include ＜stdio．h＞
int main（）
｛
const int x ＝ 1；／／直接得到值，進入符號表，但是還是會為 x 分配空間，只不過這個空間 x 沒有用而已
const int＆ rx ＝ x；／／rx代表只讀變量，這個變量是編譯器為x分配而沒有使用的空間；引用代表變量的別名，而變量代表一段內存空間的別名，所以引用代表一段內存空間的別名
int＆ nrx ＝ const＿cast＜int＆＞（rx）； ／／消除 rx只讀屬性，和rx 代表的內存空間相同，同時c＋＋里面的幾種類型轉換要掌握
nrx＝5；
printf（＂x ＝ ％d＂，x）；
printf（＂rx ＝ ％d＂，rx）；
printf（＂nrx ＝ ％d＂，nrx）；
printf（＂＆x ＝ ％p＂，＆x）；
printf（＂＆rx ＝ ％p＂，＆rx）；
printf（＂＆nrx ＝ ％p＂，＆nrx）；

return 0；
｝

輸出結果：

root＠txp－virtual－machine：／home／txp＃ ．／a．out
x ＝ 1
rx ＝ 5
nrx ＝ 5
＆x ＝ 0x7ffcc5fa8abc
＆rx ＝ 0x7ffcc5fa8abc
＆nrx ＝ 0x7ffcc5fa8abc

代碼版本二：

＃include ＜stdio．h＞
int main（）
｛
volatile const int y ＝ 2；／／ 只讀變量，不會進入符號表
int ＊p ＝ const＿cast＜int＊＞（＆y）；／／y被 const修飾，取到的地址也有 const 屬性，這里將地址只讀屬性去掉
＊p ＝ 8；
printf（＂y ＝ ％d＂，y）；
printf（＂p ＝ ％p＂，p）；
return 0；
｝

輸出結果：

root＠txp－virtual－machine：／home／txp＃ ．／a．out
y ＝ 8
p ＝ 0x7ffd78559684

代碼版本三：

＃include ＜stdio．h＞
int main（）
｛
volatile const int y ＝ 2；
int ＊p ＝ const＿cast＜int＊＞（＆y）；
＊p ＝ 8；
printf（＂y ＝ ％d＂，y）；
printf（＂p ＝ ％p＂，p）；
const int z ＝ y ；／／只讀變量
p ＝ const＿cast＜int＊＞（＆z）；
＊p＝ 9；
printf（＂z ＝ ％d＂，z）；
printf（＂p ＝ ％p＂，p）；
return 0；
｝

輸出結果：

root＠txp－virtual－machine：／home／txp＃ ．／a．out
y ＝ 8
p ＝ 0x7ffc5d651250
z ＝ 9
p ＝ 0x7ffc5d651254

代碼版本四：

＃include ＜stdio．h＞
int main（）
｛
char c ＝ ＇c＇；
char＆ rc ＝ c；
const int＆ trc ＝ c； ／／ char 類型默認轉換為 int；const 引用初始化類型不同，將得到新的只讀變量，所以改變 rc 和 trc 沒有絲毫關系，從我們的輸出結果可以看出來
rc ＝ ＇a＇；
printf（＂c ＝ ％c＂，c）；
printf（＂rc ＝ ％c＂，rc）；
printf（＂trc ＝ ％c＂，trc）；
return 0；
｝

結果輸出：

root＠txp－virtual－machine：／home／txp＃ ．／a．out
c ＝ a
rc ＝ a
trc ＝ c

二、引用的總結：

1、引用與指針有什么關系，以及如何理解＂引用的本質就是指針常量＂？

（1）指針是一個常量：

值為一個內存地址，不需要初始化，可以保存不同的地址

通過指針可以訪問對應內存地址中的值

指針可以被const修飾成為常量或者只讀變量

（2）引用只是一個變量的新名字：

對引用的操作（賦值、取地址等）都會傳遞到代表的變量上

const引用使其代表的變量具有只讀屬性

引用必須在定義時初始化，之后無法代表其它變量

（3）從使用c＋＋語言的角度來看：

引用與指針沒有任何的關系

引用是變量的新名字，操作引用就是操作對應的變量

（4）從c＋＋編譯器的角度來看：

為了支持新概念＂引用＂必須要一個有效的解決方案

在編譯器內部，使用指針常量來實現＂引用＂

因此＂引用＂在定義時必須初始化

（5）在工程項目開發中：

當進行c＋＋編程時，直接站在使用的角度來看待引用，與指針毫無關系，引用就是變量的別名

當對C＋＋代碼進行調試分析時，一些特殊情況，可以考慮站在C＋＋編譯器的角度來看待引用

代碼實踐：

版本一：

＃include ＜stdio．h＞
int a ＝ 2；
struct SV｛
int＆ x；
int＆ y；
int＆ z；
｝；
int main（）
｛
int b ＝4；
int＊ pc ＝ new int（3） ；
SV sv ＝ ｛a，b，＊pc｝；
printf（＂＆sv．x ＝ ％p＂，＆sv．x）；
printf（＂＆sv．y ＝ ％p＂，＆sv．y）；
printf（＂＆sv．z ＝ ％p＂，＆sv．z）；
delete pc；
return 0；
｝

輸出結果：

root＠txp－virtual－machine：／home／txp＃ ．／a．out
＆sv．x ＝ 0x601050
＆sv．y ＝ 0x7ffee11ba794
＆sv．z ＝ 0x1cfd010

版本二：

＃include ＜stdio．h＞
int a ＝ 2；
struct SV｛
int＆ x；
int＆ y；
int＆ z；
｝；
int main（）
｛
int b ＝4；
int＊ pc ＝ new int（3） ；
SV sv ＝ ｛a，b，＊pc｝；
int＆ array［］ ＝ ｛a，b，＊pc｝；／／數組中的每個元素是引用就不可以；error： declaration of ‘array’ as array of references；C＋＋ 天生要支持 C 語言，C 語言中數組中的每個元素在內存中是順序存放的，地址是遞增的，所以在 C＋＋ 中也要兼容這個特性，而在 C＋＋ 中唯有引用數組破快了這個特性，所以說 C＋＋ 中不支持引用數組；＆array［1］ － ＆array［0］ ！＝ Expected ＝＝＞ 4
printf（＂＆sv．x ＝ ％p＂，＆sv．x）；
printf（＂＆sv．y ＝ ％p＂，＆sv．y）；
printf（＂＆sv．z ＝ ％p＂，＆sv．z）；
delete pc；
return 0；
｝

輸出結果：

root＠txp－virtual－machine：／home／txp＃ g＋＋ test．cpp
test．cpp： In function ‘int main（）’：
test．cpp：16：14： error： declaration of ‘array’ as array of references
int＆ array［］ ＝ ｛a，b，＊pc｝；

三、總結：

指針是一個變量

引用是一個變量的新名字

const引用能夠生成新的只讀變量

在編譯器內部使用指針常量實現＂引用＂

編譯時不能直接確定初始值的const標識符都是只讀變量

好了，今天的分享就到這里，如果文章中有錯誤或者不理解的地方，可以交流互動，一起進步。我是txp，下期見！