首先，構造函數的幾個基本要點
- 構造函數可以被重載
- 實參決定使用哪個構造函數
- 構造函數自動執行
- 構造函數不能聲明爲const
因爲const構造函數是不必要的。創建類類型的const對象時，運行一個普通構造函數來初始化該const對象。
構造函數初始化的方法
一般來說，構造函數初始化的方法有兩種
構造函數初始化列表
class ShenDiao{
public:
ShenDiao():Nanzhuj("Yangguo"),Nvzhuj("Xiaolongnv"){}
private:
string Nanzhuj;
string Nvzhuj;
}類成員“男主角”和“女主角”在構造函數初始化列表中被初始化爲“楊過”和“小龍女”，稱爲顯示初始化，且類類型的數據成員總是在初始化階段初始化(Why?往下看)
構造函數內部賦值
class ShenDiao {
public:
ShenDiao()
{
Nanzhuj = "Yangguo";
Nvzhuj = "Xiaolongnv";
}
private:
string Nanzhuj;
string Nvzhuj;
}該構造函數隱式使用默認的string構造函數來初始化 Nanzhuj 和 Nvzhuj，即執行構造函數的函數體時，它們已經有值了，該值被構造函數函數體的賦值所覆蓋。
從概念上來講，可以認爲構造函數分兩個階段執行：
- 初始化階段；
- 普通的計算階段：計算階段由構造函數函數體中的所有語句組成。
以下情況必須使用構造函數初始化列表
- 類成員爲const類型的成員
- 類成員爲引用類型的成員
沒有默認構造函數的類類型的成員
class Media{ public Media(int tai,string taiName){} }ShenDiao::ShenDiao(string Name):name(Name),Author(name),Director(Name)，media(Mango){} private: string name; const string Author；//定義時初始化 string &Director；//引用只能用對象初始化 Media media; //若不在初始化列表初始化media，則編譯錯誤，類類型Media無默認構造函數，則只能在初始化列表賦值。
構造函數的種類
一般類型：
class Complex
{
private :
double m_real;
double m_imag;
public:
// 無參數構造函數
// 如果創建一個類你沒有寫任何構造函數,則系統會自動生成默認的無參構造函數，函數爲空，什麼都不做
// 只要你寫了一個下面的某一種構造函數，系統就不會再自動生成這樣一個默認的構造函數，如果希望有一個這樣的無參構造函數，則需要自己顯示地寫出來
Complex(void)
{
m_real = 0.0;
m_imag = 0.0;
}
// 一般構造函數（也稱重載構造函數）
// 一般構造函數可以有各種參數形式,一個類可以有多個一般構造函數，前提是參數的個數或者類型不同（基於c++的重載函數原理）
// 例如：你還可以寫一個 Complex( int num)的構造函數出來
// 創建對象時根據傳入的參數不同調用不同的構造函數
Complex(double real, double imag)
{
m_real = real;
m_imag = imag;
}拷貝構造函數
#include<iostream>
using namespace std;
class CExample
{
private:
int a;
public:
CExample(int b)
{
a=b;
}
/*CExample(const CExample &C)
{
a = C.a;
}*/
void show()
{
cout<<a<<endl;
}
};
int main()
{
CExample A(100);
CExample B(A);//用B=A一樣，注意這裏的對象初始化要調用拷貝構造函數，而非賦值
B.show();
return 0;
}註釋或不註釋掉CExample(const CExample& C)，運行程序，屏幕輸出100。CExample(const CExample& C) 就是我們自定義的拷貝構造函數。系統爲對象 B 分配了內存並完成了與對象 A 的複製過程。可見，拷貝構造函數是一種特殊的構造函數，函數的名稱必須和類名稱一致，它必須的一個參數是本類型的一個引用變量。
拷貝構造函數的調用時機
- 對象以傳值的方式傳入函數參數
class CExample
{
private:
int a;
public:
//構造函數
CExample(int b)
{
a = b;
cout<<"creat: "<<a<<endl;
}
//拷貝構造
CExample(const CExample& C)
{
a = C.a;
cout<<"copy"<<endl;
}
//析構函數
~CExample()
{
cout<< "delete: "<<a<<endl;
}
void Show ()
{
cout<<a<<endl;
}
};
//全局函數，傳入的是對象
void g_Fun(CExample C)
{
cout<<"test"<<endl;
}
int main()
{
CExample test(1);
//傳入對象
g_Fun(test);
return 0;
}輸出結果
調用g_Fun()時，會產生以下幾個重要步驟：
(1).test對象傳入形參時，會先會產生一個臨時變量，就叫 C 吧。
(2).然後調用拷貝構造函數把test的值給C。 整個這兩個步驟有點像：CExample C(test);
(3).等g_Fun()執行完後, 析構掉 C 對象。
2.對象以傳值的方式從函數返回
class CExample
{
private:
int a;
public:
//構造函數
CExample(int b)
{
a = b;
cout<<"creat"<<endl;
}
//拷貝構造
CExample(const CExample& C)
{
a = C.a;
cout<<"copy"<<endl;
}
//析構
~CExample()
{
cout<< "delete: "<<a<<endl;
}
};
//全局函數
CExample g_Fun()
{
CExample temp(0);
return temp;
}
int main()
{
g_Fun();
return 0;
}運行結果
當g_Fun()函數執行到return時，會產生以下幾個重要步驟：
(1). 先會產生一個臨時變量，就叫XXXX吧。
(2). 然後調用拷貝構造函數把temp的值給XXXX。整個這兩個步驟有點像：CExample XXXX(temp);
(3). 在函數執行到最後先析構temp局部變量。
(4). 等g_Fun()執行完後再析構掉XXXX對象。
3.對象需要通過另外一個對象進行初始化
如之前的
CExample B = A;
CExample B(A);淺拷貝和深拷貝
以下轉自：c++拷貝構造函數詳解
- 默認拷貝構造函數
很多時候在我們都不知道拷貝構造函數的情況下，傳遞對象給函數參數或者函數返回對象都能很好的進行，這是因爲編譯器會給我們自動產生一個拷貝構造函數，這就是“默認拷貝構造函數”，這個構造函數很簡單，僅僅使用“老對象”的數據成員的值對“新對象”的數據成員一一進行賦值，它一般具有以下形式：
Rect::Rect(const Rect& r)
{
width = r.width;
height = r.height;
}當然，以上代碼不用我們編寫，編譯器會爲我們自動生成。但是如果認爲這樣就可以解決對象的複製問題，那就錯了，讓我們來考慮以下一段代碼：
class Rect
{
public:
Rect() // 構造函數，計數器加1
{
count++;
}
~Rect() // 析構函數，計數器減1
{
count--;
}
static int getCount() // 返回計數器的值
{
return count;
}
private:
int width;
int height;
static int count; // 一靜態成員做爲計數器
};
int Rect::count = 0; // 初始化計數器
int main()
{
Rect rect1;
cout<<"The count of Rect: "<<Rect::getCount()<<endl;
Rect rect2(rect1); // 使用rect1複製rect2，此時應該有兩個對象
cout<<"The count of Rect: "<<Rect::getCount()<<endl;
return 0;
}這段代碼對前面的類，加入了一個靜態成員，目的是進行計數。在主函數中，首先創建對象rect1，輸出此時的對象個數，然後使用rect1複製出對象rect2，再輸出此時的對象個數，按照理解，此時應該有兩個對象存在，但實際程序運行時，輸出的都是1，反應出只有1個對象。此外，在銷燬對象時，由於會調用銷燬兩個對象，類的析構函數會調用兩次，此時的計數器將變爲負數。
說白了，就是拷貝構造函數沒有處理靜態數據成員。
出現這些問題最根本就在於在複製對象時，計數器沒有遞增，我們重新編寫拷貝構造函數，如下：
class Rect
{
public:
Rect() // 構造函數，計數器加1
{
count++;
}
Rect(const Rect& r) // 拷貝構造函數
{
width = r.width;
height = r.height;
count++; // 計數器加1
}
~Rect() // 析構函數，計數器減1
{
count--;
}
static int getCount() // 返回計數器的值
{
return count;
}
private:
int width;
int height;
static int count; // 一靜態成員做爲計數器
};輸出結果：
淺拷貝
所謂淺拷貝，指的是在對象複製時，只對對象中的數據成員進行簡單的賦值，默認拷貝構造函數執行的也是淺拷貝。大多情況下“淺拷貝”已經能很好地工作了，但是一旦對象存在了動態成員，那麼淺拷貝就會出問題了，讓我們考慮如下一段代碼：
class Rect
{
public:
Rect() // 構造函數，p指向堆中分配的一空間
{
p = new int(100);
}
~Rect() // 析構函數，釋放動態分配的空間
{
if(p != NULL)
{
delete p;
}
}
private:
int width;
int height;
int *p; // 一指針成員
};
int main()
{
Rect rect1;
Rect rect2(rect1); // 複製對象
return 0;
}在這段代碼運行結束之前，會出現一個運行錯誤。原因就在於在進行對象複製時，對於動態分配的內容沒有進行正確的操作。我們來分析一下：
在運行定義rect1對象後，由於在構造函數中有一個動態分配的語句，因此執行後的內存情況大致如下：
在使用rect1複製rect2時，由於執行的是淺拷貝，只是將成員的值進行賦值，這時 rect1.p = rect2.p，也即這兩個指針指向了堆裏的同一個空間，如下圖所示：
當然，這不是我們所期望的結果，在銷燬對象時，兩個對象的析構函數將對同一個內存空間釋放兩次，這就是錯誤出現的原因。我們需要的不是兩個p有相同的值，而是兩個p指向的空間有相同的值，解決辦法就是使用“深拷貝”。
- 深拷貝
在“深拷貝”的情況下，對於對象中動態成員，就不能僅僅簡單地賦值了，而應該重新動態分配空間，如上面的例子就應該按照如下的方式進行處理：
class Rect
{
public:
Rect() // 構造函數，p指向堆中分配的一空間
{
p = new int(100);
}
Rect(const Rect& r)
{
width = r.width;
height = r.height;
p = new int; // 爲新對象重新動態分配空間
*p = *(r.p);
}
~Rect() // 析構函數，釋放動態分配的空間
{
if(p != NULL)
{
delete p;
}
}
private:
int width;
int height;
int *p; // 一指針成員
};此時，在完成對象的複製後，內存的一個大致情況如下：
此時rect1的p和rect2的p各自指向一段內存空間，但它們指向的空間具有相同的內容，這就是所謂的“深拷貝”。
- 防止默認拷貝發生
通過對對象複製的分析，我們發現對象的複製大多在進行“值傳遞”時發生，這裏有一個小技巧可以防止按值傳遞——聲明一個私有拷貝構造函數。甚至不必去定義這個拷貝構造函數，這樣因爲拷貝構造函數是私有的，如果用戶試圖按值傳遞或函數返回該類對象，將得到一個編譯錯誤，從而可以避免按值傳遞或返回對象。
// 防止按值傳遞
class CExample
{
private:
int a;
public:
//構造函數
CExample(int b)
{
a = b;
cout<<"creat: "<<a<<endl;
}
private:
//拷貝構造，只是聲明
CExample(const CExample& C);
public:
~CExample()
{
cout<< "delete: "<<a<<endl;
}
void Show ()
{
cout<<a<<endl;
}
};
//全局函數
void g_Fun(CExample C)
{
cout<<"test"<<endl;
}
int main()
{
CExample test(1);
//g_Fun(test); 按值傳遞將出錯
return 0;
} 拷貝構造函數的幾個細節
- 拷貝構造函數裏能調用private成員變量嗎?
解答：這個問題是在網上見的，當時一下子有點暈。其時從名子我們就知道拷貝構造函數其時就是一個特殊的構造函數，操作的還是自己類的成員變量，所以不受private的限制。
2 . 以下函數哪個是拷貝構造函數,爲什麼?
X::X(const X&);
X::X(X);
X::X(X&, int a=1);
X::X(X&, int a=1, int b=2);解答：對於一個類X, 如果一個構造函數的第一個參數是下列之一:
a) X&
b) const X&
c) volatile X&
d) const volatile X&
且沒有其他參數或其他參數都有默認值,那麼這個函數是拷貝構造函數.
X::X(const X&); //是拷貝構造函數
X::X(X&, int=1); //是拷貝構造函數
X::X(X&, int a=1, int b=2); //當然也是拷貝構造函數3 .一個類中可以存在多於一個的拷貝構造函數嗎?
解答：類中可以存在超過一個拷貝構造函數。
class X {
public:
X(const X&); // const 的拷貝構造
X(X&); // 非const的拷貝構造
};注意,如果一個類中只存在一個參數爲 X& 的拷貝構造函數,那麼就不能使用const X或volatile X的對象實行拷貝初始化.
class X {
public:
X();
X(X&);
};
const X cx;
X x = cx; // error如果一個類中沒有定義拷貝構造函數,那麼編譯器會自動產生一個默認的拷貝構造函數。
這個默認的參數可能爲 X::X(const X&)或 X::X(X&),由編譯器根據上下文決定選擇哪一個。