1 缺省函數
設計一個類，沒有成員函數 (member function)，只有成員數據 (member data)
class DataOnly {
private:
std::string strName; // member data
int iData;
};
1.1 特殊成員函數
C++98 編譯器會為其隱式的產生四個函數：缺省構造函數，析構函數；拷貝構造函數，拷貝賦值算子
而 C++11 編譯器，除了產生這四個函數外，還會多產生兩個函數：移動構造函數，移動賦值算子
class DataOnly {
public:
DataOnly () // default constructor
~DataOnly () // destructor
DataOnly (const DataOnly & rhs) // copy constructor
DataOnly & operator=(const DataOnly & rhs) // copy assignment operator
DataOnly (const DataOnly && rhs) // C++11, move constructor
DataOnly & operator=(DataOnly && rhs) // C++11, move assignment operator
};
1.2 兩個實現形式
缺省構造函數，是為了初始化類的成員數據，相當於如下形式：
DataOnly::DataOnly(const DataOnly &orig): strName(orig.strName), iData(orig.iData) { }
而拷貝賦值算子的實現，則相當於如下形式：
DataOnly& DataOnly::operator=(const DataOnly &rhs)
{
strName = rhs.strName; // calls the string::operator=
iData = rhs.iData; // uses the built-in int assignment
return *this; // return a reference to this object
}
結尾為何返回 *this，可以參見另一篇博文 C++ 之 重載賦值操作符 中的 “1.1 鏈式賦值”
2 禁止缺省函數
作為開發者，如果不想讓用戶使用某個類成員函數，不聲明該函數即可；但對於由編譯器自動產生的特殊成員函數 (special member fucntions)，則是另一種情況。
例如，設計一個樹葉類，如下所示：
class LeafFromTree{ ... };
萊布尼茨說過，“世上沒有兩片完全相同的樹葉” (Es gibt keine zwei Blätter, die gleich bleiben)，因此，對於一片獨一無二的樹葉，下面的操作是錯誤的。
LeafFromTree leaf1; LeafFromTree leaf2; LeafFromTree Leaf3(Leaf1); // attempt to copy Leaf1 — should not compile! Leaf1 = Leaf2; // attempt to copy Leaf2 — should not compile!
由以上代碼可知，此時需要避免使用 “拷貝構造函數” 和 “拷貝賦值算子”
2.1 私有+不實現
C++98 中，可聲明這些特殊成員函數為私有型 (private)，且不實現該函數，具體如下：
class LeafFromTree{
private:
LeafFromTree( const LeafFromTree& ); // not defined
LeafFromTree & operator=( const LeafFromTree& ); // not defined
};
程序中如果調用了 LeafFromTree 類的拷貝構造函數 (或拷貝賦值操作符)，則在編譯時，會出現鏈接錯誤 (link-time error)
為了將報錯提前到編譯時 (compile time)，可增加了一個基類 Uncopyable，並將拷貝構造函數和拷貝賦值算子聲明為私有型
class Uncopyable {
protected:
Uncopyable() {} // allow construction and destruction of derived objects...
~Uncopyable() {}
private:
Uncopyable(const Uncopyable&); // ...but prevent copying
Uncopyable& operator=(const Uncopyable&);
};
而 LeafFromTree 則私有繼承自 Uncopyable 基類
// class no longer declares copy ctor or copy assign operator
class LeafFromTree: private Uncopyable { };
2.2 delete 關鍵字
C++11 中比較簡單，只需在想要 “禁止使用” 的函數聲明後加 “= delete”，需要保留的則加 "= default" 或者不采取操作
class LeafFromTree{
public:
LeafFromTree() = default;
~LeafFromTree() = default;
LeafFromTree( const LeafFromTree& ) = delete; // mark copy ctor or copy assignment operator as deleted functions
LeafFromTree & operator=( const LeafFromTree &) = delete;
};
3 delete 的擴展
C++11 中，delete 關鍵字可用於任何函數，不僅僅局限於類成員函數
3.1 函數重載
在函數重載中，可用 delete 來濾掉一些函數的形參類型，如下：
bool isLucky(int number); // original function bool isLucky(char) = delete; // reject chars bool isLucky(bool) = delete; // reject bools bool isLucky(double) = delete; // reject doubles and floats
這樣在調用 isLucky 函數時，如果參數類型不對，則會出現錯誤提示
if (isLucky('a')) … // error ! call to deleted function
if (isLucky(true)) … // error !
if (isLucky(3.5)) … // error !
3.2 模板特化
在模板特例化中，也可以用 delete 來過濾一些特定的形參類型。
例如，Widget 類中聲明了一個模板函數，當進行模板特化時，要求禁止參數為 void* 的函數調用。
如果按照 C++98 的 “私有不實現“ 思路，應該是將特例化的函數聲明為私有型，如下所示：
class Widget {
public:
template<typename T>
void processPointer(T* ptr) { … }
private:
template<>
void processPointer<void>(void*); // error!
};
問題是，模板特化應該被寫在命名空間域 (namespace scope)，而不是類域 (class scope)，因此，該方法會報錯。
而在 C++11 中，因為有了 delete 關鍵字，則可以直接在類域外，將特例化的模板函數聲明為 delete， 如下所示：
class Widget {
public:
template<typename T>
void processPointer(T* ptr) { … }
};
template<>
void Widget::processPointer<void>(void*) = delete; // still public, but deleted
這樣，當程序代碼中，有調用 void* 作形參的 processPointer 函數時，則編譯時就會報錯。
小結：
1) Prefer deleted functions to private undefined ones
2) Any function may be deleted, including non-member functions and template instantiations
參考資料：
<C++ Primer_5th> chapter 13 Copy Control
<Effective C++_3rd> item 5 , item 6
<Effective Modern C++> item 11 , item 17
