使用const提高函數(shù)的健壯性
看到const關(guān)鍵字，C++程序員首先想到的可能是const常量.這可不是良好的條件反射.如果只知道用const定義常量，那么相當(dāng)于把火藥僅用于制作鞭炮.const更大的魅力是它可以修飾函數(shù)的參數(shù)、返回值，甚至函數(shù)的定義體
const是constant的縮寫，“恒定不變”的意思.被const修飾的東西都受到強(qiáng)制保護(hù)，可以預(yù)防意外的變動(dòng)，能提高程序的健壯性.所以很多C++程序設(shè)計(jì)書籍建議：“Use const whenever you need”.
11.1.1 用const修飾函數(shù)的參數(shù)
如果參數(shù)作輸出用，不論它是什么數(shù)據(jù)類型，也不論它采用“指針傳遞”還是“引用傳遞”，都不能加const修飾，否則該參數(shù)將失去輸出功能
const只能修飾輸入?yún)?shù)：
如果輸入?yún)?shù)采用“指針傳遞”，那么加const修飾可以防止意外地改動(dòng)該指針，起到保護(hù)作用..
例如StringCopy函數(shù)：
void StringCopy(char *strDestination, const char *strSource);其中strSource是輸入?yún)?shù)，strDestination是輸出參數(shù).給strSource加上const修飾后，如果函數(shù)體內(nèi)的語句試圖改動(dòng)strSource的內(nèi)容，編譯器將指出錯(cuò)誤..
如果輸入?yún)?shù)采用“值傳遞”，由于函數(shù)將自動(dòng)產(chǎn)生臨時(shí)變量用于復(fù)制該參數(shù)，該輸入?yún)?shù)本來就無需保護(hù)，所以不要加const修飾
例如不要將函數(shù)void Func1(int x) 寫成void Func1(const int x).同理不要將函數(shù)void Func2(A a) 寫成void Func2(const A a).其中A為用戶自定義的數(shù)據(jù)類型..
對于非內(nèi)部數(shù)據(jù)類型的參數(shù)而言，象void Func(A a) 這樣聲明的函數(shù)注定效率比較底.因?yàn)楹瘮?shù)體內(nèi)將產(chǎn)生A類型的臨時(shí)對象用于復(fù)制參數(shù)a，而臨時(shí)對象的構(gòu)造、復(fù)制、析構(gòu)過程都將消耗時(shí)間..
為了提高效率，可以將函數(shù)聲明改為void Func(A &a)，因?yàn)?#8220;引用傳遞”僅借用一下參數(shù)的別名而已，不需要產(chǎn)生臨時(shí)對象.但是函數(shù)void Func(A &a) 存在一個(gè)缺點(diǎn)：“引用傳遞”有可能改變參數(shù)a，這是我們不期望的.解決這個(gè)問題很容易，加const修飾即可，因此函數(shù)最終成為void Func(const A &a).
以此類推，是否應(yīng)將void Func(int x) 改寫為void Func(const int &x)，以便提高效率？完全沒有必要，因?yàn)閮?nèi)部數(shù)據(jù)類型的參數(shù)不存在構(gòu)造、析構(gòu)的過程，而復(fù)制也非常快，“值傳遞”和“引用傳遞”的效率幾乎相當(dāng)
問題是如此的纏綿，我只好將“const &”修飾輸入?yún)?shù)的用法總結(jié)一下
1,對于非內(nèi)部數(shù)據(jù)類型的輸入?yún)?shù)，應(yīng)該將“值傳遞”的方式改為“const引用傳遞”，目的是提高效率.例如將void Func(A a) 改為void Func(const A &a)..
2,對于內(nèi)部數(shù)據(jù)類型的輸入?yún)?shù)，不要將“值傳遞”的方式改為“const引用傳遞”.否則既達(dá)不到提高效率的目的，又降低了函數(shù)的可理解性.例如void Func(int x) 不應(yīng)該改為void Func(const int &x).
“const &”修飾輸入?yún)?shù)的規(guī)則
11.1.2 用const修飾函數(shù)的返回值
如果給以“指針傳遞”方式的函數(shù)返回值加const修飾，那么函數(shù)返回值(即指針)的內(nèi)容不能被修改，該返回值只能被賦給加const修飾的同類型指針
例如函數(shù)
const char * GetString(void);如下語句將出現(xiàn)編譯錯(cuò)誤
char *str = GetString();正確的用法是
const char *str = GetString();如果函數(shù)返回值采用“值傳遞方式”，由于函數(shù)會(huì)把返回值復(fù)制到外部臨時(shí)的存儲單元中，加const修飾沒有任何價(jià)值
例如不要把函數(shù)int GetInt(void) 寫成const int GetInt(void).
同理不要把函數(shù)A GetA(void) 寫成const A GetA(void)，其中A為用戶自定義的數(shù)據(jù)類型
如果返回值不是內(nèi)部數(shù)據(jù)類型，將函數(shù)A GetA(void) 改寫為const A & GetA(void)的確能提高效率.但此時(shí)千萬千萬要小心，一定要搞清楚函數(shù)究竟是想返回一個(gè)對象的“拷貝”還是僅返回“別名”就可以了，否則程序會(huì)出錯(cuò).見6.2節(jié)“返回值的規(guī)則”.
函數(shù)返回值采用“引用傳遞”的場合并不多，這種方式一般只出現(xiàn)在類的賦值函數(shù)中，目的是為了實(shí)現(xiàn)鏈?zhǔn)奖磉_(dá)
例如

  class A    {   
     …       
A & operate = (const A &other); // 賦值函數(shù)  
  };       
