雜項

進行高效的C++程序設計有很多準則，其中有一些很難歸類。本章就是專門為這些準則而安排的。不要因此而小看了它們的重要性。要想寫出高效的軟件，就必須知道：編譯器在背后為你（給你?）做了些什么，怎樣保證非局部的靜態對象在被使用前已經被初始化，能從標準庫得到些什么，從何處著手深入理解語言底層的設計思想。本書最后的這個章節，我將詳細說明這些問題，甚至更多其它問題。

條款45: 弄清C++在幕后為你所寫、所調用的函數

一個空類什么時候不是空類？ ---- 當C++編譯器通過它的時候。如果你沒有聲明下列函數，體貼的編譯器會聲明它自己的版本。這些函數是：一個拷貝構造函數，一個賦值運算符，一個析構函數，一對取址運算符。另外，如果你沒有聲明任何構造函數，它也將為你聲明一個缺省構造函數。所有這些函數都是公有的。換句話說，如果你這么寫：

class Empty{};

和你這么寫是一樣的：

class Empty {
public:
 Empty();/t/t        // 缺省構造函數
 Empty(const Empty& rhs);        // 拷貝構造函數

 ~Empty();/t/t       // 析構函數 ---- 是否
/t/t/t/t  // 為虛函數看下文說明
 Empty&
 operator=(const Empty& rhs);    // 賦值運算符

 Empty* operator&();/t     // 取址運算符
 const Empty* operator&() const;
};

現在，如果需要，這些函數就會被生成，但你會很容易就需要它們。下面的代碼將使得每個函數被生成：

const Empty e1;/t/t     // 缺省構造函數
/t/t/t/t    // 析構函數

Empty e2(e1);/t/t       // 拷貝構造函數

e2 = e1;/t/t/t    //  賦值運算符

Empty *pe2 = &e2;/t/t   // 取址運算符
/t/t/t/t    // (非const)

const Empty *pe1 = &e1;/t     //  取址運算符
/t/t/t/t    // (const)

假設編譯器為你寫了函數，這些函數又做些什么呢？是這樣的，缺省構造函數和析構函數實際上什么也不做，它們只是讓你能夠創建和銷毀類的對象（對編譯器來說，將一些 "幕后" 行為的代碼放在此處也很方便 ---- 參見條款33和M24。）。注意，生成的析構函數一般是非虛擬的（參見條款14），除非它所在的類是從一個聲明了虛析構函數的基類繼承而來。缺省取址運算符只是返回對象的地址。這些函數實際上就如同下面所定義的那樣：

inline Empty::Empty() {}

inline Empty::~Empty() {}

inline Empty * Empty::operator&() { return this; }

inline const Empty * Empty::operator&() const
{ return this; }

至于拷貝構造函數和賦值運算符，官方的規則是：缺省拷貝構造函數（賦值運算符）對類的非靜態數據成員進行 "以成員為單位的" 逐一拷貝構造（賦值）。即，如果m是類C中類型為T的非靜態數據成員，并且C沒有聲明拷貝構造函數（賦值運算符），m將會通過類型T的拷貝構造函數（賦值運算符）被拷貝構造（賦值）---- 如果T有拷貝構造函數（賦值運算符）的話。如果沒有，規則遞歸應用到m的數據成員，直至找到一個拷貝構造函數（賦值運算符）或固定類型（例如，int，double，指針，等）為止。默認情況下，固定類型的對象拷貝構造（賦值）時是從源對象到目標對象的 "逐位" 拷貝。對于從別的類繼承而來的類來說，這條規則適用于繼承層次結構中的每一層，所以，用戶自定義的構造函數和賦值運算符無論在哪一層被聲明，都會被調用。

我希望這已經說得很清楚了。

但怕萬一沒說清楚，還是給個例子。看這樣一個NamedObject模板的定義，它的實例是可以將名字和對象聯系起來的類：

template<class T>
class NamedObject {
public:
 NamedObject(const char *name, const T& value);
 NamedObject(const string& name, const T& value);

 ...

private:
 string nameValue;
 T objectValue;
};

