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修饰局部变量，即声明一个局部常量

 

int main()
{
    const int con_var1 = 3;
    int * b = (int *)&con_var1;

    *b  = 5;
    std::cout <<con_var1 << " "<<*b ;
    return 0;
}

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

 

Dump of assembler code for function main:
   0x080485ce <+0>:   push   %ebp
   0x080485cf <+1>:   mov    %esp,%ebp
   0x080485d1 <+3>:   and    $0xfffffff0,%esp
   0x080485d4 <+6>:   push   %ebx
   0x080485d5 <+7>:   sub    $0x2c,%esp
   <span style="color:#FF0000;">0x080485d8 <+10>: movl   $0x3,0x18(%esp)</span>
   0x080485e0 <+18>:  lea    0x18(%esp),%eax
   0x080485e4 <+22>:  mov    %eax,0x1c(%esp)
   0x080485e8 <+26>:  mov    0x1c(%esp),%eax
   0x080485ec <+30>:  movl   $0x5,(%eax)
   0x080485f2 <+36>:  mov    0x1c(%esp),%eax
   0x080485f6 <+40>:  mov    (%eax),%ebx
   <span style="color:#FF0000;">0x080485f8 <+42>: movl   $0x3,0x4(%esp)</span>
   0x08048600 <+50>:  movl   $0x804a040,(%esp)
   0x08048607 <+57>:  call   0x8048498 <_ZNSolsEi@plt>
   0x0804860c <+62>:  movl   $0x8048760,0x4(%esp)
   0x08048614 <+70>:  mov    %eax,(%esp)
   0x08048617 <+73>:  call   0x80484f8 <_ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc@plt>
   0x0804861c <+78>:  mov    %ebx,0x4(%esp)
   0x08048620 <+82>:  mov    %eax,(%esp)
   0x08048623 <+85>:  call   0x8048498 <_ZNSolsEi@plt>
   0x08048628 <+90>:  mov    $0x0,%eax
   0x0804862d <+95>:  add    $0x2c,%esp
   0x08048630 <+98>:  pop    %ebx
   0x08048631 <+99>:  mov    %ebp,%esp
   0x08048633 <+101>: pop    %ebp
   0x08048634 <+102>: ret
End of assembler dump.

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

 

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

 

0x080485e0 <+18>: lea    0x18(%esp),%eax
 0x080485e4 <+22>:    mov    %eax,0x1c(%esp)
 0x080485e8 <+26>:    mov    0x1c(%esp),%eax
 0x080485ec <+30>:    movl   $0x5,(%eax)

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

 

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

 

0x080485f8 <+42>: movl   $0x3,0x4(%esp)
 0x08048600 <+50>:    movl   $0x804a040,(%esp)
 0x08048607 <+57>:    call   0x8048498 <_ZNSolsEi@plt>

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

 

咱们发现，上面一样的行为，使用c将获得不一样的结果

 

int main()
{
    const int con_var1 = 3;
    int * b = (int *)&con_var1;
    *b = 5;

    printf("%d",con_var1);
}

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

 

因而，我猜想如下结论：

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

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

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

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

 

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

 

int main()
{
    int v = 3;
    const int * ptr_cvalue = &v;

    cout <<v;
    cout << *ptr_cvalue;

    v = 5;
    cout <<v ;
    cout<< *ptr_cvalue;

}

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

 

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

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

相相似的，指针自己为常量的也能够经过另外一个指向指针的指针来修改其所指向的地址来实现更改。

 

3）const修饰类成员变量

 

#include <iostream>
using namespace std;
class A
{
public:
A(int i=1,int j=2):a(i),b(j)
{};
//const int c;

void fun()
{
cout<<"a="<<a<<endl;
cout<<"b="<<b<<endl;

int *a1 = (int*)&(a);
*a1 = 5;
int *b1 = (int*)&(b);
*b1 = 6;

cout<<&a<<"="<<a<<endl<<a1<<"="<<*a1<<endl;
cout<<&b<<"="<<b<<endl<<b1<<"="<<*b1<<endl;
}
private:
const int a;
const int b;

};

int main(int argc, char* argv[])
{
A a;
a.fun();
cout << &a << endl;
return 0;
}

运行结果为

 

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

 

4）函数const传址也是能够被修改的。

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

 

#include<iostream>
using namespace std;
const int constant=1;
int main()
{

unsigned int addr;
int * pconst;

addr=(unsigned int)&constant;
pconst=(int *)addr;
cout<<&constant<<" "<<&addr<<endl;
*pconst=10;//segment fault
cout<<constant<<endl;
return 0;
}

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

 

 

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