Effective C++讀書筆記之二 :盡可能使用const

條款三：盡可能使用const（use const whenever possible）
const允許你指定一個語義約束，而編譯器會強制實施這項約束。它允許你告訴編譯器和其他程序員某值應(yīng)該保持不變。有一條約束需要注意，那就是：如果const出現(xiàn)在*號的左邊，那就是說被指物是常量；如果出現(xiàn)在星號右邊，則表示指針本身是常量；如果出現(xiàn)在兩邊，則被指物和指針都是常量。如果被指物是常量，則關(guān)鍵字const寫在類型的前面和類型之后，星號之前兩種所表示的語義是相同的。例如下面這兩種寫法是一樣的：
void f1(const Widget* pw);
void f2(Widget const * pw);
const也可用來修飾STL中的迭代器。聲明迭代器為const就想聲明指針為const一樣（即T* const 指針），表示這個迭代器不得指向不同的東西。但它所指的東西的值是可以改變的。如果希望迭代器所指的東西不可改變（即模擬一個const T*指針），需要的是const_iterator:
std::vector<int> vec;
...
const std::vector<int>::iterator iter = vec.begin();// same as T* const
*iter = 10;                                                        //no problem
++iter;                                                              //wrong!!
std::vector<int>::const_iterator cIter = vec.begin();//same as const T*
*iter = 10;                                                             //wrong!!
++iter;                                                                  //no problem

const 最具威力（？）的用法是面對函數(shù)聲明時的應(yīng)用。在一個函數(shù)聲明式內(nèi)，const可以和函數(shù)返回值，各參數(shù)，函數(shù)自身（成員函數(shù)）產(chǎn)生關(guān)聯(lián)。
令函數(shù)返回一個常量值，往往可以降低因客戶錯誤而造成的意外，而又不至于放棄安全性和高效性。例如，考慮有理數(shù)的operator*聲明式：
class Rational(){...};
const Rational operator* (const Rational & lhs, const Rational & rhs);
也許你會說為什么返回一個const對象？原因是如果不這樣別人可能實現(xiàn)這樣的暴行：
Rational a,b,c;
...
(a*b)=c;
下面，主要說明const作用于成員函數(shù)。
許多人都忽視了這么一個事實，那就是如果兩個成員函數(shù)只是常量性不同，那么他們是可以重載的。考慮以下這個用來表示一大塊文字的class：

class TextBlock{
public:

const char& operator[](std::size_t position) const
{return text[position];}
char& operator[](std::size_t position)
{return text[position];}
private:
std::string text;
};
TextBlock的operator[]可以這么使用：
TextBlock tb("Hello");
std::cout << tb[0];  //調(diào)用non-const 

const TextBlock ctb("Hello");
std::cont << ctb[0]; //調(diào)用const

真是情形中const對象多用于passed by pointer-to-const或passed by reference-to-const的傳遞結(jié)果。上述的ctb太過于造作，下邊這個比較真實：

void print (const TextBlocd& ctb)
{
  std::cout << ctb[0];
  
}

只用重載operator[]并對不同的版本給予不同的返回類型，就可以令const和non-const獲得不同的處理。
此處需要注意一點，non-const operator[]的返回類型是個reference to char,不是char。如果operator[]返回的是個char，下邊的賦值就不能通過編譯：
tb[0] = 'x'; //error c2106: ' = ' : left operand must be l-value
那是因為，如果函數(shù)的返回類型是個內(nèi)置類型，那么改動函數(shù)的返回值從來就不合法。縱使合法，C++以by value返回對象這一事實（條款20）意味著改動的其實只是tb.text[0]的一個副本，不是tb.text[0]本身，那不是我們想要的結(jié)果。
下邊來說說在const和non-const成員函數(shù)中避免重復(fù)
假設(shè)TextBlock（和CTextBlock）內(nèi)的operator[]不單只是返回一個reference指向某字符，也執(zhí)行邊界檢查、志記訪問信息、甚至可能進行數(shù)據(jù)完整性檢驗。把所有這些同時放進const和non-const operator[]中，導(dǎo)致這樣的一個怪物：

