對于C++ 11標準中支持的default函數，編譯器會為其自動生成默認的函數定義體，從而獲得更高的代碼執行效率，也可免除程序員手動定義該函數的工作量。
C++的類有四類特殊成員函數，它們分別是：
- 默認構造函數
- 析構函數
- 拷貝構造函數
- 拷貝賦值運算符
這些類的特殊成員函數負責創建、初始化、銷毀，或者拷貝類的對象，如果程序員沒有顯式地為一個類定義某個特殊成員函數，而又需要用到該特殊成員函數時，則編譯器會隱式的為這個類生成一個默認的特殊成員函數。例如：
清單 1
|
1
2
3
4
5
6
|
class X{private: int a;};X x; |
在清單 1 中，程序員并沒有定義類 X 的默認構造函數，但是在創建類 X 的對象 x 的時候，又需要用到類 X 的默認構造函數，此時，編譯器會隱式的為類 X 生成一個默認構造函數。該自動生成的默認構造函數沒有參數，包含一個空的函數體，即 X::X（）{ }。雖然自動生成的默認構造函數僅有一個空函數體，但是它仍可用來成功創建類 X 的對象 x，清單 1 也可以編譯通過。
但是，如果程序員為類 X 顯式的自定義了非默認構造函數，卻沒有定義默認構造函數的時候，清單 2 將會出現編譯錯誤：
清單 2
|
1
2
3
4
5
6
7
8
9
10
|
class X{public: X(int i){ a = i; }private: int a;};X x; // 錯誤 , 默認構造函數 X::X() 不存在 |
清單 2 編譯出錯的原因在于類 X 已經有了用戶自定義的構造函數，所以編譯器將不再會為它隱式的生成默認構造函數。如果需要用到默認構造函數來創建類的對象時，程序員必須自己顯式的定義默認構造函數。例如：
清單 3
|
1
2
3
4
5
6
7
8
9
10
11
|
class X{ public: X(){}; // 手動定義默認構造函數 X(int i){ a = i; } private: int a;};X x; // 正確，默認構造函數 X::X() 存在 |
從清單 3 可以看出，原本期望編譯器自動生成的默認構造函數需要程序員手動編寫了，即程序員的工作量加大了。此外，手動編寫的默認構造函數的代碼執行效率比編譯器自動生成的默認構造函數低。類的其它幾類特殊成員函數也和默認構造函數一樣，當存在用戶自定義的特殊成員函數時，編譯器將不會隱式的自動生成默認特殊成員函數，而需要程序員手動編寫，加大了程序員的工作量。類似的，手動編寫的特殊成員函數的代碼執行效率比編譯器自動生成的特殊成員函數低。
為了解決如清單 3 所示的兩個問題：
減輕程序員的編程工作量；
- 獲得編譯器自動生成的默認特殊成員函數的高的代碼執行效率
- C++11 標準引入了一個新特性：default函數。程序員只需在函數聲明后加上=default;，就可將該函數聲明為 default 函數，編譯器將為顯式聲明的 default 函數自動生成函數體。例如：
清單 4
|
1
2
3
4
5
6
7
8
9
10
11
|
class X{public: X()= default; X(int i){ a = i;}private: int a;};X x; |
在清單 4 中，編譯器會自動生成默認構造函數 X::X(){}，該函數可以比用戶自己定義的默認構造函數獲得更高的代碼效率。
Default 函數特性僅適用于類的特殊成員函數，且該特殊成員函數沒有默認參數。例如：
清單 5
|
1
2
3
4
5
6
|
class X {public: int f() = default; // 錯誤 , 函數 f() 非類 X 的特殊成員函數 X(int) = default; // 錯誤 , 構造函數 X(int, int) 非 X 的特殊成員函數 X(int = 1) = default; // 錯誤 , 默認構造函數 X(int=1) 含有默認參數}; |
Default 函數既可以在類體里（inline）定義，也可以在類體外（out-of-line）定義。例如：
清單 6
|
1
2
3
4
5
6
7
8
9
10
11
|
class X{public: X() = default; //Inline default 默認構造函數 X(const X&); X& operator = (const X&); ~X() = default; //Inline default 析構函數};X::X(const X&) = default; //Out-of-line default 拷貝構造函數X& X::operator = (const X&) = default; //Out-of-line default// 拷貝賦值操作符 |
在 C++ 代碼編譯過程中，如果程序員沒有為類 X 定義析構函數，但是在銷毀類 X 對象的時候又需要調用類 X 的析構函數時，編譯器會自動隱式的為該類生成一個析構函數。該自動生成的析構函數沒有參數，包含一個空的函數體，即 X::~X（）{ }。例如：
清單 7
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
class X {private: int x;};class Y: public X {private: int y;};int main(){ X* x = new Y; delete x;} |
在清單 7 中，程序員沒有為基類 X 和派生類 Y 定義析構函數，當在主函數內 delete 基類指針 x 的時候，需要調用基類的析構函數。于是，編譯器會隱式自動的為類 X 生成一個析構函數，從而可以成功的銷毀 x 指向的派生類對象中的基類子對象（即 int 型成員變量 x）。
但是，這段代碼存在內存泄露的問題，當利用 delete 語句刪除指向派生類對象的指針 x 時，系統調用的是基類的析構函數，而非派生類 Y 類的析構函數，因此，編譯器無法析構派生類的 int 型成員變量 y。
因此，一般情況下我們需要將基類的析構函數定義為虛函數，當利用 delete 語句刪除指向派生類對象的基類指針時，系統會調用相應的派生類的析構函數（實現多態性），從而避免內存泄露。但是編譯器隱式自動生成的析構函數都是非虛函數，這就需要由程序員手動的為基類 X 定義虛析構函數，例如：
清單 8
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
|
class X {public: virtual ~X(){}; // 手動定義虛析構函數private: int x;};class Y: public X {private: int y;};int main(){ X* x = new Y; delete x;} |
在清單 8 中，由于程序員手動為基類 X 定義了虛析構函數，當利用 delete 語句刪除指向派生類對象的基類指針 x 時，系統會調用相應的派生類 Y 的析構函數（由編譯器隱式自動生成）以及基類 X 的析構函數，從而將派生類對象完整的銷毀，可以避免內存泄露。
但是，在清單 8 中，程序員需要手動的編寫基類的虛構函數的定義（哪怕函數體是空的），增加了程序員的編程工作量。更值得一提的是，手動定義的析構函數的代碼執行效率要低于編譯器自動生成的析構函數。
為了解決上述問題，我們可以將基類的虛析構函數聲明為 default 函數，這樣就可以顯式的指定編譯器為該函數自動生成函數體。例如：
清單 9
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
|
class X {public: virtual ~X()= default; // 編譯器自動生成 default 函數定義體private: int x;};class Y: public X {private: int y;};int main(){ X* x = new Y; delete x;} |
到此這篇關于C++11中的default函數使用的文章就介紹到這了,更多相關C++11 default函數內容請搜索服務器之家以前的文章或繼續瀏覽下面的相關文章希望大家以后多多支持服務器之家！
原文鏈接：https://blog.csdn.net/u013318019/article/details/113894153
