c++ const常量的实现机制（转载）

const关键字的基本思想就是将一个变量变成常量，试图从语言设计者的角度去分析引入该关键字的动机。

我猜测原因如下：

1）提醒程序员，某些值是常量，如PI。或该值在程序运行期间是不变的，防止程序员误修改。对于多模块开发，头文件引用复杂的系统来说，这是很重要的，如果不能在编译期阻止常量被误修改，那么这些修改将引起运行时调试困难的问题。

2）改进c语言中的#define预处理宏，1）中提到的问题使用#define宏也能够得到解决，但是#define宏作为解决方案存在一些缺陷：a)#define宏会产生二义性。
b)#define宏不支持类型，无法进行类型检测，这对于强类型语言来说，无疑是难以接受的。3）#define宏无法实现后来者const的一些功能。如函数参数传址时，防止被调用函数在调用者不知情的情况下随意修改参数。再如c++类机制中的const成员的访问性控制。

通常的理解，const修饰的变量是不可修改的。其实不然，const关键字在某种程度上来说只是一个面向编译器和程序员的幌子，并不能保证被修饰的内容的不变性。

下面分别按照const的部分用法来分析一下：

1） const修饰局部变量，即声明一个局部常量

[cpp] view
plaincopy

1. int main()


2. {


3. const int con_var1 = 3;


4. int * b = (int *)&con_var1;
5. *b  = 5;


6. std::cout <<con_var1 << " "<<*b ;


7. return 0;


8. }

运行结果为3  
5。看起来，const确实很负责的保证了被修饰内容的不变性。实际上，这样理解是片面的。const确实在一定程度上使得con_var1变成了一个常量，然而它并没有实现保证con_var1在内存中的值不被修改。
来看一下汇编代码：

[plain] view
plaincopy

1. Dump of assembler code for function main:


2. 0x080485ce <+0>:   push   %ebp


3. 0x080485cf <+1>:   mov    %esp,%ebp


4. 0x080485d1 <+3>:   and    $0xfffffff0,%esp


5. 0x080485d4 <+6>:   push   %ebx


6. 0x080485d5 <+7>:   sub    $0x2c,%esp


7. <span style="color:#FF0000;">0x080485d8 <+10>: movl   $0x3,0x18(%esp)</span>


8. 0x080485e0 <+18>:  lea    0x18(%esp),%eax


9. 0x080485e4 <+22>:  mov    %eax,0x1c(%esp)


10. 0x080485e8 <+26>:  mov    0x1c(%esp),%eax


11. 0x080485ec <+30>:  movl   $0x5,(%eax)


12. 0x080485f2 <+36>:  mov    0x1c(%esp),%eax


13. 0x080485f6 <+40>:  mov    (%eax),%ebx


14. <span style="color:#FF0000;">0x080485f8 <+42>: movl   $0x3,0x4(%esp)</span>


15. 0x08048600 <+50>:  movl   $0x804a040,(%esp)


16. 0x08048607 <+57>:  call   0x8048498 <[email protected]>


17. 0x0804860c <+62>:  movl   $0x8048760,0x4(%esp)


18. 0x08048614 <+70>:  mov    %eax,(%esp)


19. 0x08048617 <+73>:  call   0x80484f8 <[email protected]>


20. 0x0804861c <+78>:  mov    %ebx,0x4(%esp)


21. 0x08048620 <+82>:  mov    %eax,(%esp)


22. 0x08048623 <+85>:  call   0x8048498 <[email protected]>


23. 0x08048628 <+90>:  mov    $0x0,%eax


24. 0x0804862d <+95>:  add    $0x2c,%esp


25. 0x08048630 <+98>:  pop    %ebx


26. 0x08048631 <+99>:  mov    %ebp,%esp


27. 0x08048633 <+101>: pop    %ebp


28. 0x08048634 <+102>: ret


29. End of assembler dump.

[plain] view
plaincopy

1. <span style="color:#FF0000;">0x080485d8 <+10>:    movl   $0x3,0x18(%esp)</span>

这句是con_var1的定义，在栈上分配了内存，并赋值为3。

[plain] view
plaincopy

1. 0x080485e0 <+18>: lea    0x18(%esp),%eax


2. 0x080485e4 <+22>:    mov    %eax,0x1c(%esp)


3. 0x080485e8 <+26>:    mov    0x1c(%esp),%eax


4. 0x080485ec <+30>:    movl   $0x5,(%eax)

上面这段是取con_var1的内存地址，并将该地址中的值改为5.即con_var1在内存中实际的值已经被改写成5了。

既然内存中的值已经被改成5了，那么为什么最后打印出的值没有改变？

[plain] view
plaincopy

1. 0x080485f8 <+42>: movl   $0x3,0x4(%esp)


2. 0x08048600 <+50>:    movl   $0x804a040,(%esp)


