C++中const的實現細節(C、C#同理)

1、什麼是const?  
常類型是指使用類型修飾符const說明的類型，常類型的變數或對象的值是不能被更新的。（當然，我們可以偷梁換柱進行更新：）  

2、為什麼引入const？  
const 推出的初始目的，正是為了取代先行編譯指令，消除它的缺點，同時繼承它的優點。  

3、cons有什麼主要的作用？  
（1）可以定義const常量，具有不可變性。 例如：  
const int Max=100; int Array[Max];  
（2）便於進行類型檢查，使編譯器對處理內容有更多瞭解，消除了一些隱患。例如： void f(const int i) { .........} 編譯器就會知道i是一個常量，不允許修改； （3）可以避免意義模糊的數字出現，同樣可以很方便地進行參數的調整和修改。 同宏定義一樣，可以做到不變則已，一變都變！如（1）中，如果想修改Max的內容，只需要：const int Max=you want;即可！  
（4）可以保護被修飾的東西，防止意外的修改，增強程式的健壯性。 還是上面的例子，如果在函數體內修改了i，編譯器就會報錯； 例如：  
void f(const int i) { i=10;//error! }  
（5） 為函數重載提供了一個參考。  
class A { ......  
void f(int i) {......} //一個函數  
void f(int i) const {......} //上一個函數的重載 ......  
};  
（6） 可以節省空間的，避免不必要的記憶體配置。 例如：  
#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定義的常量在記憶體中有若干個拷貝。  
（7） 提高了效率。 編譯器通常不為普通const常量分配儲存空間，而是將它們儲存在符號表中，這使得它成為一個編譯期間的常量，沒有了儲存與讀記憶體的操作，使得它的效率也很高。  

4、如何使用const？  
（1）修飾一般常量 一般常量是指簡單類型的常量。這種常量在定義時，修飾符const可以用在類型說明符前，也可以用在類型說明符後。 例如：  
int const x=2; 或 const int x=2;  
（2）修飾常數組 定義或說明一個常數組可採用如下格式：   
int const a[5]={1, 2, 3, 4, 5};   
const int a[5]={1, 2, 3, 4, 5};  
（3）修飾常對象 常對象是指對象常量，定義格式如下：  
class A; const A a;  
A const a; 定義常對象時，同樣要進行初始化，並且該對象不能再被更新，修飾符const可以放在類名後面，也可以放在類名前面。   
（4）修飾常指標  
const int *A; //const修飾指向的對象，A可變，A指向的對象不可變  
int const *A; //const修飾指向的對象，A可變，A指向的對象不可變  
int *const A; //const修飾指標A， A不可變，A指向的對象可變  
const int *const A;//指標A和A指向的對象都不可變  
（5）修飾常引用 使用const修飾符也可以說明引用，被說明的引用為常引用，該引用所引用的對象不能被更新。其定義格式如下：   
const double & v;   
（6）修飾函數的常參數 const修飾符也可以修飾函數的傳遞參數，格式如下：  
void Fun(const int Var); 告訴編譯器Var在函數體中的無法改變，從而防止了使用者的一些無意的或錯誤的修改。  
（7）修飾函數的傳回值： const修飾符也可以修飾函數的傳回值，是傳回值不可被改變，格式如下：  
const int Fun1(); const MyClass Fun2();  
（8）修飾類的成員函數： const修飾符也可以修飾類的成員函數，格式如下：  
class ClassName {  
public:   
int Fun() const; .....  
}； 這樣，在調用函數Fun時就不能修改類裡面的資料  
（9）在另一串連檔案中引用const常量  
extern const int i;//正確的引用  
extern const int j=10;//錯誤！常量不可以被再次賦值 另外，還要注意，常量必須初始化！ 例如： const int i=5;  

 

 

所謂C++編譯器，C++編譯器是C++中的一個與標準化高度相容的編譯環境，編譯器對不同的CPU會進行不同的最佳化，下面說明C++編譯器進行Const常量分配儲存空間的說明介紹。

Const 是C++中常用的類型修飾符，有某些微妙的應用場合，如果沒有搞清本源，則錯誤在所難免。本篇中將對const進行辨析。溯其本源，究其實質，希望能對大家理解const有所協助，根據思維的承接關係，分為如下幾個部分進行闡述。C++的提出者當初是基於什麼樣的目的引入（或者說保留）const關鍵字呢？，這是一個有趣又有益的話題，對理解const很有協助。

1． 大家知道，C++有一個類型嚴格的編譯系統，這使得C++程式的錯誤在編譯階段即可發現許多，從而使得出錯率大為減少，因此，也成為了C++與C相比，有著突出優點的一個方面。

2． C++中很常見的預先處理指令 #define VariableName VariableValue 可以很方便地進行值替代，這種值替代至少在三個方面優點突出：一是避免了意義模糊的數字出現，使得程式語義流暢清晰。

二是可以很方便地進行參數的調整與修改，如上例，當人數由107變為201時，進改動此處即可，三是提高了程式的執行效率，由於使用了先行編譯器進行值替代，並不需要為這些常量分配儲存空間，所以執行的效率較高。鑒於以上的優點，這種預定義指令的使用在程式中隨處可見。

3． 說到這裡，大家可能會迷惑上述的1點、2點與const有什麼關係呢?,好，請接著向下看來：

預先處理語句雖然有以上的許多優點，但它有個比較致命的缺點，即，預先處理語句僅僅只是簡單值替代，缺乏類型的檢測機制。這樣預先處理語句就不能享受C++嚴格類型檢查的好處，從而可能成為引發一系列錯誤的隱患。

4．好了，第一階段結論出來了：

結論： Const 推出的初始目的，正是為了取代先行編譯指令，消除它的缺點，同時繼承它的優點。

現在它的形式變成了：

Const DataType VariableName = VariableValue ;為什麼const能很好地取代預定義語句？const 到底有什麼大神通，使它可以振臂一揮取代預定義語句呢？

1． 首先，以const 修飾的常量值，具有不可變性，這是它能取代預定義語句的基礎。

2． 第二，很明顯，它也同樣可以避免意義模糊的數字出現，同樣可以很方便地進行參數的調整和修改。

3． 第三，C++的編譯器通常不為普通const常量分配儲存空間，而是將它們儲存在符號表中，這使得它成為一個編譯期間的常量，沒有了儲存與讀記憶體的操作，使得它的效率也很高，同時，這也是它取代預定義語句的重要基礎。

這裡，我要提一下，為什麼說這一點是也是它能取代預定義語句的基礎，這是因為，編譯器不會去讀儲存的內容，如果編譯器為const分配了儲存空間，它就不能夠成為一個編譯期間的常量了。

4． 最後，const定義也像一個普通的變數定義一樣，它會由編譯器對它進行類型的檢測，消除了預定義語句的隱患。

 

我們也許學習過const的使用，但是對於const的細緻的技術細節卻不一定掌握。const的用法在許多的教材上只是簡單的介紹，在這裡我們對 const進行細緻的概念以及用法剖析。const 是由c++採用，並加進標準c中，但是他們的意義完全不同，在舊版本(標準前)的c中，如果想建立一個常量，必須使用前置處理器：
#define PI 3.14159

此後無論在何處使用PI，都會被前置處理器以3.14159替代。編譯器不對PI進行類型檢查，也就是說可以不受限制的建立宏並用它來替代值，如果使用不慎，很可能由預先處理引入錯誤，這些錯誤往往很難發現。

我們也不能得到PI的地址（即不能向PI傳遞指標和引用）。
c++引入了命名常量的概念，命名常量就像變數一樣，只是它的值不能改變，如果試圖改變一個const 對象，編譯器將會產生錯誤。 const 和正常變數一樣有範圍，所以函數內部的const也不會影響程式的其餘部分。在c++中const可以取代前置處理器#define來進行值替代， const有安全的類型檢查，所以不用擔心會像前置處理器一樣引入錯誤。

在通常的情況下const同前置處理器#define一樣只是將所賦值儲存入編譯器的符號表中（符號表僅僅在編譯時間存在，在編譯過程中編譯器將程式中的名字與之在符號表中定義的數值作簡單的替換），在使用的時候進行值替換，並不為const建立儲存空間。我們將const的定義放進標頭檔裡，這樣通過包含標頭檔，可以把const定義單獨放在一個地方並把它分配給一個編譯單元，const預設為內部串連（內部串連意味著只對正在編譯的檔案建立儲存空間，別的檔案可以使用相同的標示符和全域變數，編譯器不會發現衝突，外部串連意味著為所有被編譯過的檔案建立一片單獨的儲存空間，一般全域變數和函數名的外部串連通過extern聲明，可以通過其他的檔案訪問）也就是說const僅能被它所定義過的檔案訪問，在定義一個const時，必須賦一個值給它，除非用extern做出說明：

extern const int a;

這表示const的定義在其他的什麼地方，這裡僅僅是一個聲明，但是這樣的做法使const使用了外部串連，也就是說上面的extern強制進行了對const的儲存空間分配，這樣我們就無法再用const作為常量摺疊（在可能的情況下，符號常量的值會代替改名字的出現，這個替代過程叫做常量摺疊）使用了，即使我們在其他地方定義了const的值,如：

extern const int a=3;

因為const的值被放入了儲存單元，在編譯的過程中，編譯器不會去讀儲存單元的內容。如果我們這樣做：

int b[a];

編譯器就會給我們一個錯誤資訊。

想不為const分配儲存空間是不可能的，因為對於複雜的結構，例如集合，編譯器不會複雜到將集合儲存到它的符號表中，所以必須分配記憶體空間，這就意味著“這是一塊不能改變的儲存空間”，當然也就不能在編譯期間使用它的值，因為編譯器不知道儲存的內容：

const int i[]={1,2,3,4};

//float f[i[2]]; 
//將得到錯誤資訊，編譯器提示不能在數組定義裡找到一個常數運算式。

因為編譯器靠移動棧指標來儲存和讀取資料。
也因此，由於無法避免為const分配記憶體，所以const的定義必須預設為內部串連，否則由於眾多的const在多個檔案中分配記憶體，就會引起錯誤。下面我們看一段簡單有效代碼來說明const的常量摺疊：

#include <iostream.h>
const int a=3;
const int b=a+1;
float *f=(float*)&b;
char c[b+3];
void main()
{
const char gc=cin.get();
const char c2=gc+3;
}

我們可以看到，a是一個編譯器期間的const，b是從a中計算出來的，由於a是一個const，b的計算值來自一個常數運算式，而它自身也是一個編譯器間的const，接著下面指標f取得了b的地址，所以迫使編譯器給b分配了儲存空間，不過即使分配了儲存空間，由於編譯器已經知道了b的值,所以仍然不妨礙在決定數組c的大小時使用b。

在主函數main()裡，標識符gc的值在編譯期間是不知道的，這也意味著需要儲存空間，但是初始化要在定義點進行，而且一旦初始化，其值就不能改變，我們發現c2是由gc計算出來的，它的範圍與其他類型const的範圍是一樣的，這是對#define用法的一種改進。

在c++引進常量的時候，標準c也引入了const，但是在c中const的意思和在c++中有很大不同，在c中const的意思是“一個不能改變的普通變數”，const常量總是被分配儲存空間而且它的名字是全域符即const使用外部串連。於是在c中：

const int size=100;
char c[size];

得出一個錯誤。但是在c中可以這樣寫：

const int size;

因為c中的const被預設為外部串連，所以這樣做是合理的。
在c語言中使用限定符const不是很有用，如果希望在常數運算式裡（必須在編譯期間被求值）使用一個已命名的值，必須使用前置處理器#define。

在c++中可以使指標成為const，這很有用，如果以後想在程式碼中改變const這種指標的使用，編譯器將給出通知，這樣大大提高了安全性。在用帶有const的指標時，我們有兩種選擇：const修飾指標指向的對象，或者const修飾指標自己指向的儲存空間。

如果要使指向的對象不發生改變，則需要這樣寫：

const int *p;

這裡p是一個指向const int 的指標，它不需要初始化，因為p可以指向任何標識符，它自己並不是一個const，但是它所指的值是不能改變的，同樣的，我們可以這樣寫：

int const *p;

這兩種方法是等同的，依據個人習慣以及編碼風格不同，程式員自己決定使用哪一種形式。
如果希望使指標成為一個const必須將const標明的部分放在*右邊。

int a=3;
int *const j=&a

編譯器要求給它一個初始值，這個值在指標的生命期間內不變，也就是說指標始終指向a的地址，不過要改變它地址中的值是可以的：

*j+=4;

也可以是一個const指標指向一個const對象：

const int *j1=&a;
int const *j2=&a;

這樣指標和對象都不能改變，這兩種形式同樣是等同的。在賦值的的時候需要注意，我們可以將一個非const的對象地址賦給一個const指標，但是不能將一個const對象地址賦給一個非const指標，因為這樣可能通過被賦值的指標改變對象的值，當然也可以用類型的強制轉換來進行const對象的賦值，但是這樣做打破了const提供的安全性。

const也被用於限定函數參數和函數的傳回值，如果函數參數是按值傳遞時，即表示變數的初值不會被函數改變，如果函數的傳回值為const那麼對於內部類型來說按值返回的是否是一個cosnt是無關緊要的，編譯器不讓它成為一個左值，因為它是一個值而不是一個變數，所以使用const是多餘的，例如：

const int f(){return 1;}
void main(){int a=f();}

但是當處理使用者定義型別的時候，按值返回常量就很有意義了，這時候函數的傳回值不能被直接賦值也不能被修改。僅僅是非const傳回值能作為一個左值使用，但是這往往失去意義，因為函數傳回值在使用時通常儲存為一個臨時量，臨時量被作為左值使用並修改後，編譯器將臨時量清除。結果丟失了所有的修改。
可以用const限定傳遞或返回一個地址（即一個指標或一個引用）：

const int * const func(const int *p)
{ static int a=*p;
return &a;
}

參數內的const限定指標p指向的資料不能被改變，此後p的值被賦給靜態變數a,然後將a的地址返回，這裡a是一個靜態變數，在函數運行結束後，它的生命期並沒有結束，所以可以將它的地址返回。因為函數返回一個const int* 型，所以函數func的傳回值不可以賦給一個非指向const的指標，但它同時接受一個const int * const和一個const int *指標，這是因為在函數返回時產生一個const臨時指標用以存放a的地址，所以自動產生了這種原始變數不能被改變的約定，於是*右邊的const只有當作左值使用時才有意義。

const同樣運用於類中，但是它的意義又有所不同，我們可以建立const的資料成員，const的成員函數，甚至是const的對象，但是保持類的對象為const比較複雜，所以const對象只能調用const成員函數。

const的資料成員在類的每一個對象中分配儲存，並且一旦初始化這個值在對象的生命期內是一個常量，因此在類中建立一個const資料成員時，初始化工作必須在建構函式初始化列表中。如果我們希望建立一個有編譯期間的常量成員，這就需要在該常量成員的前面使用static限定符，這樣所有的對象都僅有一個執行個體：

class X
{
static const int size=50;
int a[size];
public:
X();
};

const對象只能調用const成員函數，一個普通對象同樣可以調用const成員函數，因此，const成員函數更具有一般性，但是成員函數不會預設為const。聲明一個const成員函數，需要將const限定符放在函數名的後面：

void f (void ) const;

當我們運用const成員函數時，遇到需要改變資料成員，可以用mutable進行特別的指定：

class X
{
mutable int i;
public:
X();
void nochange() const;
};

void X::nochange const(){i++;}

const消除了前置處理器的值替代的不良影響，並且提供了良好的類型檢查形式和安全性，在可能的地方儘可能的使用const對我們的編程有很大的協助。

 

 

小結:

const int i=10;//這個類似宏替換，也就是說，它最佳化之後可能是放一個符號表裡面。所有使用i的地方都用10代替，但是當你對i取址後，沒辦法，編譯器必須為i在常量區找個地方安身。這就是所謂的常量摺疊.

 

內容取自互連網與《C++編程思想》