PS：寫在前面

?

就是構造函數的作用可以這樣理解，如果沒有構造函數就是類里邊只是聲明了成員變量，成員函數，還有最后的對象，這樣你在對該對象進行初始化賦值時就比較麻煩就得先調用成員函數對成員變量賦值，成員變量進而作用到對象上，之后有了構造函數，在構建構造函數時直接可以帶參數對對象進行初始化，相當于省略了步驟，可以這樣簡單的理解。

PS：但是構造函數遠遠不止只有賦值這一條作用（此處不要陷入誤區以為他就是給成員變量賦值的這一個作用，不是這樣的或者說不完全是這樣，給成員變量賦值只是構造函數的作用之一，他還有其他別的作用比如說打開文件再比如說分配內存，再比如說預先做一些計算，比如加減乘除之類的，所以沒有參數的構造函數就不對成員變量進行賦值，他還可以在函數體內執行分配內存或者打開文件操作還可以提前做一些計算，所以無參的構造函數沒有參數也無所謂它可以進行別的操作啊，再說了沒有參數我也可以對成員變量賦值把它賦值為0嘛，這個時候就不需要參數我就是固定的寫死的就是要給他賦值為0，所以沒有參數的構造函數照樣具有很巨大的意義。）

所以看完這個博客不要就記住了構造函數的賦值作用，他還有其他很多的作用。

首先從本質上理解構造函數：

在 C++ 程序中，變量在定義時可以初始化。如果不進行初始化，變量的初始值會是什么呢？對全局變量和局部變量來說，這個答案是不一樣的。

未初始化的全部變量

全局變量在程序裝入內存時就已經分配好了存儲空間，程序運行期間其地址不變。對于程序員沒有初始化的全局變量，程序啟動時自動將其全部初始化為 0（即變量的每個比特都是 0）。
在大多數情況下，這是一種穩妥的做法。而且，將全局變量自動初始化為 0，是程序啟動時的一次性工作，不會花費多少時間，所以大多數 C++ 編譯器生成的程序，未初始化的全局變量的初始值都是全 0。

未初始化的局部變量

對于局部變量，如果不進行初始化，那么它的初始值是隨機的。局部變量定義在函數內部，其存儲空間是動態分配在棧中的。
函數被調用時，棧會分配一部分空間存放該函數中的局部變量（包括參數），這片新分配的存儲空間中原來的內容是什么，局部變量的初始內容也就是什么，因此局部變量的初始值是不可預測的。
函數調用結束后，局部變量占用的存儲空間就被回收，以便分配給下一次函數調用中涉及的局部變量。
為什么不將局部變量自動初始化為全 0 呢？因為一個函數的局部變量在內存中的地址，在每次函數被調用時都可能不同，因此自動初始化的工作就不是一次性的，而是每次函數被調用時都耍做，這會帶來無謂的時間開銷。
當然，如果程序員在定義局部變量時將其初始化了，那么這個初始化的工作也是每次函數被調用時都要做的，但這是編程者要求做的，因而不會是無謂的。

對象的初始化

對象和基本類型的變量一樣，定義時也可以進行初始化。一個對象，其行為和內部結構可能比較復雜，如果不通過初始化為其某些成員變量賦予一個合理的值，使用時就會產生錯誤。例如，有些以指針為成員變量的類可能會要求其對象生成時，指針就已經指向一片動態分配的存儲空間。
對象的初始化往往不只是對成員變量賦值這么簡單，也可能還要進行一些動態內存分配、打開文件等復雜的操作，在這種情況下，就不可能用初始化基本類型變量的方法來對其初始化。
雖然可以為類設汁一個初始化函數，對象定義后就立即調用它，但這樣做的話，初始化就不具有強制性，難保程序員在定義對象后不會忘記對其進行初始化。面向對象的程序設計語言傾向于對象一定要經過初始化后，使用起來才比較安全。因此，引入了構造函數（constructor）的概念，用于對對象進行自動初始化。

