面向物件是C++的重要特性.

但是c++在c的基礎上新增加的幾點優化也是很耀眼的
就const直接可以取代c中的#define
以下幾點很重要,學不好後果也也很嚴重

const
1. 限定符宣告變數只能被讀
const int i=5;
int j=0;
...
i=j; //非法，導致編譯錯誤
j=i; //合法
2. 必須初始化
const int i=5; //合法
const int j; //非法，導致編譯錯誤
3. 在另一連線檔案中引用const常量
extern const int i; //合法
extern const int j=10; //非法，常量不可以被再次賦值
4. 便於進行型別檢查
用const方法可以使編譯器對處理內容有更多瞭解。
#define I=10
const long &i=10; /*dapingguo提醒：由於編譯器的優化，使
得在const long i=10; 時i不被分配記憶體，而是已10直接代入
以後的引用中，以致在以後的程式碼中沒有錯誤，為達到說教效
果，特別地用&i明確地給出了i的記憶體分配。不過一旦你關閉所
有優化措施，即使const long i=10;也會引起後面的編譯錯誤。*/
char h=I; //沒有錯
char h=i; //編譯警告，可能由於數的截短帶來錯誤賦值。
5. 可以避免不必要的記憶體分配
#define STRING "abcdefghijklmn\n"
const char string[]="abcdefghijklm\n";
...
printf(STRING); //為STRING分配了第一次記憶體
printf(string); //為string一次分配了記憶體，以後不再分配
...
printf(STRING); //為STRING分配了第二次記憶體
printf(string);
...
由於const定義常量從彙編的角度來看，只是給出了對應的記憶體地址，
而不是象#define一樣給出的是立即數，所以，const定義的常量在
程式執行過程中只有一份拷貝，而#define定義的常量在記憶體中有
若干個拷貝。
6. 可以通過函式對常量進行初始化
int value();
const int i=value();
dapingguo說：假定對ROM編寫程式時，由於目的碼的不可改寫，
本語句將會無效，不過可以變通一下：
const int &i=value();
只要令i的地址處於ROM之外，即可實現：i通過函式初始化，而其
值有不會被修改。
7. 是不是const的常量值一定不可以被修改呢？
觀察以下一段程式碼：
const int i=0;
int *p=(int*)&i;
p=100;
通過強制型別轉換，將地址賦給變數，再作修改即可以改變const常量值。
8. 請分清數值常量和指標常量，以下宣告頗為玩味：
int ii=0;
const int i=0; //i是常量，i的值不會被修改
const int *p1i=&i; //指標p1i所指內容是常量，可以不初始化
int * const p2i=ⅈ //指標p2i是常量，所指內容可修改
const int * const p3i=&i; //指標p3i是常量，所指內容也是常量
p1i=ⅈ //合法
*p2i=100; //合法
關於C++中的const關鍵字的用法非常靈活，而使用const將大大改善程式的健壯性，參考了康建東兄的const使用詳解一文，對其中進行了一些補充，寫下了本文。


1. const常量，如const int max = 100;
優點：const常量有資料型別，而巨集常量沒有資料型別。編譯器可以對前者進行型別安全檢查，而對後者只進行字元替換，沒有型別安全檢查，並且在字元替換時可能會產生意料不到的錯誤（邊際效應）

2. const 修飾類的資料成員。如：
class A

{

const int size;

…

}

const 資料成員只在某個物件生存期內是常量，而對於整個類而言卻是可變的。因為類可以建立多個物件，不同的物件其const資料成員的值可以不同。所以不能在類 宣告中初始化const資料成員，因為類的物件未被建立時，編譯器不知道const 資料成員的值是什麼。如

class A

{

const int size = 100; //錯誤

int array[size]; //錯誤，未知的size

}

const資料成員的初始化只能在類的建構函式的初始化表中進行。要想建立在整個類中都恆定的常量，應該用類中的列舉常量來實現。如

class A

{…

enum {size1=100, size2 = 200 };

int array1[size1];

int array2[size2];

}

列舉常量不會佔用物件的儲存空間，他們在編譯時被全部求值。但是列舉常量的隱含資料型別是整數，其最大值有限，且不能表示浮點數。

3. const修飾指標的情況，見下式：

int b = 500;
const int* a = & [1]
int const *a = & [2]
int* const a = & [3]
const int* const a = & [4]
如 果你能區分出上述四種情況，那麼，恭喜你，你已經邁出了可喜的一步。不知道，也沒關係，我們可以參考《Effective c++》Item21上的做法，如果const位於星號的左側，則const就是用來修飾指標所指向的變數，即指標指向為常量；如果const位於星號的 右側，const就是修飾指標本身，即指標本身是常量。因此，[1]和[2]的情況相同，都是指標所指向的內容為常量（const放在變數宣告符的位置無 關），這種情況下不允許對內容進行更改操作，如不能*a = 3 ；[3]為指標本身是常量，而指標所指向的內容不是常量，這種情況下不能對指標本身進行更改操作，如a++是錯誤的；[4]為指標本身和指向的內容均為常 量。

