今天给大家分享一下这段时间学习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\n",x);
   printf("rx = %d\n",rx);
   printf("nrx = %d\n",nrx);

   printf("&x = %p\n",&x);
   printf("&rx = %p\n",&rx);
   printf("&nrx = %p\n",&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\n",y);
       printf("p = %p\n",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\n",y);
      printf("p = %p\n",p);

      const int z = y ;//只读变量

      p = const_cast<int*>(&z);

      *p= 9;

      printf("z = %d\n",z);
      printf("p = %p\n",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\n",c);
     printf("rc = %c\n",rc);
     printf("trc = %c\n",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\n",&sv.x);
  printf("&sv.y = %p\n",&sv.y);
  printf("&sv.z = %p\n",&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\n",&sv.x);
  printf("&sv.y = %p\n",&sv.y);
  printf("&sv.z = %p\n",&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标识符都是只读变量
  
  

好了，今天的分享就到这里，如果文章中有错误或者不理解的地方，可以交流互动，一起进步。