在C++中，有一種特殊的成員函數，它的名字和類名相同，沒有返回值，不需要用戶顯式調用（用戶也不能調用），而是在創建對象時自動執行。這種特殊的成員函數就是構造函數（Constructor）。
在C++語言中，“構造函數”就是一類特殊的成員函數，其名字和類的名字一樣，并且不寫返回值類型（void 也不寫）。
構造函數可以被重載，即一個類可以有多個構造函數。
如果類的設計者沒有寫構造函數，那么編譯器會自動生成一個沒有參數的構造函數，雖然該無參構造函數什么都不做。
無參構造函數，不論是編譯器自動生成的，還是程序員寫的，都稱為默認構造函數（default constructor）。如果編寫了構造函數，那么編譯器就不會自動生成默認構造閑數。
對象在生成時，一定會自動調用某個構造函數進行初始化，對象一旦生成，就再也不會在其上執行構造函數。
初學者常因“構造函數”這個名稱而認為構造函數負責為對象分配內存空間，其實并非如此。構造函數執行時，對象的內存空間已經分配好了，構造函數的作用是初始化這片空間。
為類編寫構造函數是好的習慣，能夠保證對象生成時總是有合理的值。例如，一個“雇員”對象的年齡不會是負的。
來看下面的程序片段：

//設計一個表示復數的類
class Complex{
private:double real, imag;  //實部和虛部
public:void Set(double r, double i);  //設置實部和虛部
};

上面這個 Complex 類代表復數，沒有編寫構造函數，因此編譯器會為 Complex 類自動生成一個無參的構造函數。
下面兩條定義或動態生成 Complex 對象的語句，都會導致該無參構造函數被調用，以對 Complex 對象進行初始化。

Complex c;  //類對象c用無參構造函數初始化
Complex *p = new Complex;  //類對象 *p 用無參構造函數初始化

如果為 Complex 類編寫了構造閑數，如下所示：

class Complex
{
private:double real, imag;
public:Complex(double r, double i = 0);  //聲明構造函數//第二個參數的默認值為0
};
Complex::Complex(double r,double i)//定義構造函數
{real = r;imag = i;
}

那么以下語句有的能夠編譯通過，有的則不行：

Complex cl;  //錯，Complex 類沒有聲明無參數的構造函數（默認構造函數）
Complex* pc = new Complex;  //錯，Complex 類沒有默認構造函數（因為已經有了一個構造函數，編譯器就不會自動生成默認構造函數，于是 Complex 類就不存在默認構造函數）
Complex c2(2);  //正確，相當于 Complex c2(2, 0)
Complex c3(2, 4), c4(3, 5);  //正確
Complex* pc2 = new Complex(3, 4);  //正確

C++ 規定，任何對象生成時都一定會調用構造閑數進行初始化。第 1 行通過變量定義的方式生成了 c1 對象，第 2 行通過動態內存分配生成了一個 Complex 對象，這兩條語句均沒有涉及任何關于構造函數參數的信息，因此編譯器會認為這兩個對象應該用默認構造函數初始化。可是 Complex 類已經有了一個構造函數，編譯器就不會自動生成默認構造函數，于是 Complex 類就不存在默認構造函數，所以上述兩條語句就無法完成對象的初始化，導致編譯時報錯。
構造函數是可以重載的，即可以寫多個構造函數，它們的參數表不同。當編譯到能生成對象的語句時，編譯器會根據這條語句所提供的參數信息決定該調用哪個構造函數。如果沒有提供參數信息，編譯器就認為應該調用無參構造函數。
下面是一個有多個構造函數的 Complex 類的例子程序。

