C++中的深拷貝與淺拷貝
時間：2018-09-27 來源：未知
說道c++，大家第一印象就是面向對象這四個字。當我們把一個抽象的類描述完畢，該有的功能都有的時候，接下來要做的事情就是去把這個類實例化成對象，換成人話就是創建一個對象。這個對象的類型 就是用于實例化這個對象的基類的類型。舉個栗子，在c語言中，我們想要定義一個整型變量，首先要寫出它的基類型int，然后寫出你想給出這個變量的名字int a=888;此時一個你想象中的整型變量就出來了。內存中就有一個大小為4個字節的空間，名字叫做a的家伙。它的值是888。然后我們就可以在這個變量的生存周期里面使用它了。
本文引用地址：//www.einuk.cn/emb/Column/7237.html
一個對象也可以這么理解，假如有類class T ，則我們可以利用該類去定義一個對象，T a，你看 基類型此時叫T ，變量名叫a。是不是和定義一個整型變量差不多?既然如此，那么是不是整型變量的賦值操作也同樣可以用在對象的賦值呢?
首先來看下整型變量的賦值：
int a = 10;
int b = a;
好了，就是這么簡單明了。把a變量所對應內存空間中的那個888常量復制到變量b所在的內存空間中。然后我們再累看下對象的賦值：
首先有個類 class Meizi，妹子類。嗯，沒錯，程序員找女朋友都很困難，所以只能靠C++去虛擬出來。描述這個妹子的方法和屬性我就不多說了，大家的想象力反正都很豐富，各種size自己選擇。這時，需要將這個具體的妹子創造出來,因此有了以下的代碼
class Meizi
{
public:
Meizi(int m_weight, float m_high, int m_age);
~Meizi();
void show()
{
cout << "this girl " << weight << "kg," << high << "cm,age" << age << endl;
}
private:
int weight;
float high;
int age;
};
Meizi::Meizi(int m_weight, float m_high, int m_age)
{
weight = m_weight;
high = m_high;
age = m_age;
}
Meizi::~Meizi()
{
}
int main()
{
Meizi Aoi_sola(45,155.4,33);
Aoi_sola.show();
return 0;
}
輸出為
可以看到一個對象中的結構比一個單純的整型變量要復雜，存在有各種成員變量。為了實現將一個類實例化成為一個對象，我們都知道會用到一種叫做構造函數的東西，把該分配的資源給分配了�，F在想要用這樣一個頗為復雜的對象去給另一個對象賦值的話，能否像之前整型變量賦值一樣呢?現在，就用這個剛剛出爐的妹子復制成另一個妹子，主程序改成這個樣子
int main()
{
Meizi Aoi_sola(45,155.4,33);
Aoi_sola.show();
Meizi Yoshizawa_Akiho = Aoi_sola;
Yoshizawa_Akiho.show();
return 0;
}
結果是
居然成功了，我們用了一個妹子去創造出了另一個。這個里面我們將原先那個Aoi_sola對象的內容完完全全復制給了新對象Yoshizawa_Akiho，那么在實現的過程中，我們的c++編譯器會調用一個看不見的東西，他叫做默認拷貝構造函數。這個函數為新妹子Yoshizawa_Akiho分配了內存空間并完成了與妹子Aoi_sola的復制過程，克隆人就這么出來了。
拷貝構造函數是怎么工作的?怎么就能分配內存且復制成員了呢?向下看
class Meizi
{
public:
Meizi(int m_weight, float m_high, int m_age);
Meizi(Meizi &M);
~Meizi();
void show()
{
cout << "this girl " << weight << "kg," << high << "cm,age" << age << endl;
}
private:
int weight;
float high;
int age;
};
Meizi::Meizi(int m_weight, float m_high, int m_age)
{
weight = m_weight;
high = m_high;
age = m_age;
}
Meizi::Meizi(Meizi &M)//<-----看這里看這里
{
weight = M.weight;
high = M.high;
age = M.age;
cout << "調用拷貝構造" << endl;
}
Meizi::~Meizi()
{
}
int main()
{
Meizi Aoi_sola(45,155.4,33);
Aoi_sola.show();
Meizi Yoshizawa_Akiho = Aoi_sola;
Yoshizawa_Akiho.show();
return 0;
}
然后我們運行下
看到了么，在去創建新對象Yoshizawa_Akiho的時候調用了我們自己定義的一個函數，這個函數和類名同名，沒有返回值類型，參數是該類的一個引用。我們不用顯式的調用它，因為在用一個已經初始化過了的自定義類類型對象去初始化一個新對象的時候拷貝構造函數會被自動的調用，當類的對象需要拷貝時，拷貝構造函數將會被調用。以下情況都會調用拷貝構造函數：
(1)一個對象以值傳遞的方式傳入函數體
(2)一個對象以值傳遞的方式從函數返回
(3)一個對象需要通過另外一個對象進行初始化。
如果在類中沒有顯式地聲明一個拷貝構造函數，那么，編譯器將會自動生成一個默認的拷貝構造函數，該構造函數完成對象之間的位拷貝。位拷貝又稱淺拷貝。
淺淺的拷貝一下，就能將一個新對象(妹子)創建出來，方便又快捷。想想還有些小激動呢。
沒錯，接下來我要說可是，在某些狀況下，類內成員變量需要動態開辟堆內存，如果實行淺拷貝，也就是把對象里的值完全復制給另一個對象，如A=B。這時，如果B中有一個成員變量指針已經申請了內存，那A中的那個成員變量也指向同一塊內存。這就出現了問題：當B把內存釋放了(如：析構)，這時A內的指針就是野指針了，出現運行錯誤。不信?我們來試試看，還是這兩個妹子，Aoi_sola和Yoshizawa_Akiho，
class Meizi
{
public:
Meizi(int m_weight, float m_high, int m_age,char *home);
~Meizi();
void show()
{
cout << "this girl " << weight << "kg," << high << "cm,age" << age <<"home"<
}
private:
int weight;
float high;
int age;
char *home;
};
Meizi::Meizi(int m_weight, float m_high, int m_age,char *m_home)
{
weight = m_weight;
high = m_high;
age = m_age;
home = new char[20];
strcpy(home,m_home);
}
Meizi::~Meizi()
{
}
int main()
{
Meizi Aoi_sola(45,155.4,33,"Tokyo");
Aoi_sola.show();
Meizi Yoshizawa_Akiho = Aoi_sola;
Yoshizawa_Akiho.show();
return 0;
}
新添加了妹子的家鄉成員變量 home，是一個字符串。之后我們采取默認拷貝構造函數來初始化新對象，結果：
錯了。
原因在于構造函數中我們利用malloc動態開辟了一段堆空間，此時對象Aoi_sola的成員變量指針home指向了該空間，利用默認構造函數初始化新對象Yoshizawa_Akiho，這個時候你知道是復制操作，因此Yoshizawa_Akiho對象的成員變量home指針也指向的和原先對象相同的地方，在析構的時候，我們有個好習慣，手動分配的資源要手動釋放，結果我們將兩個對象析構的時候調用了兩次析構函數也就是調用了兩次delete，也就是將同一塊內存釋放了兩次。結果當然出錯了。針對這種情況，我們就需要深拷貝構造函數，多深呢?請看代碼
class Meizi
{
public:
Meizi(int m_weight, float m_high, int m_age,char *home);
Meizi(Meizi &M) //這里就是我們自己定義的拷貝構造函數
{
weight = M.weight;
high = M.high;
age = M.age;
home = new char[20];
if (home != NULL)
{
strcpy(home,M.home);
}
cout << "copy instructor" << endl;
//深刻的拷貝構造了一下
}
~Meizi();
void show()
{
cout << "this girl " << weight << "kg," << high << "cm,age" << age << endl;
}
private:
int weight;
float high;
int age;
char *home;
};
Meizi::Meizi(int m_weight, float m_high, int m_age,char *m_home)
{
weight = m_weight;
high = m_high;
age = m_age;
home = new char[20];
strcpy(home,m_home);
}
Meizi::~Meizi()
{
delete home;
}
int main()
{
Meizi Aoi_sola(45,155.4,33,"Tokyo");
Aoi_sola.show();
Meizi Yoshizawa_Akiho = Aoi_sola;
Yoshizawa_Akiho.show();
return 0;
}
結果：
所以原先的對象去創建新對象的時候會調用我們自己定義的拷貝構造函數,在自定義拷貝構造函數中我們自己手動分配了內存空間。進而實現的拷貝構造，叫做深拷貝。
那么問題來了，這兩種拷貝構造我應該怎么選呢?什么時候用淺拷貝什么時候用深拷貝?總的來說還是要根據類的實現來判斷該用淺拷貝還是深拷貝。如果需要拷貝這個對象引用的對象，則是深拷貝，否則是淺拷貝。