A a, b, c; // a, b, c 為A的對象   
…   
a = b = c; // 正常的鏈?zhǔn)劫x值  
  (a = b) = c; // 不正常的鏈?zhǔn)劫x值，但合法

如果將賦值函數(shù)的返回值加const修飾，那么該返回值的內(nèi)容不允許被改動(dòng).上例中，語句 a = b = c仍然正確，但是語句 (a = b) = c 則是非法的11.1.3 const成員函數(shù)
任何不會(huì)修改數(shù)據(jù)成員的函數(shù)都應(yīng)該聲明為const類型.如果在編寫const成員函數(shù)時(shí)，不慎修改了數(shù)據(jù)成員，或者調(diào)用了其它非const成員函數(shù)，編譯器將指出錯(cuò)誤，這無疑會(huì)提高程序的健壯性
以下程序中，類stack的成員函數(shù)GetCount僅用于計(jì)數(shù)，從邏輯上講GetCount應(yīng)當(dāng)為const函數(shù).編譯器將指出GetCount函數(shù)中的錯(cuò)誤
class Stack    {  
  public:       
    void Push(int elem);       
    int Pop(void);      
   int GetCount(void) const; // const成員函數(shù)    
 private:       
    int m_num;        
   int m_data[100];   
};      
  int Stack::GetCount(void) const  
  {      
  ++ m_num; // 編譯錯(cuò)誤，企圖修改數(shù)據(jù)成員m_num     
   Pop(); // 編譯錯(cuò)誤，企圖調(diào)用非const函數(shù)     
   return m_num;   
}

 
const成員函數(shù)的聲明看起來怪怪的：const關(guān)鍵字只能放在函數(shù)聲明的尾部，大概是因?yàn)槠渌胤蕉家呀?jīng)被占用了關(guān)于C++中的const關(guān)鍵字的用法非常靈活，而使用const將大大改善程序的健壯性，現(xiàn)將本人的一些體會(huì)總結(jié)如下，期望對大家有所幫助：
 一 const基礎(chǔ)
如果const關(guān)鍵字不涉及到指針，我們很好理解，下面是涉及到指針的情況：
int b = 500;
const int* a = &b;  [1]
int const *a = &b;  [2]
int* const a = &b;  [3]
const int* const a = &b; [4]
如果你能區(qū)分出上述四種情況，那么，恭喜你，你已經(jīng)邁出了可喜的一步。不知道，也沒關(guān)系，我們可以參考《Effective c++》Item21上的做法，如果const位于星號的左側(cè)，則const就是用來修飾指針?biāo)赶虻淖兞浚粗羔樦赶驗(yàn)槌Ａ浚蝗绻鹀onst位于星號的右側(cè)，const就是修飾指針本身，即指針本身是常量。因此，[1]和[2]的情況相同，都是指針?biāo)赶虻膬?nèi)容為常量（const放在變量聲明符的位置無關(guān)），這種情況下不允許對內(nèi)容進(jìn)行更改操作，如不能*a = 3 ；[3]為指針本身是常量，而指針?biāo)赶虻膬?nèi)容不是常量，這種情況下不能對指針本身進(jìn)行更改操作，如a++是錯(cuò)誤的；[4]為指針本身和指向的內(nèi)容均為常量。另外const 的一些強(qiáng)大的功能在于它在函數(shù)聲明中的應(yīng)用。在一個(gè)函數(shù)聲明中，const 可以修飾函數(shù)的返回值，或某個(gè)參數(shù)；對于成員函數(shù)，還可以修飾是整個(gè)函數(shù)。有如下幾種情況，以下會(huì)逐漸的說明用法：A& operator=(const A& a);void fun0(const A* a ); void fun1( ) const;    // fun1( ) 為類成員函數(shù)const A fun2( );

 二 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();引用： A f; const A& e = f;   // 這樣作e只能訪問聲明為const的函數(shù)，而不能訪問一般的成員函數(shù)；