class Complex{
private:double real, imag;
public:Complex(double r);Complex(double r, double i);Complex(Complex cl, Complex c2);
};Complex::Complex(double r)  //構造函數 1
{real = r;imag = 0;
}
Complex :: Complex(double r, double i)  //構造數 2
{real = r;imag = i;
}
Complex :: Complex(Complex cl, Complex c2)  //構造函數 3
{real = cl.real + c2.real;imag = cl.imag + c2.imag;
}
int main()
{Complex cl(3), c2(1,2), c3(cl,c2), c4(7);return 0;
}

根據參數個數和類型要匹配的原則，c1、c2、c3、c4 分別用構造函數 1、構造函數 2、構造函數 3 和構造函數 1 進行初始化。初始化的結果是：c1.real = 3，c1.imag = 0 （不妨表示為 c1 = {3, 0}），c2 = {1, 2}，c3 = {4, 2}, c4 = {7, 0}。

從上訴表明可以看出用構造函數完成了對象c1、c2、c3、c4 的初始化。

下面從兩個類的定義方式來說明使用構造函數來對類的對象進行初始化的便利性（對比于類中聲明定義的普通成員函數）。

在沒有構造函數時，我們在類中通過成員函數 setname()、setage()、setscore() 分別為成員變量 name、age、score 賦值，這樣做雖然有效，但顯得有點麻煩。有了構造函數，我們就可以簡化這項工作，在創建對象的同時為成員變量賦值，請看下面的代碼：

第一個代碼（通過先調用對象的成員函數對成員變量進行初始化賦值）：

#include <iostream>
using namespace std;//類的聲明
class Student{
//因為三個成員變量都是私有的，不能通過對象直接訪問，必須借助三個 public 屬性的成員函數來修改它們的值。即不能在外部直接對他們賦值做修改
private:  //私有的char *m_name;int m_age;float m_score;public:  //共有的void setname(char *name);void setage(int age);void setscore(float score);void show();
};//成員函數的定義
void Student::setname(char *name){m_name = name;
}
void Student::setage(int age){m_age = age;
}
void Student::setscore(float score){m_score = score;
}
void Student::show(){cout<<m_name<<"的年齡是"<<m_age<<"，成績是"<<m_score<<endl;
}int main(){//在棧上創建對象Student stu;stu.setname("小明");stu.setage(15);stu.setscore(92.5f);stu.show();//在堆上創建對象Student *pstu = new Student;pstu -> setname("李華");pstu -> setage(16);pstu -> setscore(96);pstu -> show();return 0;
}

運行結果：
小明的年齡是15，成績是92.5
李華的年齡是16，成績是96

第二種改變上述代碼（使用構造函數在創建對象的同時可以直接為成員變量賦值）

#include <iostream>
using namespace std;class Student{
private:char *m_name;int m_age;float m_score;
public://聲明構造函數Student(char *name, int age, float score);//聲明普通成員函數void show();
};//定義構造函數
Student::Student(char *name, int age, float score){m_name = name;m_age = age;m_score = score;
}
//定義普通成員函數
void Student::show(){cout<<m_name<<"的年齡是"<<m_age<<"，成績是"<<m_score<<endl;
}int main(){//創建對象時向構造函數傳參Student stu("小明", 15, 92.5f);stu.show();//創建對象時向構造函數傳參Student *pstu = new Student("李華", 16, 96);pstu -> show();return 0;
}

運行結果：
小明的年齡是15，成績是92.5
李華的年齡是16，成績是96

該例在 Student 類中定義了一個構造函數Student(char *, int, float)，它的作用是給三個 private 屬性的成員變量賦值。要想調用該構造函數，就得在創建對象的同時傳遞實參，并且實參由( )包圍，和普通的函數調用非常類似。

在棧上創建對象時，實參位于對象名后面，例如Student stu("小明", 15, 92.5f)；在堆上創建對象時，實參位于類名后面，例如new Student("李華", 16, 96)。

構造函數必須是 public 屬性的，否則創建對象時無法調用。當然，設置為 private、protected 屬性也不會報錯，但是沒有意義。

構造函數沒有返回值，因為沒有變量來接收返回值，即使有也毫無用處，這意味著：