class TextBlock{
public:

const char& operator[](std::size_t position) const
{
      //邊界檢查(bounds checking)
      //志記數(shù)據(jù)訪問(log access data)
      //檢驗數(shù)據(jù)完整性(verify data integrity)
return text[position];
}
char& operator[](std::size_t position)
{
      //邊界檢查(bounds checking)
      //志記數(shù)據(jù)訪問(log access data)
      //檢驗數(shù)據(jù)完整性(verify data integrity)
return text[position];
}
private:
std::string text;
};

其中代碼的代碼重復(fù)性及伴隨的編譯時間，維護，代碼膨脹等問題真是令人頭疼啊。當然了，將邊界檢查……等所有代碼移植到另一個成員函數(shù)，并令兩個版本的operator[]調(diào)用它，是可能的，但是還是重復(fù)了一些代碼，例如函數(shù)調(diào)用，兩次return語句等。
我們真正要做的，是實現(xiàn)operator[]的機能一次并使用它兩次。也就是說，你必須使一個調(diào)用另一個。這促使我們將常量性轉(zhuǎn)除（casting away constness）。
就一般而言，casting是一個糟糕的想法，在條款27中有詳細的說明。然而代碼重復(fù)也不是什么令人愉快的經(jīng)驗。本例中cosnt operator[]完全做掉了non-const版本該做的一切，唯一不同是其返回類型多了一個const資格修飾。這種情況下如果將返回值的const轉(zhuǎn)除是安全的，因為不論誰調(diào)用non-const operator[]都一定首先有個non-const對象，否則就不能夠調(diào)用non-const函數(shù)。所以令non-const operator[]調(diào)用其const兄弟是一個避免重復(fù)的安全做法：

class TextBlock{
public:

const char& operator[](std::size_t position) const
{



return text[position];
}
char& operator[](std::size_t position)
{
const_cast<char&>(static_cast<const TextBlock&>
(*this)[position]);
}

};

這里面有兩個轉(zhuǎn)型動作，而不是一個。我們打算讓non-const operator[]調(diào)用const兄弟，但是non-const如果只是單純調(diào)用operator[]，會遞歸調(diào)用自己。為了避免無窮遞歸，我們必須明確指出調(diào)用的是const operator[]。因此，這里將*this從其原始類型TextBlock&轉(zhuǎn)型為const TextBlock&。所以這里有兩次轉(zhuǎn)型：第一次用來為*this添加const，第二次則是從const operator[]的返回值中移除const。添加const的那一次轉(zhuǎn)型強迫進行了一次安全轉(zhuǎn)型，所以采用static_cast。移除const的那個動作只能由const_cast完成，沒有其他選擇。
下面來考慮一下反向的做法：令const來調(diào)用non-const以避免重復(fù)。這個不是我們應(yīng)該做的。const成員函數(shù)承諾絕對不改變其對象的邏輯狀態(tài)，non-const成員函數(shù)卻沒有這般承諾。如果在const函數(shù)內(nèi)部調(diào)用了non-const函數(shù)，就是冒了這樣的風(fēng)險：你曾經(jīng)承諾不改動的那個對象被改動了。這就是為什么“const成員函數(shù)調(diào)用non-const成員函數(shù)”是一種錯誤行為：因為對象有可能因此而被改動。反向調(diào)用才是安全的：non-const函數(shù)本來就可以對其對象做任何動作，所以在其中調(diào)用一個const成員函數(shù)并不會帶來任何風(fēng)險。

本條目總結(jié)：

Things to Remember

• Declaring something const helps compilers detect usage errors. const can be applied to objects at any scope, to function parameters and return types, and to member functions as a whole.

• Compilers enforce bitwise constness, but you should program using conceptual constness.

• When const and non-const member functions have essentially identical implementations, code duplication can be avoided by having the non-const version call the const version.
  

posted on 2008-12-09 23:00 Edmund 閱讀(292) 評論(0)  編輯 收藏 引用