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.   
6.     *b  = 5;  
7.     std::cout <<con_var1 << " "<<*b ;  
8.     return 0;  
9. }  

运行结果为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 <_ZNSolsEi@plt>  
17.    0x0804860c <+62>:  movl   $0x8048760,0x4(%esp)  
18.    0x08048614 <+70>:  mov    %eax,(%esp)  
19.    0x08048617 <+73>:  call   0x80484f8 <_ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc@plt>  
20.    0x0804861c <+78>:  mov    %ebx,0x4(%esp)  
21.    0x08048620 <+82>:  mov    %eax,(%esp)  
22.    0x08048623 <+85>:  call   0x8048498 <_ZNSolsEi@plt>  
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.  
30.    

[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 <_ZNSolsEi@plt>  

这是打印语句的调用以及参数的入栈，可以看到，入栈时是直接使用立即数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.   
7.     printf("%d",con_var1);  
8. }  

运行结果输出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.   
6.     cout <<v;  
7.     cout << *ptr_cvalue;  
8.   
9.     v = 5;  
10.     cout <<v ;  
11.     cout<< *ptr_cvalue;  
12.   
13. }  

上面代码定义了一个指向常量的指针，即被指向的地址中址是不能通过*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.   
10. void fun()  
11. {  
12. cout<<"a="<<a<<endl;  
13. cout<<"b="<<b<<endl;  
14.   
15. int *a1 = (int*)&(a);  
16. *a1 = 5;  
17. int *b1 = (int*)&(b);  
18. *b1 = 6;  
19.   
20. cout<<&a<<"="<<a<<endl<<a1<<"="<<*a1<<endl;  
21. cout<<&b<<"="<<b<<endl<<b1<<"="<<*b1<<endl;  
22. }  
23. private:  
24. const int a;  
25. const int b;  
26.   
27. };  
28.   
29. int main(int argc, char* argv[])  
30. {  
31. A a;  
32. a.fun();  
33. cout << &a << endl;  
34. return 0;  
35. }  

运行结果为

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.   
7. unsigned int addr;  
8. int * pconst;  
9.   
10. addr=(unsigned int)&constant;  
11. pconst=(int *)addr;  
12. cout<<&constant<<" "<<&addr<<endl;  
13. *pconst=10;//segment fault  
14. cout<<constant<<endl;  
15. return 0;  
16. }  

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

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

(1) 编译器处理方式不同

　　define宏是在预处理阶段展开。

　　const常量是编译运行阶段使用。

(2) 类型和安全检查不同

　　define宏没有类型，不做任何类型检查，仅仅是展开。

　　const常量有具体的类型，在编译阶段会执行类型检查。

(3) 存储方式不同

　　define宏仅仅是展开，有多少地方使用，就展开多少次，不会分配内存。

　　const常量会在内存中分配(可以是堆中也可以是栈中)。

 

(4)const  可以节省空间，避免不必要的内存分配。 例如：  
        #define PI 3.14159 //常量宏  
        const doulbe Pi=3.14159; //此时并未将Pi放入ROM中 ......  
        double i=Pi; //此时为Pi分配内存，以后不再分配！  
        double I=PI; //编译期间进行宏替换，分配内存  
        double j=Pi; //没有内存分配  
        double J=PI; //再进行宏替换，又一次分配内存！  
        const定义常量从汇编的角度来看，只是给出了对应的内存地址，而不是象#define一样给出的是立即数，所以，const定义的常量在程序运行过程中只有一份拷贝，而 #define定义的常量在内存中有若干个拷贝。 
(5) 提高了效率。 编译器通常不为普通const常量分配存储空间，而是将它们保存在符号表中，这使得它成为一个编译期间的常量，没有了存储与读内存的操作，使得它的效率也很高。

 

const 与 #define的比较

    C++ 语言可以用const来定义常量，也可以用 #define来定义常量。但是前者比后者有更多的优点：

（1）   const常量有数据类型，而宏常量没有数据类型。编译器可以对前者进行类型安全检查。而对后者只进行字符替换，没有类型安全检查，并且在字符替换可能会产生意料不到的错误（边际效应）。

（2）   有些集成化的调试工具可以对const常量进行调试，但是不能对宏常量进行调试。

 

l  【规则5-2-1】在C++ 程序中只使用const常量而不使用宏常量，即const常量完全取代宏常量。

5.3 常量定义规则

l  【规则5-3-1】需要对外公开的常量放在头文件中，不需要对外公开的常量放在定义文件的头部。为便于管理，可以把不同模块的常量集中存放在一个公共的头文件中。

l  【规则5-3-2】如果某一常量与其它常量密切相关，应在定义中包含这种关系，而不应给出一些孤立的值。

例如：

const  float   RADIUS = 100;

const  float   DIAMETER = RADIUS * 2;

5.4 类中的常量

有时我们希望某些常量只在类中有效。由于#define定义的宏常量是全局的，不能达到目的，于是想当然地觉得应该用const修饰数据成员来实现。const数据成员的确是存在的，但其含义却不是我们所期望的。const数据成员只在某个对象生存期内是常量，而对于整个类而言却是可变的，因为类可以创建多个对象，不同的对象其const数据成员的值可以不同。

    不能在类声明中初始化const数据成员。以下用法是错误的，因为类的对象未被创建时，编译器不知道SIZE的值是什么。

    class A

    {…

        const int SIZE = 100; // 错误，企图在类声明中初始化const数据成员

        int array[SIZE];       // 错误，未知的SIZE

    };

 

const数据成员的初始化只能在类构造函数的初始化表中进行，例如

    class A

    {…

        A(int size);       // 构造函数

        const int SIZE ;  

    };

    A::A(int size) : SIZE(size) // 构造函数的初始化表

    {

      …

    }

    A  a(100);  // 对象 a 的SIZE值为100

    A  b(200);  // 对象 b 的SIZE值为200

 

    怎样才能建立在整个类中都恒定的常量呢？别指望const数据成员了，应该用类中的枚举常量来实现。例如

    class A

    {…

        enum { SIZE1 = 100, SIZE2 = 200}; // 枚举常量

        int array1[SIZE1];

        int array2[SIZE2];

    };

    枚举常量不会占用对象的存储空间，它们在编译时被全部求值。枚举常量的缺点是：它的隐含数据类型是整数，其最大值有限，且不能表示浮点数（如PI=3.14159）。sizeof(A) = 1200;其中枚举部长空间。

                         enum   EM { SIZE1 = 100, SIZE2 = 200}; // 枚举常量    sizeof（EM） = 4；