（簡單點就是：對於指針，深copy時候，相同數據指針指向不同的內存地址
深度拷貝是什麼？
其實就是針對指針或引用的特殊處理而已。任何面向對象的程序都要解決的問題。
一個對象A裏面有一個指針指向一堆數據，你現在想把這個對象拷貝一份B，那麼這個指針怎麼辦？如果默認的話，指針的內容被拷貝，那麼拷貝後的對象B和之前的對象A中的指針指向的是同一個數據。這樣就是“淺拷貝”。如果B中修改了這些數據，A那邊一樣會變，因爲二者的數據其實是同一個。這在有些時候會出問題。
而“深拷貝”就是，自己處理這些指針，給B重新分配一塊內存，然後把指針指向的數據也拷貝一份，這樣A和B就完全獨立，互相沒有影響。 ）;
淺拷貝就是成員數據之間的一一賦值：把值賦給一一賦給要拷貝的值。但是可能會有這樣的情況：對象還包含資源，這裏的資源可以值堆資源，或者一個文件。。當 值拷貝的時候，兩個對象就有用共同的資源，同時對資源可以訪問，這樣就會出問題。深拷貝就是用來解決這樣的問題的，它把資源也賦值一次，使對象擁有不同的 資源，但資源的內容是一樣的。對於堆資源來說，就是在開闢一片堆內存，把原來的內容拷貝。
如果你拷貝的對象中引用了某個外部的內容（比如分配在堆上的數據），那麼在拷貝這個對象的時候，讓新舊兩個對象指向同一個外部的內容，就是淺拷貝；如果在拷貝這個對象的時候爲新對象製作了外部對象的獨立拷貝，就是深拷貝
引用和指針的語義是相似的，引用是不可改變的指針，指針是可以改變的引用。其實都是實現了引用語義。
深拷貝和淺拷貝的區別是在對象狀態中包含其它對象的引用的時候，當拷貝一個對象時，如果需要拷貝這個對象引用的對象，則是深拷貝，否則是淺拷貝。
COW語義是“深拷貝”與“推遲計算”的組合，仍然是深拷貝，而非淺拷貝，因爲拷貝之後的兩個對象的數據在邏輯上是不相關的，只是內容相同。
無論深淺，都是需要的。當深拷貝發生時，通常表明存在着一個“聚合關係”，而淺拷貝發生時，通常表明存在着一個“相識關係”。
舉個簡單的例子：
當你實現一個Composite Pattern，你通常都會實現一個深拷貝(如果需要拷貝的話)，很少有要求同的Composite共享Leaf的；
而當你實現一個Observer Pattern時，如果你需要拷貝Observer,你大概不會去拷貝Subject，這時就要實現個淺拷貝。
是深拷貝還是淺拷貝，並不是取決於時間效率、空間效率或是語言等等，而是取決於哪一個是邏輯上正確的
//--------------------------------------------------------------------------------
在學習這一章內容前我們已經學習過了類的構造函數和析構函數的相關知識，對於普通類型的對象來說，他們之間的複製是很簡單的，例如：
int a = 10; int b =a; |
自己定義的類的對象同樣是對象，誰也不能阻止我們用以下的方式進行復制,例如：
#include <iostream>
usingnamespacestd;
classTest
{
public:
Test(inttemp)
{
p1=temp;
}
protected:
intp1;
};
voidmain()
{
Test a(99);
Test b=a;
}
|
普通對象和類對象同爲對象，他們之間的特性有相似之處也有不同之處，類對象內部存在成員變量，而普通對象是沒有的，當同樣的複製方法發生在不同的對象上的 時候，那麼系統對他們進行的操作也是不一樣的，就類對象而言，相同類型的類對象是通過拷貝構造函數來完成整個複製過程的，在上面的代碼中,我們並沒有看到 拷貝構造函數，同樣完成了複製工作，這又是爲什麼呢？因爲當一個類沒有自定義的拷貝構造函數的時候系統會自動提供一個默認的拷貝構造函數，來完成複製工 作。
下面，我們爲了說明情況，就普通情況而言(以上面的代碼爲例)，我們來自己定義一個與系統默認拷貝構造函數一樣的拷貝構造函數，看看它的內部是如何工作的！
代碼如下：
#include <iostream>
usingnamespacestd;
classTest
{
public:
Test(inttemp)
{
p1=temp;
}
Test(Test &c_t)//這裏就是自定義的拷貝構造函數
{
cout<<"進入copy構造函數"<p1=c_t.p1;//這句如果去掉就不能完成複製工作了,此句複製過程的核心語句
}
public:
intp1;
};
voidmain()
{
Test a(99);
Test b=a;
cout<cin.get();
}
|
上面代碼中的Test(Test &c_t)就是我們自定義的拷貝構造函數，拷貝構造函數的名稱必須與類名稱一致，函數的形式參數是本類型的一個引用變量,且必須是引用。
當用一個已經初始化過了的自定義類類型對象去初始化另一個新構造的對象的時候，拷貝構造函數就會被自動調用，如果你沒有自定義拷貝構造函數的時候系統將會提供給一個默認的拷貝構造函數來完成這個過程，上面代碼的複製核心語句就是通過 Test(Test &c_t)拷貝構造函數內的p1=c_t.p1;語句完成的。如果取掉這句代碼，那麼b對象的p1屬性將得到一個未知的隨機值；
下面我們來討論一下關於淺拷貝和深拷貝的問題。
就上面的代碼情況而言，很多人會問到，既然系統會自動提供一個默認的拷貝構造函數來處理複製，那麼我們沒有意義要去自定義拷貝構造函數呀，對，就普通情況 而言這的確是沒有必要的，但在某寫狀況下，類體內的成員是需要開闢動態開闢堆內存的,如果我們不自定義拷貝構造函數而讓系統自己處理，那麼就會導致堆內存 的所屬權產生混亂，試想一下，已經開闢的一端堆地址原來是屬於對象a的，由於複製過程發生，b對象取得是a已經開闢的堆地址，一旦程序產生析構，釋放堆的 時候，計算機是不可能清楚這段地址是真正屬於誰的，當連續發生兩次析構的時候就出現了運行錯誤。
爲了更詳細的說明問題，請看如下的代碼。
#include <iostream>
usingnamespacestd;
classInternet
{
public:
Internet(char*name,char*address)
{
cout<<"載入構造函數"<strcpy(Internet::name,name);
strcpy(Internet::address,address);
cname=newchar[strlen(name)+1];
if(cname!=NULL)
{
strcpy(Internet::cname,name);
}
}
Internet(Internet &temp)
{
cout<<"載入COPY構造函數"<strcpy(Internet::name,temp.name);
strcpy(Internet::address,temp.address);
cname=newchar[strlen(name)+1];//這裏注意,深拷貝的體現!
if(cname!=NULL)
{
strcpy(Internet::cname,name);
}
}
~Internet()
{
cout<<"載入析構函數!";
delete[] cname;
cin.get();
}
voidshow();
protected:
charname[20];
charaddress[30];
char*cname;
};
voidInternet::show()
{
cout<}
voidtest(Internet ts)
{
cout<<"載入test函數"<}
voidmain()
{
Internet a("中國軟件開發實驗室","www.cndev-lab.com");
Internet b =a;
b.show();
test(b);
}
|
上面代碼就演示了深拷貝的問題,對對象b的cname屬性採取了新開闢內存的方式避免了內存歸屬不清所導致析構釋放空間時候的錯誤,最後我必須提一下，對於上面的程序我的解釋並不多，就是希望讀者本身運行程序觀察變化，進而深刻理解。
深拷貝和淺拷貝的定義可以簡單理解成：如果一個類擁有資源(堆，或者是其它系統資源)，當這個類的對象發生複製過程的時候，這個過程就可以叫做深拷貝，反之對象存在資源但複製過程並未複製資源的情況視爲淺拷貝。
淺拷貝資源後在釋放資源的時候會產生資源歸屬不清的情況導致程序運行出錯,這點尤其需要注意!
以前我們的教程中討論過函數返回對象產生臨時變量的問題，接下來我們來看一下在函數中返回自定義類型對象是否也遵循此規則產生臨時對象！
先運行下列代碼:
#include <iostream>
usingnamespacestd;
classInternet
{
public:
Internet()
{
};
Internet(char*name,char*address)
{
cout<<"載入構造函數"<strcpy(Internet::name,name);
strcpy(Internet::address,address);
}
Internet(Internet &temp)
{
cout<<"載入COPY構造函數"<strcpy(Internet::name,temp.name);
strcpy(Internet::address,temp.address);
cin.get();
}
~Internet()
{
cout<<"載入析構函數!";
cin.get();
}
protected:
charname[20];
charaddress[20];
};
Internet tp()
{
Internet b("中國軟件開發實驗室","www.cndev-lab.com");
returnb;
}
voidmain()
{
Internet a;
a=tp();
}
|
從上面的代碼運行結果可以看出，程序一共載入過析構函數三次，證明了由函數返回自定義類型對象同樣會產生臨時變量，事實上對象a得到的就是這個臨時Internet類類型對象temp的值。
這一下節的內容我們來說一下無名對象。
利用無名對象初始化對象系統不會不調用拷貝構造函數。
那麼什麼又是無名對象呢？
很簡單，如果在上面程序的main函數中有：
Internet ("中國軟件開發實驗室","www.cndev-lab.com");
|
這樣的一句語句就會產生一個無名對象，無名對象會調用構造函數但利用無名對象初始化對象系統不會不調用拷貝構造函數！
下面三段代碼是很見到的三種利用無名對象初始化對象的例子。
#include <iostream>
usingnamespacestd;
classInternet
{
public:
Internet(char*name,char*address)
{
cout<<"載入構造函數"<strcpy(Internet::name,name);
}
Internet(Internet &temp)
{
cout<<"載入COPY構造函數"<strcpy(Internet::name,temp.name);
cin.get();
}
~Internet()
{
cout<<"載入析構函數!";
cin.get();
}
public:
charname[20];
charaddress[20];
};
voidmain()
{
Internet a=Internet("中國軟件開發實驗室","www.cndev-lab.com");
cout<cin.get();
}
|
上面代碼的運行結果有點“出人意料”，從思維邏輯上說，當無名對象創建了後，是應該調用自定義拷貝構造函數，或者是默認拷貝構造函數來完成複製過程的，但事實上系統並沒有這麼做，因爲無名對象使用過後在整個程序中就失去了作用，對於這種情況c++會把代碼看成是：
Internet a("中國軟件開發實驗室","www.cndev-lab.com");
省略了創建無名對象這一過程，所以說不會調用拷貝構造函數。
最後讓我們來看看引用無名對象的情況。
#include <iostream>
usingnamespacestd;
classInternet
{
public:
Internet(char*name,char*address)
{
cout<<"載入構造函數"<strcpy(Internet::name,name);
}
Internet(Internet &temp)
{
cout<<"載入COPY構造函數"<strcpy(Internet::name,temp.name);
cin.get();
}
~Internet()
{
cout<<"載入析構函數!";
}
public:
charname[20];
charaddress[20];
};
voidmain()
{
Internet &a=Internet("中國軟件開發實驗室","www.cndev-lab.com");
cout<cin.get();
}
|
引用本身是對象的別名，和複製並沒有關係，所以不會調用拷貝構造函數,但要注意的是，在c++看來:
Internet &a=Internet("中國軟件開發實驗室","www.cndev-lab.com");
|
是等價與:
Internet a("中國軟件開發實驗室","www.cndev-lab.com");
|
的,注意觀察調用析構函數的位置（這種情況是在main()外調用，而無名對象本身是在main()內析構的）。
來自互聯網