構造函數是一種可初始化其類的實例的成員函數。構造函數具有與類相同的名稱，沒有返回值。構造函數可以具有任意數量的參數，類可以具有任意數量的重載構造函數。構造函數可以具有任何可訪問性（公共、受保護或私有）。如果未定義任何構造函數，則編譯器會生成不采用任何參數的默認構造函數；可以通過將默認構造函數聲明為已刪除來重寫此行為。
構造函數順序
構造函數按此順序執行工作：
按聲明順序調用基類和成員構造函數。
如果類派生自虛擬基類，則會將對象的虛擬基指針初始化。
如果類具有或繼承了虛函數，則會將對象的虛函數指針初始化。虛函數指針指向類中的虛函數表，確保虛函數正確地調用綁定代碼。
它執行自己函數體中的所有代碼。
下面的示例顯示，在派生類的構造函數中，基類和成員構造函數的調用順序。首先，調用基構造函數，然后按照基類成員在類聲明中出現的順序對這些成員進行初始化，然后，調用派生構造函數。
#include <iostream>using namespace std;class Contained1 {public: Contained1() { cout << "Contained1 constructor." << endl; }};class Contained2 {public: Contained2() { cout << "Contained2 constructor." << endl; }};class Contained3 {public: Contained3() { cout << "Contained3 constructor." << endl; }};class BaseContainer {public: BaseContainer() { cout << "BaseContainer constructor." << endl; }private: Contained1 c1; Contained2 c2;};class DerivedContainer : public BaseContainer {public: DerivedContainer() : BaseContainer() { cout << "DerivedContainer constructor." << endl; }private: Contained3 c3;};int main() { DerivedContainer dc; int x = 3;}這是輸出：
Contained1 constructor.Contained2 constructor.BaseContainer constructor.Contained3 constructor.DerivedContainer constructor.
如果構造函數引發異常，析構的順序與構造的順序相反：
構造函數主體中的代碼將展開。
基類和成員對象將被銷毀，順序與聲明順序相反。
如果是非委托構造函數，所有完全構造的基類對象和成員均將被銷毀。但是，對象本身不是完全構造的，因此析構函數不會運行。
成員列表
使用成員初始值設定項列表從構造函數參數初始化類成員。此方法使用直接初始化，這比在構造函數體內使用賦值運算符更高效。
class Box {public: Box(int width, int length, int height) : m_width(width), m_length(length), m_height(height) // member init list {} int Volume() {return m_width * m_length * m_height; }private: int m_width; int m_length; int m_height;};創建 Box 對象：
Box b(42, 21, 12);cout << "The volume is " << b.Volume();
顯式構造函數
如果類具有帶一個參數的構造函數，或是如果除了一個參數之外的所有參數都具有默認值，則參數類型可以隱式轉換為類類型。例如，如果 Box 類具有一個類似于下面這樣的構造函數：
Box(int size): m_width(size), m_length(size), m_height(size){}可以初始化 Box，如下所示：
Box b = 42;
或將一個 int 傳遞給采用 Box 的函數：
class ShippingOrder{public: ShippingOrder(Box b, double postage) : m_box(b), m_postage(postage){}private: Box m_box; double m_postage;}//elsewhere... ShippingOrder so(42, 10.8);
這類轉換可能在某些情況下很有用，但更常見的是，它們可能會導致代碼中發生細微但嚴重的錯誤。作為一般規則，應對構造函數使用 explicit 關鍵字（和用戶定義的運算符）以防止出現這種隱式類型轉換：
explicit Box(int size): m_width(size), m_length(size), m_height(size){}構造函數是顯式函數時，此行會導致編譯器錯誤：ShippingOrder so(42, 10.8);。
默認構造函數
默認構造函數沒有參數；它們遵循略有不同的規則：
默認構造函數是一個特殊成員函數；如果沒有在類中聲明構造函數，則編譯器會提供默認構造函數：
class Box { Box(int width, int length, int height) : m_width(width), m_length(length), m_height(height){}};int main(){ Box box1{}; // call compiler-generated default ctor Box box2; // call compiler-generated default ctor}當你調用默認構造函數并嘗試使用括號時，系統將發出警告：
class myclass{};int main(){myclass mc(); // warning C4930: prototyped function not called (was a variable definition intended?)}這是“最棘手的解析”問題的示例。這種示例表達式既可以解釋為函數的聲明，也可以解釋為對默認構造函數的調用，而且 C++ 分析器更偏向于聲明，因此表達式會被視為函數聲明。
如果聲明了任何非默認構造函數，編譯器不會提供默認構造函數：
class Box { Box(int width, int length, int height) : m_width(width), m_length(length), m_height(height){}};private: int m_width; int m_length; int m_height;};int main(){ Box box1(1, 2, 3); Box box2{ 2, 3, 4 }; Box box4; // compiler error C2512: no appropriate default constructor available}如果類沒有默認構造函數，將無法通過單獨使用方括號語法來構造該類的對象數組。例如，在前面提到的代碼塊中，框的數組無法進行如下聲明：
Box boxes[3]; // compiler error C2512: no appropriate default constructor available
但是，你可以使用初始值設定項列表將框的數組初始化：
Box boxes[3]{ { 1, 2, 3 }, { 4, 5, 6 }, { 7, 8, 9 } };復制和移動構造函數
復制構造函數是特殊成員函數，它采用對相同類型對象的引用作為輸入，并創建它的副本。移動也是特殊成員函數構造函數，它將現有對象的所有權移交給新變量，而不復制原始數據。
顯式默認構造函數和已刪除構造函數
你可以顯式設置默認復制構造函數、設置默認構造函數、移動構造函數、復制賦值運算符、移動賦值運算符和析構函數。你可以顯式刪除所有特殊成員函數。
派生類中的構造函數
派生類構造函數始終調用基類構造函數，因此，在完成任何額外任務之前，它可以依賴于完全構造的基類。調用基類構造函數進行派生，例如，如果 ClassA 派生自 ClassB，ClassB 派生自 ClassC，那么首先調用 ClassC 構造函數，然后調用 ClassB 構造函數，最后調用 ClassA 構造函數。
如果基類沒有默認構造函數，則必須在派生類構造函數中提供基類構造函數參數：
class Box {public: Box(int width, int length, int height){ m_width = width; m_length = length; m_height = height; }private: int m_width; int m_length; int m_height;};class StorageBox : public Box {public: StorageBox(int width, int length, int height, const string label&) : Box(width, length, height){ m_label = label; }private: string m_label;};int main(){ const string aLabel = "aLabel"; StorageBox sb(1, 2, 3, aLabel);} 具有多重繼承的類的構造函數
如果類從多個基類派生，那么將按照派生類聲明中列出的順序調用基類構造函數：
#include <iostream>using namespace std;class BaseClass1 {public: BaseClass1() { cout << "BaseClass1 constructor." << endl; }};class BaseClass2 {public: BaseClass2() { cout << "BaseClass2 constructor." << endl; }};class BaseClass3{public: BaseClass3() { cout << "BaseClass3 constructor." << endl; }};class DerivedClass : public BaseClass1, public BaseClass2, public BaseClass3 {public: DerivedClass() { cout << "DerivedClass constructor." << endl; }};int main() { DerivedClass dc;}你應看到以下輸出：
BaseClass1 constructor.BaseClass2 constructor.BaseClass3 constructor.DerivedClass constructor.
構造函數中的虛函數
我們建議你謹慎調用構造函數中的虛函數。基類構造函數始終在派生類構造函數之前調用，因此基構造函數中調用的函數是基類版本，而非派生類版本。在下面的示例中，構造 DerivedClass 會導致執行 BaseClass 的 print_it() 實現早于 DerivedClass 構造函數導致執行 DerivedClass 的 print_it() 實現：
#include <iostream>using namespace std;class BaseClass{public: BaseClass(){ print_it(); } virtual void print_it() { cout << "BaseClass print_it" << endl; }};class DerivedClass : public BaseClass {public: DerivedClass() { print_it(); } virtual void print_it(){ cout << "Derived Class print_it" << endl; }};int main() { DerivedClass dc;}這是輸出：
BaseClass print_itDerived Class print_it
構造函數和復合類
包含類類型成員的類稱為“復合類”。創建復合類的類類型成員時，調用類自己的構造函數之前，先調用構造函數。當包含的類沒有默認構造函數是，必須使用復合類構造函數中的初始化列表。在之前的 StorageBox 示例中，如果將 m_label 成員變量的類型更改為新的 Label 類，則必須調用基類構造函數，并且將 m_label 變量（位于 StorageBox 構造函數中）初始化：
class Label {public: Label(const string& name, const string& address) { m_name = name; m_address = address; } string m_name; string m_address;};class StorageBox : public Box {public: StorageBox(int width, int length, int height, Label label) : Box(width, length, height), m_label(label){}private: Label m_label;};int main(){// passing a named Label Label label1{ "some_name", "some_address" }; StorageBox sb1(1, 2, 3, label1); // passing a temporary label StorageBox sb2(3, 4, 5, Label{ "another name", "another address" }); // passing a temporary label as an initializer list StorageBox sb3(1, 2, 3, {"myname", "myaddress"});}委托構造函數
委托構造函數調用同一類中的其他構造函數，完成部分初始化工作。在下面的示例中，派生類具有三個構造函數，第二個構造函數委托第一個，第三個構造函數委托第二個：
#include <iostream>using namespace std;class ConstructorDestructor {public: ConstructorDestructor() { cout << "ConstructorDestructor default constructor." << endl; } ConstructorDestructor(int int1) { cout << "ConstructorDestructor constructor with 1 int." << endl; } ConstructorDestructor(int int1, int int2) : ConstructorDestructor(int1) { cout << "ConstructorDestructor constructor with 2 ints." << endl; throw exception(); } ConstructorDestructor(int int1, int int2, int int3) : ConstructorDestructor(int1, int2) { cout << "ConstructorDestructor constructor with 3 ints." << endl; } ~ConstructorDestructor() { cout << "ConstructorDestructor destructor." << endl; }};int main() { ConstructorDestructor dc(1, 2, 3);}這是輸出：
ConstructorDestructor constructor with 1 int.ConstructorDestructor constructor with 2 ints.ConstructorDestructor constructor with 3 ints.
所有構造函數完成后，完全初始化的構造函數將立即創建對象。 DerivedContainer(int int1) 成功，但是 DerivedContainer(int int1, int int2) 失敗，并調用析構函數。
class ConstructorDestructor {public: ConstructorDestructor() { cout << "ConstructorDestructor default constructor." << endl; } ConstructorDestructor(int int1) { cout << "ConstructorDestructor constructor with 1 int." << endl; } ConstructorDestructor(int int1, int int2) : ConstructorDestructor(int1) { cout << "ConstructorDestructor constructor with 2 ints." << endl; throw exception(); } ConstructorDestructor(int int1, int int2, int int3) : ConstructorDestructor(int1, int2) { cout << "ConstructorDestructor constructor with 3 ints." << endl; } ~ConstructorDestructor() { cout << "ConstructorDestructor destructor." << endl; }};int main() { try { ConstructorDestructor cd{ 1, 2, 3 }; } catch (const exception& ex){ }}輸出：
ConstructorDestructor constructor with 1 int.ConstructorDestructor constructor with 2 ints.ConstructorDestructor destructor.
繼承構造函數 (C++11)
派生類可以使用 using 聲明從直接基類繼承構造函數，如下面的示例所示：
#include <iostream>using namespace std;class Base{public: Base() { cout << "Base()" << endl; } Base(const Base& other) { cout << "Base(Base&)" << endl; } explicit Base(int i) : num(i) { cout << "Base(int)" << endl; } explicit Base(char c) : letter(c) { cout << "Base(char)" << endl; }private: int num; char letter;};class Derived : Base{public: // Inherit all constructors from Base using Base::Base;private: // Can't initialize newMember from Base constructors. int newMember{ 0 };};int main(int argc, char argv[]){ cout << "Derived d1(5) calls: "; Derived d1(5); cout << "Derived d1('c') calls: "; Derived d2('c'); cout << "Derived d3 = d2 calls: " ; Derived d3 = d2; cout << "Derived d4 calls: "; Derived d4; // Keep console open in debug mode: cout << endl << "Press Enter to exit."; char in[1]; cin.getline(in, 1); return 0;}Derived d1(5) calls: Base(int)Derived d1('c') calls: Base(char)Derived d3 = d2 calls: Base(Base&)Derived d4 calls: Base()Press Enter to exit.using 語句可將來自基類的所有構造函數引入范圍（除了簽名與派生類中的構造函數相同的構造函數）。一般而言，當派生類未聲明新數據成員或構造函數時，最好使用繼承構造函數。
如果類型指定基類，則類模板可以從類型參數繼承所有構造函數：
template< typename T >class Derived : T { using T::T; // declare the constructors from T // ...};如果基類的構造函數具有相同簽名，則派生類無法從多個基類繼承。
聲明構造函數的規則
構造函數與它的類的名稱相同?？梢月暶魅我鈹盗康臉嬙旌瘮?，這取決于重載函數的規則。
argument-declaration-list 可能為空。
C++ 定義兩種特殊的構造函數（默認構造函數和復制構造函數），如下表所述。
默認構造函數和復制構造函數
默認構造函數可在沒有參數的情況下調用。但是，如果所有參數都有默認值，則可以用參數列表聲明默認構造函數。同樣，復制構造函數必須接受對相同類類型的引用的單一參數?？梢蕴峁┒鄠€參數，前提是所有后續參數都有默認值。
如果未提供任何構造函數，則編譯器將嘗試生成默認構造函數。如果未提供復制構造函數，則編譯器將嘗試生成一個。這些編譯器生成的構造函數被視為公共成員函數。如果使用屬于對象但不屬于引用的第一個參數指定復制構造函數，則將生成錯誤。
編譯器生成的默認構造函數將設置對象（如上文所述，初始化 vftables 和 vbtables），并調用基類和成員的默認構造函數，但是它不執行任何其他操作。僅當基類和成員構造函數存在、可訪問并且無歧義時才會調用它們。
編譯器生成的復制構造函數將設置新的對象，并對要復制的對象的內容按成員復制。如果基類或成員構造函數存在，則將調用它們；否則將執行按位復制。
如果類 type 的所有基類和成員類均具有接受 const 參數的復制構造函數，則編譯器生成的復制構造函數將接受 const type& 類型的單個參數。否則，編譯器生成的復制構造函數將接受 type& 類型的單個參數。
您可以使用構造函數初始化 const 或 volatile 對象，但是，構造函數本身不能聲明為 const 或 volatile。構造函數的唯一合法存儲類是 inline；將任何其他存儲類修飾符（包括 __declspec 關鍵字）與構造函數一起使用將導致編譯器錯誤。
stdcall 調用約定用于使用 __stdcall 關鍵字聲明的靜態成員函數和全局函數，且不使用變量參數列表。對非靜態成員函數（如構造函數）使用 __stdcall 關鍵字時，編譯器將使用 thiscall 調用約定。
基類的構造函數不由派生類繼承。創建派生類類型的對象時，該對象將從基類組件開始進行構造；然后移到派生類組件。由于整個對象有一部分已初始化，因此編譯器使用每個基類的構造函數（虛擬派生的情況除外，如初始化基類中所述）。
顯式調用構造函數
可以在程序中顯式調用構造函數來創建給定類型的對象。例如，若要創建描述某行末尾的兩個 Point 對象，請編寫以下代碼：
DrawLine( Point( 13, 22 ), Point( 87, 91 ) );
創建類型 Point 的兩個對象，將其傳遞給函數 DrawLine，并在表達式（函數調用）的末尾將其銷毀。
在其中顯式調用構造函數的另一個上下文正在進行初始化：
Point pt = Point( 7, 11 );
使用接受類型為 Point 的兩個參數的構造函數來創建和初始化類型為 int 的對象。
通過顯式調用構造函數創建的對象（如上面的兩個示例）未進行命名，并且該對象具有在其中創建它們的表達式的生存期。 臨時對象中更詳細地討論了這一點。
通常，從構造函數的內部調用所有成員函數是安全的，因為該對象在用戶代碼的第一行執行之前已完全設置（已初始化虛擬表等）。但是，在構造或析構期間，成員函數調用抽象基類的虛擬成員函數可能是不安全的。
構造函數可以調用虛函數。調用虛函數時，調用的函數將是為構造函數自己的類定義的函數（或從其基類繼承）。以下示例演示從構造函數的內部調用虛函數時發生的情況：
// specl_calling_virtual_functions.cpp// compile with: /EHsc#include <iostream>using namespace std;class Base{public: Base(); // Default constructor. virtual void f(); // Virtual member function.};Base::Base(){ cout << "Constructing Base sub-object/n"; f(); // Call virtual member function} // from inside constructor.void Base::f(){ cout << "Called Base::f()/n";}class Derived : public Base{public: Derived(); // Default constructor. void f(); // Implementation of virtual}; // function f for this class.Derived::Derived(){ cout << "Constructing Derived object/n";}void Derived::f(){ cout << "Called Derived::f()/n";}int main(){ Derived d;}在運行前面的程序時，聲明 Derived d 將產生以下事件序列：
調用類 Derived (Derived::Derived) 的構造函數。
在輸入 Derived 類的構造函數的主體之前，調用類 Base (Base::Base) 的構造函數。
Base::Base 調用函數 f，該函數是一個虛函數。通常，將調用 Derived::f，因為對象 d 屬于類型 Derived。由于 Base::Base 函數是構造函數，因此該對象不屬于 Derived 類型，并且將調用 Base::f。
新聞熱點
疑難解答
圖片精選