• 不管是聲明還是定義，函數名前面都不能出現返回值類型，即使是 void 也不允許；
• 函數體中不能有 return 語句。

構造函數的重載

和普通成員函數一樣，構造函數是允許重載的。一個類可以有多個重載的構造函數，創建對象時根據傳遞的實參來判斷調用哪一個構造函數。

構造函數的調用是強制性的，一旦在類中定義了構造函數，那么創建對象時就一定要調用，不調用是錯誤的。如果有多個重載的構造函數，那么創建對象時提供的實參必須和其中的一個構造函數匹配；反過來說，創建對象時只有一個構造函數會被調用。

對示例1中的代碼，如果寫作Student stu或者new Student就是錯誤的，因為類中包含了構造函數，而創建對象時卻沒有調用。

更改示例1的代碼，再添加一個構造函數（示例2）：

#include <iostream>
using namespace std;class Student{
private:char *m_name;int m_age;float m_score;
public:Student();Student(char *name, int age, float score);void setname(char *name);void setage(int age);void setscore(float score);void show();
};Student::Student(){m_name = NULL;m_age = 0;m_score = 0.0;
}
Student::Student(char *name, int age, float score){m_name = name;m_age = age;m_score = score;
}
void Student::setname(char *name){m_name = name;
}
void Student::setage(int age){m_age = age;
}
void Student::setscore(float score){m_score = score;
}
void Student::show(){if(m_name == NULL || m_age <= 0){cout<<"成員變量還未初始化"<<endl;}else{cout<<m_name<<"的年齡是"<<m_age<<"，成績是"<<m_score<<endl;}
}int main(){//調用構造函數 Student(char *, int, float)Student stu("小明", 15, 92.5f);stu.show();//調用構造函數 Student()Student *pstu = new Student();pstu -> show();pstu -> setname("李華");pstu -> setage(16);pstu -> setscore(96);pstu -> show();return 0;
}

運行結果：
小明的年齡是15，成績是92.5
成員變量還未初始化
李華的年齡是16，成績是96

構造函數Student(char *, int, float)為各個成員變量賦值，構造函數Student()將各個成員變量的值設置為空，它們是重載關系。根據Student()創建對象時不會賦予成員變量有效值，所以還要調用成員函數 setname()、setage()、setscore() 來給它們重新賦值。

構造函數在實際開發中會大量使用，它往往用來做一些初始化工作，例如對成員變量賦值、預先打開文件等。

默認構造函數

如果用戶自己沒有定義構造函數，那么編譯器會自動生成一個默認的構造函數，只是這個構造函數的函數體是空的，也沒有形參，也不執行任何操作。比如上面的 Student 類，默認生成的構造函數如下：

Student(){}

一個類必須有構造函數，要么用戶自己定義，要么編譯器自動生成。一旦用戶自己定義了構造函數，不管有幾個，也不管形參如何，編譯器都不再自動生成。在示例1中，Student 類已經有了一個構造函數Student(char *, int, float)，也就是我們自己定義的，編譯器不會再額外添加構造函數Student()，在示例2中我們才手動添加了該構造函數。

實際上編譯器只有在必要的時候才會生成默認構造函數，而且它的函數體一般不為空。默認構造函數的目的是幫助編譯器做初始化工作，而不是幫助程序員。這是C++的內部實現機制，這里不再深究，初學者可以按照上面說的“一定有一個空函數體的默認構造函數”來理解。

最后需要注意的一點是，調用沒有參數的構造函數也可以省略括號。對于示例2的代碼，在棧上創建對象可以寫作Student stu()或Student stu，在堆上創建對象可以寫作Student *pstu = new Student()或Student *pstu = new Student，它們都會調用構造函數 Student()。

以前我們就是這樣做的，創建對象時都沒有寫括號，其實是調用了默認的構造函數。

總結

以上是生活随笔為你收集整理的C++：构造函数作用及用法的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。