C++中的const和引用的讨论

今天给大家分享一下这段时间学习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，下期见！

审核编辑：符乾江