一、深拷貝和淺拷貝構造函數總結:
1、兩個特殊的構造函數：
(1)無參構造函數：
沒有參數的構造函數
Class Test
{
public:
Test()
{
//這是一個無參構造函數
}
};當類中沒有定義構造函數時，編譯器默認提供一個無參構造函數，並且其函數體為空；換句話來說，就是我們在類中，不用我們程序猿自己寫，編譯就自動提供了無參構造函數（只是我們肉眼看不到!）
#include <iostream>
#include <string>
class Test{
//編譯器默認給我們提供了一個無參構造函數，只是我們肉眼看不到
};
int main()
{
Test t;
return 0;
}結果輸出(編譯時能夠通過的)：
root@txp-virtual-machine:/home/txp# g++ test.cpp
root@txp-virtual-machine:/home/txp#(2)拷貝構造函數：
參數為const class_name&的構造函數
class Test{
public:
Test(const Test& p)
{
}
}當類中沒有定義拷貝構造函數時，編譯器默認提供了一個拷貝構造函數，簡單的進行成員變量的值賦值
#include <iostream>
#include <string>
class Test{
private:
int i;
int j;
public:
/* Test(const Test& p)編譯器默認提供這樣操作的
{
i = p.i;
j = p.j;
}*/
};
int main()
{
Test t;
return 0;
}輸出結果(編譯可以通過)：
root@txp-virtual-machine:/home/txp# g++ test.cpp
root@txp-virtual-machine:/home/txp#(3)注意：
在寫程序的時候，定義的類對象初始化時看屬於哪種類型的:
Test t;//對應無參構造函數
Test t(1);//對應有參構造函數
Test t1;
Test t2=t1;//對應拷貝構造函數比如下面我定義的類對象屬於無參構造函數(當然前提是你手寫了其他構造函數，雖然說編譯器會默認提供，但是既然要手寫，那麼三種構造函數就在定義類對象的時候按需求來寫),如果只寫了有參數構造函數，那麼編譯器就會報錯：
#include <iostream>
#include <string>
class Test{
private:
int i;
int j;
public:
Test(int a)
{
i = 9;
j=8;
}
Test(const Test& p)
{
i = p.i;
j = p.j;
}
};
int main()
{
Test t;
return 0;
}輸出結果：
root@txp-virtual-machine:/home/txp# g++ test.cpp
test.cpp: In function 『int main()』:
test.cpp:25:9: error: no matching function for call to 『Test::Test()』
Test t;
^
test.cpp:25:9: note: candidates are:
test.cpp:15:3: note: Test::Test(const Test&)
Test(const Test& p)
^
test.cpp:15:3: note: candidate expects 1 argument, 0 provided
test.cpp:10:3: note: Test::Test(int)
Test(int a)
^
test.cpp:10:3: note: candidate expects 1 argument, 0 provided4、拷貝構造函數的意義：
(1)淺拷貝
拷貝後對象的物理狀態相同
(2)深拷貝
拷貝後對象的邏輯狀態相同
(3)編譯器提供的拷貝構造函數隻進行淺拷貝
代碼版本一：
#include <stdio.h>
#include <string>
class Test{
private:
int i;
int j;
int *p;
public:
int getI()
{
return i;
}
int getJ()
{
return j;
}
int *getP()
{
return p;
}
Test(int a)
{
i = 2;
j = 3;
p = new int;
*p = a;
}
void free()
{
delete p;
}
};
int main()
{
Test t1(3);//Test t1 3;
Test t2 = t1;
printf("t1.i = %d, t1.j = %d, t1.p = %p\n", t1.getI(), t1.getJ(), t1.getP());
printf("t2.i = %d, t2.j = %d, t2.p = %p\n", t2.getI(), t2.getJ(), t2.getP());
t1.free();
t2.free();
return 0;
}輸出結果：
root@txp-virtual-machine:/home/txp# g++ test.cpp
root@txp-virtual-machine:/home/txp# ./a.out
t1.i = 2, t1.j = 3, t1.p = 0x1528010
t2.i = 2, t2.j = 3, t2.p = 0x1528010
*** Error in `./a.out': double free or corruption (fasttop): 0x0000000001528010 ***
Aborted (core dumped)註解：出現了段錯誤，仔細分析，我們發現這裡釋放了堆空間兩次(因為我們這裡沒有調用拷貝構造函數，也就是自己去寫拷貝構造函數；所以這種情況是淺拷貝，不能釋放兩次堆空間)：
代碼版本二(加上拷貝構造函數)：
#include <stdio.h>
#include <string>
class Test{
private:
int i;
int j;
int *p;
public:
int getI()
{
return i;
}
int getJ()
{
return j;
}
int *getP()
{
return p;
}
Test(int a)
{
i = 2;
j = 3;
p = new int;
*p = a;
}
Test(const Test& t)
{
i = t.i;
j = t.j;
p = new int;
*p = *t.p;
}
void free()
{
delete p;
}
};
int main()
{
Test t1(4);
Test t2 = t1;
printf("t1.i = %d, t1.j = %d, t1.p = %p\n", t1.getI(), t1.getJ(), t1.getP());
printf("t2.i = %d, t2.j = %d, t2.p = %p\n", t2.getI(), t2.getJ(), t2.getP());
t1.free();
t2.free();
return 0;
}輸出結果：
root@txp-virtual-machine:/home/txp# g++ test.cpp
root@txp-virtual-machine:/home/txp# ./a.out
t1.i = 2, t1.j = 3, t1.p = 0xb0a010
t2.i = 2, t2.j = 3, t2.p = 0xb0a030註解：從列印的p地址空間來看，就知釋放的兩個對象的堆空間不同，不再是指向同一堆空間了；同時我們發現淺拷貝只是簡單數值上的進行賦值而已；深拷貝不只是簡單的值賦值，而是從內存的角度來看，是操作不同的內存。
5、什麼時候需要進行深拷貝？
(1)對象中有成員指代了系統中的資源
成員指向了動態內存空間
成員打開了外存中的文件
成員使用了系統中的網絡埠
注意：一般來說，自定義拷貝構造函數(也就是我們自己手寫的)，必然需要實現深拷貝！
二、總結：
C++編譯器會默認提供構造函數
無參構造函數用於定義對象的默認初始化狀態
拷貝構造函數在創建對象時拷貝對象的狀態
對象的拷貝有淺拷貝和深拷貝兩種方式。
好了，今天的分享就到這裡，如果文章中有錯誤或者不理解的地方，可以交流互動，一起進步。我是txp，下期見！