4. const的初始化
先看一下const變數初始化的情況
1) 非指標const常量初始化的情況：A b;
const A a = b;
2) 指標const常量初始化的情況：

A* d = new A();
const A* c = d;
或者：const A* c = new A();
3）引用const常量初始化的情況：
A f;
const A& e = f; // 這樣作e只能訪問宣告為const的函式，而不能訪問一

般的成員函式；
[思考1]： 以下的這種賦值方法正確嗎？
const A* c=new A();
A* e = c;
[思考2]： 以下的這種賦值方法正確嗎？
A* const c = new A();
A* b = c;

5. 另外const 的一些強大的功能在於它在函式宣告中的應用。在一個函式宣告中，const 可以修飾函式的返回值，或某個引數；對於成員函式，還可以修飾是整個函式。有如下幾種情況，以下會逐漸的說明用法：A& operator=(const A& a);
void fun0(const A* a );
void fun1( ) const; // fun1( ) 為類成員函式
const A fun2( );

1） 修飾引數的const，如 void fun0(const A* a ); void fun1(const A& a);
調 用函式的時候，用相應的變數初始化const常量，則在函式體中，按照const所修飾的部分進行常量化，如形參為const A* a，則不能對傳遞進來的指標的內容進行改變，保護了原指標所指向的內容；如形參為const A& a，則不能對傳遞進來的引用物件進行改變，保護了原物件的屬性。
[注意]：引數const通常用於引數為指標或引用的情況，且只能修飾輸入引數;若輸入引數採用“值傳遞”方式，由於函式將自動產生臨時變數用於複製該引數，該引數本就不需要保護，所以不用const修飾。

[總結]對於非內部資料型別的輸入引數，因該將“值傳遞”的方式改為“const引用傳遞”，目的是為了提高效率。例如，將void Func(A a)改為void Func(const A &a)

對於內部資料型別的輸入引數，不要將“值傳遞”的方式改為“const引用傳遞”。否則既達不到提高效率的目的，又降低了函式的可理解性。例如void Func(int x)不應該改為void Func(const int &x)

2） 修飾返回值的const，如const A fun2( ); const A* fun3( );
這樣聲明瞭返回值後，const按照"修飾原則"進行修飾，起到相應的保護作用。const Rational operator*(const Rational& lhs, const Rational& rhs)
{
return Rational(lhs.numerator() * rhs.numerator(),
lhs.denominator() * rhs.denominator());
}
返回值用const修飾可以防止允許這樣的操作發生:Rational a,b;
Radional c;
(a*b) = c;
一般用const修飾返回值為物件本身（非引用和指標）的情況多用於二目操作符過載函式併產生新物件的時候。
[總結]

1. 一般情況下，函式的返回值為某個物件時，如果將其宣告為const時，多用於操作符的過載。通常，不建議用const修飾函式的返回值型別為某個物件或對 某個物件引用的情況。原因如下：如果返回值為某個物件為const（const A test = A 例項）或某個物件的引用為const（const A& test = A例項） ，則返回值具有const屬性，則返回例項只能訪問類A中的公有（保護）資料成員和const成員函式，並且不允許對其進行賦值操作，這在一般情況下很少 用到。

2. 如果給採用“指標傳遞”方式的函式返回值加const修飾，那麼函式返回值（即指標）的內容不能被修改，該返回值只能被賦給加const 修飾的同類型指標。如：

const char * GetString(void);

如下語句將出現編譯錯誤：

char *str=GetString();

正確的用法是：

const char *str=GetString();

3. 函式返回值採用“引用傳遞”的場合不多，這種方式一般只出現在類的賻值函式中，目的是為了實現鏈式表達。如：

class A

{…

A &operate = (const A &other); //負值函式

}
A a,b,c; //a,b,c為A的物件

…

a=b=c; //正常

(a=b)=c; //不正常，但是合法

若負值函式的返回值加const修飾，那麼該返回值的內容不允許修改，上例中a=b=c依然正確。(a=b)=c就不正確了。
[思考3]： 這樣定義賦值操作符過載函式可以嗎？
const A& operator=(const A& a);

6. 類成員函式中const的使用
一般放在函式體後，形如：void fun() const;
任何不會修改資料成員的函式都因該宣告為const型別。如果在編寫const成員函式時，不慎修改了資料成員，或者呼叫了其他非const成員函式，編譯器將報錯，這大大提高了程式的健壯性。如：

class Stack