[思考1]： 以下的這種賦值方法正確嗎？const A* c=new A();A* e = c;
[思考2]： 以下的這種賦值方法正確嗎？A* const c = new A();A* b = c;

 三 作為參數(shù)和返回值的const修飾符
其實(shí)，不論是參數(shù)還是返回值，道理都是一樣的，參數(shù)傳入時(shí)候和函數(shù)返回的時(shí)候，初始化const變量1 修飾參數(shù)的const，如 void fun0(const A* a ); void fun1(const A& a);調(diào)用函數(shù)的時(shí)候，用相應(yīng)的變量初始化const常量，則在函數(shù)體中，按照const所修飾的部分進(jìn)行常量化，如形參為const A* a，則不能對傳遞進(jìn)來的指針的內(nèi)容進(jìn)行改變，保護(hù)了原指針?biāo)赶虻膬?nèi)容；如形參為const A& a，則不能對傳遞進(jìn)來的引用對象進(jìn)行改變，保護(hù)了原對象的屬性。
[注意]：參數(shù)const通常用于參數(shù)為指針或引用的情況;2 修飾返回值的const，如const A fun2( ); const A* fun3( );這樣聲明了返回值后，const按照"修飾原則"進(jìn)行修飾，起到相應(yīng)的保護(hù)作用。const Rational operator*(const Rational& lhs, const Rational& rhs){return Rational(lhs.numerator() * rhs.numerator(),lhs.denominator() * rhs.denominator());}返回值用const修飾可以防止允許這樣的操作發(fā)生:Rational a,b;Radional c;(a*b) = c;一般用const修飾返回值為對象本身（非引用和指針）的情況多用于二目操作符重載函數(shù)并產(chǎn)生新對象的時(shí)候。
[總結(jié)] 一般情況下，函數(shù)的返回值為某個(gè)對象時(shí)，如果將其聲明為const時(shí)，多用于操作符的重載。通常，不建議用const修飾函數(shù)的返回值類型為某個(gè)對象或?qū)δ硞€(gè)對象引用的情況。原因如下：如果返回值為某個(gè)對象為const（const A test = A 實(shí)例）或某個(gè)對象的引用為const（const A& test = A實(shí)例） ，則返回值具有const屬性，則返回實(shí)例只能訪問類A中的公有（保護(hù)）數(shù)據(jù)成員和const成員函數(shù)，并且不允許對其進(jìn)行賦值操作，這在一般情況下很少用到。
[思考3]： 這樣定義賦值操作符重載函數(shù)可以嗎？const A& operator=(const A& a);

 四 類成員函數(shù)中const的使用
一般放在函數(shù)體后，形如：void fun() const;如果一個(gè)成員函數(shù)的不會(huì)修改數(shù)據(jù)成員，那么最好將其聲明為const，因?yàn)閏onst成員函數(shù)中不允許對數(shù)據(jù)成員進(jìn)行修改，如果修改，編譯器將報(bào)錯(cuò)，這大大提高了程序的健壯性。 

五 使用const的一些建議
1 要大膽的使用const，這將給你帶來無盡的益處，但前提是你必須搞清楚原委；
2 要避免最一般的賦值操作錯(cuò)誤，如將const變量賦值，具體可見思考題；
3 在參數(shù)中使用const應(yīng)該使用引用或指針，而不是一般的對象實(shí)例，原因同上；
4 const在成員函數(shù)中的三種用法（參數(shù)、返回值、函數(shù)）要很好的使用；
5 不要輕易的將函數(shù)的返回值類型定為const;6除了重載操作符外一般不要將返回值類型定為對某個(gè)對象的const引用;
 
 
[思考題答案]
1 這種方法不正確，因?yàn)槁暶髦羔樀哪康氖菫榱藢ζ渲赶虻膬?nèi)容進(jìn)行改變，而聲明的指針e指向的是一個(gè)常量，所以不正確；
2 這種方法正確，因?yàn)槁暶髦羔標(biāo)赶虻膬?nèi)容可變；
3 這種做法不正確；在const A::operator=(const A& a)中，參數(shù)列表中的const的用法正確，而當(dāng)這樣連續(xù)賦值的時(shí)侯，問題就出現(xiàn)了：A a,b,c:(a=b)=c;因?yàn)閍.operator=(b)的返回值是對a的const引用，不能再將c賦值給const常量。
 
