面向對象是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.
當然，不同的編譯器可能錯誤提示不同。