從C學C++(6)——構造函數和析構函數

若無特殊說明，本博客所執行的C++標準均為C++11.

構造函數與析構函數

構造函數定義

構造函數是特殊的成員函數，當創建類類型的新對象，系統自動會調用構造函數構造函數是為了保證對象的每個數據成員都被正確初始化。

構造函數的特點

函數名和類名完全相同
不能定義構造函數的類型（返回類型）(因為構造函數需要返回對象本身，所以不能指定返回類型)，也不能使用void。
通常情況下構造函數應聲明為公有函數，否則它不能像其他成員函數那樣被顯式地調用。

(特殊情況，例如“單例模式”設計的時候，會將構造函數聲明為私有函數，以禁止外界定義一個對象)
構造函數可以有任意類型和任意個數的參數，一個類可以有多個構造函數（構造函數可以重載）

析構函數定義和特點

函數名和比類名前面多了一個字符“~”
沒有返回類型(和構造函數一樣)
沒有參數，因此析構函數不能被重載

如果沒有定義構造函數和析構函數，默認會生成兩個空函數作為構造函數和析構函數。

class Test{
public:Test(){//默認構造函數就是這樣，空的，且沒有參數   }~Test(){//默認析構函數就是這樣，空的，且沒有參數 }
}

構造/析構函數和變量的生存期

當我們定義一個對象的時候，構造函數會被默認調用；當對象的生命周期結束的時候(一般是函數運行結束的時候，對全局對象來說是程序運行結束的時候)，會默認調用析構函數進行對象的釋放。

當我們new一個對象的時候，構造函數會被默認調用；當delete對象的時候，會默認調用析構函數進行對象的釋放（而且通常需要程序員手動調用delete才能釋放該對象）。

這里需要注意的是，全局對象的構造是先于main函數執行的(這個我其實存有疑惑，特別是在單片機這樣的嵌入式設備的C++編程中，因為單片機的main函數入口前是匯編指令，負責聲明對堆棧大小和中斷向量表等操作，之后通過指令跳轉的main函數入口的，C++的全局變量的構造函數是如何插入到指令跳轉到main函數之前的呢？🤔)。

最后，析構函數是可以像普通成員函數一樣顯示調用的。

轉換構造函數和explicit

轉換構造函數

擁有單個參數的構造函數被編譯器用于隱式類型轉換的時候，稱為轉換構造函數。

因此，類的構造函數只有一個參數是非常危險的，因為編譯器可以使用這種構造函數把參數的類型隱式轉換為類類型。(可能在我們沒有注意到的地方調用了構造函數)。如下：

class Test{Test(int a){//可以什么也不做}
}int main(void){Test t(0); //此時，帶一個參數的構造函數，充當的是普通構造函數的功能t = 20; // 此時，編譯器會默認幫我們找到一個能夠用的構造函數(即一個參數的構造函數)進行隱性類型轉換；遵循以下步驟：// 1. 調用轉換構造函數將20這個整數轉換成類類型（生成一個臨時對象）// 2. 臨時對象賦值給t對象（調用的是=運算符成員函數）
}

初始化中的=不是賦值運算符

在初始化語句中的等號不是運算符。編譯器對這種表示方法有特殊的解釋，編譯器會將其等價于調用單個參數的構造函數構造對象，而不是賦值運算(調用=重載函數)。

因為對編譯器來說，Test t = 10; 這樣的語句，是對象變量的初始化，直接調用單個參數的構造函數進行初始化就可以了(等價于 Test t(10););

而不需要像 Test t; t = 10; 中一樣經過先調用構造函數構造對象，后面那個賦值語句(注意這個不是初始化語句)，會分兩步，先調用一個參數的構造函數做轉換構造函數構造一個臨時對象，再調用賦值構造函數(也就是=運算符的重載函數)將臨時對象賦值給我們賦值的對象。

這里順便說明等號運算符一般的重載形式，如下：

Test& Test::operator=(const Test& other){//需要的操作return *this; //返回對象本身
}
需要注意：

返回對象的引用，一般我們會直接返回 *this , 因為這個重載函數是在類似a=b 是調用的，其等價于 a = a.operator=(b) 這樣的調用，因此，能夠很明顯函數，=運算符重載函數是需要返回對象自身的(建議返回引用 return *this)
接收參數必須是對象的引用，這里注意到，如果接收參數不是對象的引用的話，而是一個對象的話(參數值傳遞)，因為a=b 等價于 a = a.operator=(b) ; 而值傳遞的參數決定了，這里需要有一個實參給形參傳值的操作，而實參給形參傳值的操作也就是 形參=實參 這樣的操作，那又會調用operator=(b) 函數，就會形成遞歸調用，死循環了。

explicit關鍵字

如果想要避免編譯器對類做默認類型轉換的話，我們可以給一個形參的構造函數前加上 explicit 這樣如果我們使用類似 Test t; t = 10; 這樣的操作時，編譯器會報錯，而不會使用一個參數的(轉換)構造函數和等號運算符函數做隱式的類型轉換。在這種情況下，對于Test 這個類對象，我們必須使用顯式的類型轉換。

構造函數和成員初始化

構造函數初始化列表

構造函數后可以使用: 跟一個構造函數初始化列表(成員變量(形參))，用于成員變量的初始化，注意，在構造函數體內執行的成員變量的操作是賦值操作，不是初始化操作。

Clock::Clock(int hour, int minute, int second) : m_hour(hour), m_minute(minute), m_second(second) {//初始化列表是初始化階段// 函數體內是普通計算階段// m_hour = hour;// m_minute = minute;  // m_second = second; //這部分是賦值操作而不是 初始化操作std::cout << "clock initialized: " << m_hour << ":" << m_minute << ":" << m_second << std::endl;
}

分清成員變量的初始化和賦值操作后，由之前的const變量和引用變量 必須在初始化時賦初值(后期，const變量不可被賦值更改，而引用變量 更改則是對對象本身進行更改)可知。如果類內成員有const成員 和引用成員的話，只能在構造函數的初始化列表中完成初始化。

對象成員的初始化

如果一個類中含有其他類的對象作為成員變量(這里成為對象成員)，如果我們沒有在這個類的初始化列表中提供這個對象成員的初始化的話，那么當這個類的對象定義時，會默認調用這個對象成員沒有任何參數的構造函數(即這個對象成員的默認構造函數)；如果這個對象成員沒有提供這個函數的話，就和我們平時定義一個類對象(這個類的構造函數只有一個有參數的構造函數)而我們定義時沒有傳入任何參數一樣，會報錯找不到合適的構造函數。

對象成員的初始化

所以，如果一個類擁有對象成員（且這個對象成員沒有不帶任何參數的構造函數），在外類對象的初始化的時候必須在初始化列表中給出這個對象成員的初始化，不讓會報錯找不到對應的構造函數。

拷貝構造函數

功能：使用一個已經存在的對象來初始化一個新的同一類型的對象
聲明：只有一個參數并且參數為該類對象的引用，形如Clock::Clock(const Clock& other)
如果類中沒有說明拷貝構造函數，則系統自動生成一個缺省拷貝構造函數(做逐成員賦值)，作為該類的公有成員。

拷貝構造函數調用幾種情況

凡是需要用到對象的賦值操作的，都會有拷貝構造函數調用(如函數參數的實參到形參的值傳遞，函數返回值的賦值等待)

當函數的形參是類的對象，調用函數時，進行形參與實參結合時使用。這時要在內存新建立一個局部對象，并把實參拷貝到新的對象中。理所當然也調用拷貝構造函數。
當函數的返回值是類對象，函數執行完成返回調用者時使用。理由也是要建立一個臨時對象中，再返回調用者。為什么不直接用要返回的局部對象呢？因為局部對象在離開建立它的函數時就消亡了，不可能在返回調用函數后繼續生存，所以在處理這種情況時，編譯系統會在調用函數的表達式中創建一個無名臨時對象，該臨時對象的生存周期只在函數調用處的表達式中。所謂return對象，實際上是調用拷貝構造函數把該對象的值拷入臨時對象。如果返回的是變量，處理過程類似，只是不調用構造函數。

拷貝構造函數的幾種情況

深/淺拷貝和禁止拷貝

深/淺拷貝

**對于像成員變量中有在堆上分配的類，一般都需要自己實現拷貝構造函數，因為默認的拷貝構造函數是淺拷貝，僅僅將對成員變量的值拷貝而已。**但成員變量中有在堆上分配的類，每個對象都需要重新分配一個空間，不然，當對象自動銷毀時，由于不同對象內的指針指向同一個空間，當前面一個對象銷毀后，后一個對象內的指針便成了野指針，無法delete。

#pragma once
#include  <iostream>
#include <cstring>
class Str
{
private:char* m_str;size_t m_length;
public:Str(const char* str = ""): m_length(strlen(str)), m_str(new char[m_length + 1]){strcpy(m_str, str);std::cout << "Str(const char* str) called: " << m_str << std::endl;}Str(const Str& other): m_length(other.m_length), m_str(new char[other.m_length + 1]){strcpy(m_str, other.m_str);std::cout << "Str(const Str& other) called: " << m_str << std::endl;}~Str(){std::cout << "Str Decon called:" << m_str << std::endl;delete[] m_str;}};
class Empty { //在空類中測試禁止拷貝
public:Empty() {std::cout << "Empty constructor called." << std::endl;}~Empty() {std::cout << "Empty destructor called." << std::endl;}// int a; // 如果有成員變量，Empty類的大小會大于1字節,計算方式與結構體一樣
private: //需要將拷貝構造函數和賦值運算符聲明為私有，以禁止拷貝Empty(const Empty&); // 禁止拷貝構造函數Empty& operator=(const Empty&); // 禁止賦值運算符
};

禁止拷貝

通過將拷貝構造函數與=運算符聲明為私有，并且不提供它們的實現 ，可以使得，Str s2(S1); ,Str s2 = s1; , Str s2; s2 = s1 這樣的語句直接在編譯時報錯，幫助我們實現只有單個對象禁止拷貝的功能。需要注意上面三個語句編譯器所尋找的函數有一些不同。

Str s2(S1); 找只有一個參數，且參數是Str 對象的構造函數，其實就是拷貝構造函數(這是我們人為對這個重載函數給的名字罷了)。
Str s2 = s1; 找只有一個參數，且參數是Str 對象的構造函數，其實就是拷貝構造函數(這是我們人為對這個重載函數給的名字罷了)，注意這里是初始化，所以是找拷貝構造函數，不是找=的重載函數。
Str s2; s2 = s1 先找不帶任何參數的構造函數，第二個語句找=運算符的重載函數 operator=(const Str& other)