c++ const常量的實現機制（轉載）2

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聲明的常量的不可修改性，要想使得程序中定義的常量不被修改，就只能循規蹈矩的使用它。