3. 0x08048607 <+57>:    call   0x8048498 <[email protected]>

这是打印语句的调用以及参数的入栈，可以看到，入栈时是直接使用立即数3入栈，而并不是从con_var1所在内存读取出值来入栈的。

我们发现，上面同样的行为，使用c将得到不同的结果

[cpp] view
plaincopy

1. int main()


2. {


3. const int con_var1 = 3;


4. int * b = (int *)&con_var1;


5. *b = 5;
6. printf("%d",con_var1);


7. }

运行结果输出5， 即con_var1常量被改了！

于是，我猜测以下结论：

a）对于const修饰的局部常量而言，g++编译器（不同编译器机制未必相同）会为其分配内存，由于是静态分配而且是局部常量，所以分配在栈中。

b）对代码中直接引用到该常量（即该常量直接作为右值使用）的情况，编译器会将其直接替换成定义时赋的值。这样一来，无论运行期该常量所在内存被如何修改，都不会影响常量的使用。对于取址操作&con_var而言，&con_var整体被当作一个右值，没有被编译器替换成常值，这也是为什么既然编译器还要为const修饰的常量分配内存的原因。（const
folding技术在这里被用到）。

c）const只在编译期间保证常量被使用时的不变性，无法保证运行期间的行为。程序员直接修改常量会得到一个编译错误，但是使用间接指针修改内存，只要符合语法则不会得到任何错误和警告。因为编译器无法得知你是有意还是无意的修改，但是既然定义成const，那么程序员就不应当修改它，不然直接使用变量定义好了。

d）c语言中原本没有const关键字，后来为了兼容，引入了const，但是编译器对其的操作与c++中不同。

2) const修饰  常量指针或指针常量

[cpp] view
plaincopy

1. int main()


2. {


3. int v = 3;


4. const int * ptr_cvalue = &v;
5. cout <<v;


6. cout << *ptr_cvalue;
7. v = 5;


8. cout <<v ;


9. cout<< *ptr_cvalue;
10. }

上面代码定义了一个指向常量的指针，即被指向的地址中址是不能通过*ptr_cvalue来修改的。

运行结果为5 
5,这个结果与const实现这个功能并不冲突，应为const只保证修饰的指针不能被用来修改其指向的内存的值。但是其他手段来修改该内存的值就与const无关了。

这个实验的目的是为了再次说明，const机制并没有在运行期有任何行为，只是编译期的行为。

相类似的，指针本身为常量的也可以通过另一个指向指针的指针来修改其所指向的地址来实现更改。

3）const修饰类成员变量

[cpp] view
plaincopy

1. #include <iostream>


2. using namespace std;


3. class A


4. {


5. public:


6. A(int i=1,int j=2):a(i),b(j)


7. {};


8. //const int c;
9. void fun()


10. {


11. cout<<"a="<<a<<endl;


12. cout<<"b="<<b<<endl;
13. int *a1 = (int*)&(a);


14. *a1 = 5;


15. int *b1 = (int*)&(b);


16. *b1 = 6;
17. cout<<&a<<"="<<a<<endl<<a1<<"="<<*a1<<endl;


18. cout<<&b<<"="<<b<<endl<<b1<<"="<<*b1<<endl;


19. }


20. private:


21. const int a;


22. const int b;
23. };
24. int main(int argc, char* argv[])


25. {


26. A a;


27. a.fun();


28. cout << &a << endl;


29. return 0;


30. }

运行结果为

a=1
b=2
0xbff3b9c8=5
0xbff3b9c8=5
0xbff3b9cc=6
0xbff3b9cc=6
0xbff3b9c8
可以看到，类const成员被修改了。

4）函数const传址也是可以被修改的。

5） const意外的收获---全局常量

[cpp] view
plaincopy

1. #include<iostream>


2. using namespace std;


3. const int constant=1;


4. int main()


5. {
6. unsigned int addr;


7. int * pconst;
8. addr=(unsigned int)&constant;


9. pconst=(int *)addr;


10. cout<<&constant<<" "<<&addr<<endl;


11. *pconst=10;//segment fault


12. cout<<constant<<endl;


13. return 0;


14. }

报段错误，这里报错的原因在于：const int
constant,这个全局常量内存分配在.rodata段，对于内存分页机制来说，.rodata对应的页是只读的，当试图去修改该段内存时，会引发段错误，这是在运行期的错误。可以说，这是真正能够保证不会被修改的常量。是在操作系统层面实现的。

总结：const关键字是用于约束程序员和编译器的行为的，而不是程序员用以保证程序正确性的良药，除了全局常量外，没有任何机制保证了const声明的常量的不可修改性，要想使得程序中定义的常量不被修改，就只能循规蹈矩的使用它。

c++ const常量的实现机制（转载）