首先我們來關(guān)注一下const的兩種寫法：
constint a = 1024;  //  等同于 int const a = 1024;
這兩種寫法是等價(jià)的，一般大多數(shù)人都會(huì)選擇第一種寫法。不過我認(rèn)為第二種寫法比較好一點(diǎn)，我來舉個(gè)例子：看過C++ Primer的人應(yīng)該記得，在講typedef那一節(jié)的時(shí)候有這么一個(gè)語句：
 
typedefchar *cstring;constcstring cstr;   // 你會(huì)理解成什么？
我想很多人一看到上面這個(gè)聲明就會(huì)認(rèn)為這是const char *cstr;可惜錯(cuò)了，const修飾的是cstring，而cstring代表了char *不是char，也就是把指針轉(zhuǎn)換為常量，即char *const cstr;(關(guān)于兩者的區(qū)別我將會(huì)在下面一節(jié)說明)。如果我們用const的第二種寫法就不會(huì)產(chǎn)生誤解了cstring const cstr;是不是很容易理解？所以我建議用第二種寫法(其實(shí)我也不太習(xí)慣J)。
---------------------------------------------------------------------
我們來看一行語句：
constint p = 1024;   // 如何定義一個(gè)指針來指向常量p
下面的定義對嗎？
int *pi = &p;         // 錯(cuò)了，不能用一個(gè)非常量指針指向常量pconstint *pi2 = &p;  // 毫無疑問，這是對的
讓我們再看一個(gè)定義：
// 是不是很奇怪？多加一個(gè)const，有什么不一樣嗎？constint *const pi3 = &p;
不一樣，在回答這個(gè)問題之前，先解釋一下const int *pi2的微妙之處:我們可這樣讀這個(gè)語句，pi2是一個(gè)指針(pi2本身不是常量),它指向一個(gè)常量p(它指向的對象p是常量)。這下明白了吧!我們可以給pi2賦其它的值，使它指向不同的對象，卻不能修改pi指向的對象，下面這個(gè)例子可以很好的說明這一點(diǎn)。
constint p = 1024;constint *pi2 = &p;*pi2 = 0;   // 錯(cuò)了，我們不可以修改p的值int a = 2;pi2 = &a    // 可以給pi2賦其它的值
注意：pi2指向的值可以不是const型，但我們?nèi)匀徊荒苄薷膒i2指向的對象。
現(xiàn)在再來看看另一個(gè)語句int *const pi4;我們只要把上面的語句反過來想就行了，pi4是一個(gè)常量指針，我們不可以修改它，但卻可以改變它指向的對象，HOHO，很簡單吧!再把上面兩個(gè)語句拼起來，得到一個(gè)const int *const pi3 = &p;答案出來了J……
---------------------------------------------------------------------
我們再看一個(gè)語句
constint &ir = 1024;
奇怪嗎？這個(gè)語句是正確的!原因是這樣的，1024是一個(gè)不可尋址的值，對于這樣的值要實(shí)現(xiàn)引用，編譯器必需生成一個(gè)臨時(shí)對象，用引用來指向這個(gè)臨時(shí)對象才行。
 
int temp = 1024;      // 給這個(gè)臨時(shí)對象起個(gè)名字tempconstint &ir = temp; // 引用指向的是它
那為什么一定要在int &ir前加一個(gè)const呢？假設(shè)int &ir正確，這時(shí)如果給ir賦個(gè)新值就會(huì)改變temp的值，是不是很糟糕! 所以要加上const，編譯器才會(huì)認(rèn)為是正確的。
---------------------------------------------------------------------
有了上面兩小節(jié)的準(zhǔn)備，讓我們來做這么一個(gè)題目：
constint p = 1024;
要求用const對象p的地址來初始化一個(gè)引用？
這道題有兩個(gè)解法，先說第一種，分兩步做：
constint *pi = &p;  // pi本身是非常量指針，指向一個(gè)const對象pconstint *&pp = pi; // 引用指向的是非常量指針pi
在這里，pp指向的指針pi是非常量指針，可以重新賦值，但不可以修改p的值。
再看第二種:
constint *const &pi2 = &p;
相信你已經(jīng)能理解這個(gè)語句了^-^!
---------------------------------------------------------------------
好了，寫的差不多了，再寫下去怕人笑話^0^，謝謝你看完這篇小文章，希望能對你有一點(diǎn)幫助，呵呵!讓我們共同進(jìn)步。
本文的主要參考書籍是  C++ Primer