因為NamedObject類聲明了至少一個構造函數，編譯器將不會生成缺省構造函數；但因為沒有聲明拷貝構造函數和賦值運算符，編譯器將生成這些函數（如果需要的話）。

看下面對拷貝構造函數的調用：

NamedObject<int> no1("Smallest Prime Number", 2);

NamedObject<int> no2(no1);      // 調用拷貝構造函數

編譯器生成的拷貝構造函數必須分別用no1.nameValue和no1.objectValue來初始化no2.nameValue和no2.objectValue。nameValue的類型是string，string有一個拷貝構造函數（你可以在標準庫中查看string來證實 ---- 參見條款49），所以no2.nameValue初始化時將調用string的拷貝構造函數，參數為no1.nameValue。另一方面，NamedObject<int>::objectValue的類型是int（因為這個模板實例中，T是int），int沒有定義拷貝構造函數，所以no2.objectValue是通過從no1.objectValue拷貝每一個比特(bit)而被初始化的。

編譯器為NamedObject<int>生成的賦值運算符也以同樣的方式工作，但通常，編譯器生成的賦值運算符要想如上面所描述的那樣工作，與此相關的所有代碼必須合法且行為上要合理。如果這兩個條件中有一個不成立，編譯器將拒絕為你的類生成operator=，你就會在編譯時收到一些診斷信息。

例如，假設NamedObject象這樣定義，nameValue是一個string的引用，objectValue是一個const T：

template<class T>
class NamedObject {
public:
 // 這個構造函數不再有一個const名字參數，因為nameValue
 // 現在是一個非const string的引用。char*構造函數
 // 也不見了，因為引用要指向的是string
 NamedObject(string& name, const T& value);

 .../t/t/t  // 同上，假設沒有
/t/t/t       // 聲明operator=
private:
 string& nameValue;/t   // 現在是一個引用
 const T objectValue;/t // 現在為const
};

現在看看下面將會發生什么：

string newDog("Persephone");
string oldDog("Satch");

NamedObject<int> p(newDog, 2);      // 正在我寫本書時，我們的
/t/t/t/t    // 愛犬Persephone即將過
/t/t/t/t    // 她的第二個生日

NamedObject<int> s(oldDog, 29);     // 家犬Satch如果還活著，
/t/t/t/t    // 會有29歲了（從我童年時算起）

p = s;/t/t/t      // p中的數據成員將會發生
/t/t/t/t    // 些什么呢？

賦值之前，p.nameValue指向某個string對象，s.nameValue也指向一個string，但并非同一個。賦值會給p.nameValue帶來怎樣的影響呢？賦值之后，p.nameValue應該指向 "被s.nameValue所指向的string" 嗎，即，引用本身應該被修改嗎？如果是這樣，那太陽從西邊出來了，因為C++沒有辦法讓一個引用指向另一個不同的對象（參見條款M1）。或者，p.nameValue所指的string對象應該被修改嗎？ 這樣的話，含有 "指向那個string的指針或引用" 的其它對象也會受影響，也就是說，和賦值沒有直接關系的其它對象也會受影響。這是編譯器生成的賦值運算符應該做的嗎？

面對這樣的難題，C++拒絕編譯這段代碼。如果想讓一個包含引用成員的類支持賦值，你就得自己定義賦值運算符。對于包含const成員的類（例如上面被修改的類中的objectValue）來說，編譯器的處理也相似；因為修改const成員是不合法的，所以編譯器在隱式生成賦值函數時也會不知道怎么辦。還有，如果派生類的基類將標準賦值運算符聲明為private，  編譯器也將拒絕為這個派生類生成賦值運算符。因為，編譯器為派生類生成的賦值運算符也應該處理基類部分（見條款16和M33），但這樣做的話，就得調用對派生類來說無權訪問的基類成員函數，這當然是不可能的。

以上關于編譯器生成函數的討論引發了這樣的問題：如果想禁止使用這些函數，那該怎么辦呢？也就是說，假如你永遠不想讓類的對象進行賦值，所以有意不聲明operator=，那該怎么做呢？這個小難題的解決方案正是條款27討論的主題。指針成員和編譯器生成的拷貝構造函數及賦值運算符之間的相互影響經常被人忽視，關于這個話題的討論請查看條款11。