{

public:

void Push(int elem);

int Pop(void);

int GetCount(void) const; //const 成員函式

private:

int m_num;

int m_data[100];

};

int Stack::GetCount(void) const

{

++m_num; //編譯錯誤，企圖修改資料成員m_num

Pop(); //編譯錯誤，企圖呼叫非const函式

Return m_num;

}

7. 使用const的一些建議
1 要大膽的使用const，這將給你帶來無盡的益處，但前提是你必須搞清楚原委；
2 要避免最一般的賦值操作錯誤，如將const變數賦值，具體可見思考題；
3 在引數中使用const應該使用引用或指標，而不是一般的物件例項，原因同上；
4 const在成員函式中的三種用法（引數、返回值、函式）要很好的使用；
5 不要輕易的將函式的返回值型別定為const;
6除了過載操作符外一般不要將返回值型別定為對某個物件的const引用;
[思考題答案]
1 這種方法不正確，因為宣告指標的目的是為了對其指向的內容進行改變，而宣告的指標e指向的是一個常量，所以不正確；
2 這種方法正確，因為宣告指標所指向的內容可變；
3 這種做法不正確；
在const A::operator=(const A& a)中，引數列表中的const的用法正確，而當這樣連續賦值的時侯，問題就出現了：
A a,b,c:
(a=b)=c;
因為a.operator=(b)的返回值是對a的const引用，不能再將c賦值給const常量。

1.1.1. 定義普通常量
使用#define來定義常量也是常用方法，但const也可以用來定義常量，在[Effective C++]中建議使用const代替#define來定義常量，因為const定義的常量具有型別資訊，而巨集沒有，所以使用const定義的常量在進行賦值操作時編譯器會進行更嚴格的型別檢查，是型別安全的。

const double PI = 3.1414926;

const int POOL_SIZE = 20;

定義常量有三種方法：巨集、const、enum，其中巨集應該儘量避免，而const與enum也各有優缺點，最大的區別就是enum只能用於定義整數，而不能定義浮點數；而對於定義邏輯關係較近的一組整數時比較適合使用enum，也可以考慮使用類代替enum(參見[??])。

常量必須在定義時進行初始化，之後便不能再賦值。說它不能被賦值並不是說常量的值是絕對不會改變的，只是說不能直接賦值，但可以通過指標及強制型別轉換、const_cast是可以改變常量的值的。

#include

using namespace std;

int main( void )

{

const int ci = 5;

const int* cpci = &ci;

int *pci = (int*)&ci;

cout<<"cpci = "<

return 0;

}

輸出結果：

cpci = 002DFAC8, pci = 002DFAC8

ci=5, *cpci=1, *pci=1

ci=5, *cpci=2, *pci=2

ci != *cpci

之所以使用ci直接輸出變數的值時顯示其值始終沒有改變，但通過指標間接顯示出來的值是改變了，而且輸出結果的最後一行很奇怪，ci的值與*cpci的值居然不相等，只因為編譯器在編譯時進行了優化，將程式碼中的ci直接替換成了5，與巨集替換是相同的效果，而指標的值則是實際記憶體中的值。

所以，千萬不要試圖使用指標強行改變const變數的值，否則程式可能表現出錯誤的行為，而且查詢起來這種錯誤非常困難。在gcc 4.3.4和visual C++ 2010中均預設打開了對常量的優化選項，目前還沒找到關閉該優化的命令列選項，一定不要自作聰明去改const變數的值。

1.1.2. 修飾指標
把const與指標放到一起，很多人便會想到一個繞口令“指標常量與常量指標。“指標常量”即一個指標變數，該變數不能被賦值，而指標指向的記憶體單元的內容是可以改變的；“常量指標”即一個指向常量的指標，指標變數本身可以賦值，而指標指向的記憶體單元的內容是不可以被重新賦值的。

char a = 'A', b = 'B';

const char* ptoc = &a; // 常量指標

*ptoc = 'C'; // 改變指標指向記憶體單元的內容，不可以

ptoc = &b; // 改變指標的值，可以

char* const cp = &a; // 指標常量

cp = &b; // 改變指標的值，不可以

*cp = 'D'; // 改變指標指向記憶體單元的內容，可以

const char* const cptoc = &a; // 指向常量的指標常量

*cptoc = 'E'; // 不可以

cptoc = &b; // 不可以

const是修飾型別還是修飾指標，要看const的位置，放在*前就是修飾資料型別，放到*後就是修飾指標，const char和char const是一樣的。

建議：在不打算修改資料內容的時候都將指標定義成常量指標，不打算指標本身被修改的場合都定義成指標常量。儘可能地多用const，用錯了沒關係，編譯器會提示你的，只要能夠編譯通過，就不會因為用錯const而導致程式邏輯錯誤，應該說const負作用極小。

