搬砖：编译器在处理const变量跟一般变量时的区别

编译器在处理const变量跟一般变量时的区别

2018年05月16日 12:19:52 米沙子418 阅读数：200

转自：https://www.cnblogs.com/TaigaCon/archive/2012/12/19/2824355.html

const变量，也就是常量，当某个变量加上const属性的时候，表明这个变量不可修改。

 

const变量是不可写的，那么我们对于const变量的处理只剩下读操作了。

 

当我们读一般的变量的时候，会先获取该变量的地址，然后到该地址去取数据，那么对于const变量的读操作是怎么样的呢。

下面代码有助于更好理解const变量：

 

#include<iostream>
using namespace std;

int main(){
    const int a=10;
    const int * p=&a;                    //让指针p指向常量a所在的内存
    int * p_var=const_cast<int *>(p);            //强制转换const指针为非const
    *p_var=20;                //往该指针所指向的内存写20，也就是把10给覆盖了
    
    cout<<a<<endl;
    cout<<(&a)<<endl;
    
    cout<<*p<<endl;
    cout<<(p)<<endl;
    
    cout<<*p_var<<endl;
    cout<<(p_var)<<endl;
    
    return 0;
}

 

 

然后看看输出结果：

10　　　　　　　　//a             
0x28ac54　　　　//&a            
20　　　　　　　　//*p           
0x28ac54　　　　//p              
20　　　　　　　　//*p_var     
0x28ac54　　　　//p_var        

输出结果显示&a,p,p_var 相同，不过a =10  ， *p=*p_var=20，

一个内存地址怎么可能得到两个不同的值？

 

看看反汇编：

  4011d6:    c7 44 24 04 0a 00 00     movl   $0xa,0x4(%esp)

上面的就是读取const a的值的汇编代码，它不是从内存取数据出来，而是直接得到常数0xa，也就是把const 变量当作真正的常量处理。

 

因此可以得到的结论就是：

对于const变量，编译器会在编译之前做处理，在所有要读取该const变量的地方，把该const变量替换成他一开始就制定的常量，如

const int a = 10;

int b= a ;

会在编译之前替换const变量，变成：

const int a = 10;

int b= 10;

 

********************************************************************************************

转自：https://blog.csdn.net/blogofshuguang/article/details/16852241

我们都知道在程序中用const，如果是变量，这表示该变量的值不能被修改，，，但是看下面一段C代码：

注意在用C编译，

 

[cpp] view plain copy

1. #include <stdio.h>  
2. #include <stdlib.h>  
3.   
4. int main()  
5. {  
6.     const int a = 10;  
7.     int *p=(int *)&a;//(int *)先把&i从const int * 转化为int *  
8.     *p=20;  
9.     printf("a=%d,*p=%d\n",a,*p);  
10.     return 0;  
11. }  

 

C编译器中给出的结果是： a = 20; *p = 20 （a的值被修改了）

而用C++编译上面的代码： a = 10; *p = 20;

 

为什么会酱紫呢？那就先从const在C和C++中的实现机制找答案。。。

在C中，const修饰的变量被认为是只读的变量，该变量肯定是在内存中有存储空间，用指针p指向该块内存，然后就能轻易的修改掉这块内存对应的值；

但是在C++中难道就不能够修改掉内存的值吗？。。。理想是这样，现在是C++编译器起作用的时候了，在编译阶段，C++编译器会用常量10去替换程序

中对a的引用，所以，根本就没有改的机会嘛。.(C++中的const正常情况下是看成编译期的常量,编译器并不为const分配空间,只是在编译的时候将期值保存在名字表中,并在适当的时候折合在代码中,如果加上关键字extern或者取const变量地址,则编译器就要为const分配存储空间.)

还有一个要注意的地方：C++编译器只能对内置数据类型（int , float...）做常数替换，而对于像结构体\类这样的非内置数据类型编译器不知道怎么替换，所以就不替换，

这就和C语言一样了，可以通过指针修改掉cosnt的值，

比如：

[cpp] view plain copy

1. #include <iostream>  
2. using namespace std;  
3.   
4. class Test  
5. {  
6. public:  
7.     int a;  
8.     char c;  
9.     Test():a(10),c('c'){}  
10.     ~Test(){}  
11. };  
12.   
13. int main()  
14. {  
15.     const Test t;  
16.     cout<<"t.a="<<t.a<<endl;// 结果为10  
17.     int* p = (int *)&t.a;  
18.     *p=20;  
19.     cout<<"t.a="<<t.a<<endl;//j结果为20，被修改了  
20.     return 0;  
21. }