1.1.3. 修飾類成員常量
當使用const修飾類成員變數時便定義了常資料成員，它的使用與使用類外定義的常量本質上並沒有什麼區別，在這裡只想指出一點：有網友提到const資料成員只能被const修飾的函式使用這是沒有根據的，是錯誤的。

1.1.4. 修飾類成員函式
const修飾成員函式語法：

class Socket

{

public:

typedef unsigned short socket_port_t;

socket_port_t LocalPort( void ) const

{

++readCount;

return _port;

}

private:

socket_port_t _port;

mutable int _readCount;

};

使用const修飾的成員函式不能修改類的成員變數，如成員_port，而且只能呼叫成員類物件const函式，但有個例外，就是mutable修飾的成員變數可以在const修飾的成員函式中被修改，如_readCount。

另外，const只能修飾非靜態函式。

建議：將所有不改變物件狀態的函式都使用const修飾符標識，以提高程式的可讀性。其實，標頭檔案就是最好的類介面的說明文件，越多的提供資訊就能使程式的可讀性越好，越利於維護。看到成員函式的const修飾符，讀者便立即明白該函式不會改變程式的狀態，這也有利於當程式狀態出現異常時的問題定位。

1.1.5. 修飾類物件、物件引用或物件指標（常量指標）
當const修飾自定義的類物件時，與修飾C++內建型別的變數的思想是一致的，但稍有不同，除了不能被賦值外，還不能呼叫沒有使用const修飾的非靜態成員函式。當const修飾類物件引用、指標時限制是一樣的，因為引用本身與直接使用該變數實質上沒有區別，而使用指標只是將.操作符改為了->本質上還是一樣的

const std::string hello = “Hello from Noock Tian;

std::cout<

hello = "Hi"; // 不可以賦值

hello.push_back("!"); // 不可以

1.1.6. 修飾函式引數
const修飾函式的例子是很常見了，表示函式的引數在函式體內不會被意外修改，一般用於修飾輸入引數，例如標準庫中的字串連線函式。str1是輸出引數，其內容會被修改，而str2為輸入引數，其內容不會修改。

char* strcat(char* str1, const char* str2);

實際上在說到const用法一開始就提到，const只是一種宣告，但並不能保證，例如strcat函式雖然聲明瞭str2為const char*型，但並不能保證內部絕對不會修改str2的內容。但const從語言本身提供了一種編寫自描述性程式碼的方法，只要使用函式與實現函式的雙方都達成一致的約定，按照契約程式設計，我們就可以認為const修飾的型別在函式體內不會被修改，這與const修飾類成員函式一樣，可以提高軟體的可讀性。

1.1.7. 修飾函式返回值
const可以用於修飾任何型別，只要返回值型別不是void，const就可以用來修飾返回值的型別。但實際上const用於修飾非引用的返回值型別是沒有意義的，因為返回值一般都會被賦值給另一個變數，此時用於傳遞返回值的物件已經被銷燬，修飾返回值型別的const的作用也就終結了。

當返回值是引用型別時，如果該引用的值不希望被修改是可以宣告為常引用的，例如：

class Socket

{

public:

const string& IP( void ) const{ return _ip; }

private:

string _ip;

};

Socket sock;

string& ip = sock.IP(); // 不可以

const string& ip2 = sock.IP(); // 可以

string ip3 = sock.IP(); // Socket::_ip被複制，可以

此處，為了減少構造臨時變數，將IP函式返回值定義為引用型別以提高程式執行效率，但為了保護內部狀態不會被客戶端程式碼意外，返回值使用const修飾為常引用。但是，如果對於軟體安全性較高的場合，最好不要定義為引用，因為惡意的客戶端程式碼是有可能修改Socket::_ip的值的。

在C++中賦值運算子反預設返回值都是引用，但筆者認為定義為常引用更為合適，例如：

int main( void )

{

int a = 1,b = 2,c = 3,d = 4;

((a=b)=c)=d;

cout<<”a=”<

return 0;

}

輸出結果：

a=4, b=2, c=3, d=4

顯然，在實際工程中誰也不會寫出這樣的程式碼，這段程式碼卻是合法的，無疑這給程式設計師多了一種出錯的可能，如果把賦值運算子的返回值定義為常引用，則會減少程式設計師出錯的機會，例如[??]:

class Object

{

public:

const Object& operator=(const Object& a) { return *this; }

};

int main( void )

{

Object a, b, c, d;

a = b = c = d; // 可以

((a=b)=c)=d; // 不可以

return 0;

}

在gcc 編譯時則會出現錯誤提示：

error: passing ‘const Object’ as ‘this’ argument of ‘const Object& Object::operator=(const Object&)’ discards qualifiers.
當然，不同的編譯器可能錯誤提示不同。