c語言為什麼要釋放所分配的內存（深拷貝與淺拷貝的理解）

2023-07-24 19:45:25

先說下自己的理解吧，淺拷貝，即在定義一個類A，使用類似A obj; A obj1(obj);或者A obj1 = obj; 時候，由於沒有自定義拷貝構造函數，C 編譯器自動會產生一個默認的拷貝構造函數。這個默認的拷貝構造函數採用的是「位拷貝」（淺拷貝），而非「值拷貝」（深拷貝）的方式，如果類中含有指針變量，默認的拷貝構造函數必定出錯。

用一句簡單的話來說就是淺拷貝，只是對指針的拷貝，拷貝後兩個指針指向同一個內存空間，深拷貝不但對指針進行拷貝，而且對指針指向的內容進行拷貝，經深拷貝後的指針是指向兩個不同地址的指針。

淺拷貝會出現什麼問題呢？

假如有一個成員變量的指針，char *m_data;

其一，淺拷貝只是拷貝了指針，使得兩個指針指向同一個地址，這樣在對象塊結束，調用函數析構的時，會造成同一份資源析構2次，即delete同一塊內存2次，造成程序崩潰。

其二，淺拷貝使得obj.m_data和obj1.m_data指向同一塊內存，任何一方的變動都會影響到另一方。

其三，在釋放內存的時候，會造成obj1.m_data原有的內存沒有被釋放（這句話，剛開始我不太理解，如果沒有走自定義的拷貝構造函數，申請內存空間，A obj1(obj);也不走默認構造函數，走的是默認的拷貝構造函數，何來分配空間直說，更不會造成obj1.m_data原有的內存沒有被釋放，這裡剛開始我一直有疑問），造成內存洩露。

事實是這樣的，當delete obj.m_data, obj.m_data內存被釋放後，由於之前obj.m_data和obj1.m_data指向的是同一個內存空間，obj1.m_data所指的空間不能在被利用了，delete obj1.m_data也不會成功，一致已經無法操作該空間，所以導致內存洩露。

深拷貝採用了在堆內存中申請新的空間來存儲數據，這樣每個可以避免指針懸掛。

下面來看看類string的拷貝構造函數

　　　class String　　{　　 public:　　 String(const String &other); //拷貝構造函數　　 private:　　 char *m_data; //用於保存字符串　　}; 　　　　String(const String &other)　　{ 　　 int length = strlen(other.m_data);　　 m_data = new char[length 1];　　 strcpy(m_data, other.m_data);}

可以看到在拷貝構造函數中為成員變量申請了新的內存空間，這就使得兩個對象的成員變量不指向同一個內存空間，除非你的確需要這樣做，用於實現一些其他的用途。

【文章福利】需要C/C Linux伺服器架構師學習資料加群812855908（資料包括C/C ，Linux，golang技術，Nginx，ZeroMQ，MySQL，Redis，fastdfs，MongoDB，ZK，流媒體，CDN，P2P，K8S，Docker，TCP/IP，協程，DPDK，ffmpeg等）

淺拷貝：也就是在對象複製時，只是對對象中的數據成員進行簡單的賦值，如果對象中存在動態成員，即指針，淺拷貝就會出現問題，下面代碼：

　　#include 　　　　class A　　{　　 public:　　 A // 構造函數，p指向堆中分配的一空間　　 {　　 m_data = new char(100);　　 printf("默認構造函數\n");　　 }　　 ~A // 析構函數，釋放動態分配的空間　　 {　　 if(m_data != NULL)　　 {　　 delete m_data;　　 m_data = NULL;　　 printf("析構函數\n");　　 }　　 }　　 private:　　 char *m_data; // 一指針成員　　};　　　　int main　　{　　 A a;　　 A b(a); // 複製對象　　 return 0;　　}

運行結果：

*** glibc detected *** ./simple: double free or corruption (fasttop): 0x000000000c62a010 ***

分析：由於沒有拷貝構造函數，走編譯器默認的拷貝構造函數，A b(a); 進行對象析構時，會造成釋放同一內存空間2次，導致內存洩露。

深拷貝：對於深拷貝，針對成員變量存在指針的情況，不僅僅是簡單的指針賦值，而是重新分配內存空間，如下：

　　#include 　　#include 　　　　class A　　{　　 public:　　 A // 構造函數，p指向堆中分配的一空間　　 {　　 m_pdata = new char(100);　　 printf("默認構造函數\n");　　 }　　　　 A(const A& r)　　 {　　 m_pdata = new char(100); // 為新對象重新動態分配空間　　 memcpy(m_pdata, r.m_pdata, strlen(r.m_pdata));　　 printf("copy構造函數\n");　　 }　　　　 ~A // 析構函數，釋放動態分配的空間　　 {　　 if(m_pdata != NULL)　　 {　　 delete m_pdata;　　 printf("析構函數\n");　　 }　　 }　　　　 private:　　 char *m_pdata; // 一指針成員　　};　　　　int main　　{　　 A a;　　 A b(a); // 複製對象　　 return 0;　　}

下面是我在具體的應用中使用深拷貝的情況，現在把這個demo貼出來：

　　#include 　　#include 　　#include 　　#include 　　　　using namespace std;　　　　/*存儲記錄信息的結構體*/　　typedef struct _RECODER_VALUE_STRU　　{　　 int Id;　　 int Age;　　}RECODER_VALUE_STRU;　　　　class recorder　　{　　 public:　　 recorder　　 {　　 m_stru_RecValue.Id = -1;　　 m_stru_RecValue.Age = -1;　　 m_pRecValue = &m_stru_RecValue;　　　　 m_paddr = new char[100];　　 memset(m_paddr,0x00 ,100);　　　　 printf("默認 construct recorder->&m_stru_RecValue: %x,\t m_pRecValue: %x\t m_paddr: %x\n", &m_stru_RecValue, m_pRecVa　　lue, m_paddr);　　 }　　　　 //拷貝構造函數　　/* recorder(const recorder &recorder)　　 {　　 m_stru_RecValue.Id = -1; 　　 m_stru_RecValue.Age = -1;　　 m_stru_RecValue = recorder.m_stru_RecValue;　　 m_pRecValue = &m_stru_RecValue;　　　　 m_paddr = new char[100];　　 memset(m_paddr, 0x00 ,100);　　 memcpy(m_paddr, recorder.m_paddr, strlen(recorder.m_paddr));　　　　 printf("拷貝 construct recorder->&m_stru_RecValue: %x\t m_pRecValue: %x\t m_paddr: %x\n",&m_stru_RecValue, m_pRecValu　　e, m_paddr);　　 }　　*/　　 //構造函數　　 recorder(int iId, int iAge)　　 {　　 m_stru_RecValue.Id = iId;　　 m_stru_RecValue.Age = iAge;　　 m_pRecValue = &m_stru_RecValue;　　　　 m_paddr = new char[100];　　 memset(m_paddr, 0x00 ,100);　　 memcpy(m_paddr, &iAge, sizeof(int));　　　　 printf("construct recorder->&m_stru_RecValue: %x \t m_pRecValue: %x\t m_paddr: %x\n", &m_stru_RecValue, m_pRecValue,　　m_paddr);　　 }　　　　 ~recorder　　 {　　 // cout<<"recorder 析構"<<endl;　　 /*if(m_paddr != NULL)　　 {　　 delete m_paddr;　　 m_paddr =NULL;　　 }*/　　 }　　　　 public:　　 RECODER_VALUE_STRU m_stru_RecValue;//存儲記錄信息的結構體 　　 void* m_pRecValue;//每條記錄的值　　 char *m_paddr;　　};　　　　int main　　{　　 cout <<"測試默認構造函數"<<endl<&m_stru_RecValue: %x\t addr: %x\t m_paddr: %x\n", &btest.m_stru_RecValue, btest.m_pRecValue, btest.m_paddr);　　 printf("非參：btest1->&m_stru_RecValue: %x\t addr: %x\t m_paddr: %x\n", &btest1.m_stru_RecValue, btest1.m_pRecValue, btest1.m_paddr);　　　　　　 cout << endl<<"測試帶參數的構造函數"<<endl<m_stru_RecValue: %x\t m_pRecValue: %x\t, m_paddr: %x\n", &btest2.m_stru_RecValue, btest2.m_pRecValue, btest2.m_　　paddr);　　 printf("帶參：btest3->m_stru_RecValue: %x\t m_pRecValue: %x\t, m_paddr: %x\n", &btest3.m_stru_RecValue, btest3.m_pRecValue, btest3.m_　　paddr);　　　　　　 return 0;　　}

對比結果：

注釋掉自定義拷貝構造函數,運行結果：

測試默認構造函數

默認 construct recorder->&m_stru_RecValue: ddbb8de0, m_pRecValue: ddbb8de0 m_paddr: 1b8a0010

非參：btest ->&m_stru_RecValue: ddbb8de0 addr: ddbb8de0 m_paddr: 1b8a0010

非參：btest1->&m_stru_RecValue: ddbb8dc0 addr: ddbb8de0 m_paddr: 1b8a0010

測試帶參數的構造函數

construct recorder->&m_stru_RecValue: ddbb8da0 m_pRecValue: ddbb8da0 m_paddr: 1b8a0080

帶參：btest2->m_stru_RecValue: ddbb8da0 m_pRecValue: ddbb8da0 , m_paddr: 1b8a0080

帶參：btest3->m_stru_RecValue: ddbb8d80 m_pRecValue: ddbb8da0 , m_paddr: 1b8a0080

默認拷貝構造函數結果分析：

通過結果可以看出，當成員變量為指針變量的時候，指針成員變量指向的地址都是同一個地址，無論是申請空間的成員變量m_pRecValue，和僅僅作為指針賦值的成員變量m_paddr；結構體的地址是變化的，除了指針淺拷貝與深拷貝沒什麼區別。

打開自定義拷貝構造函數，運行結果：

測試默認構造函數

默認 construct recorder->&m_stru_RecValue: 58bb9e20, m_pRecValue: 58bb9e20 m_paddr: 7a2c010

拷貝 construct recorder->&m_stru_RecValue: 58bb9e00 m_pRecValue: 58bb9e00 m_paddr: 7a2c080

非參：btest ->&m_stru_RecValue: 58bb9e20 addr: 58bb9e20 m_paddr: 7a2c010

非參：btest1->&m_stru_RecValue: 58bb9e00 addr: 58bb9e00 m_paddr: 7a2c080

測試帶參數的構造函數

construct recorder->&m_stru_RecValue: 58bb9de0 m_pRecValue: 58bb9de0 m_paddr: 7a2c0f0

拷貝 construct recorder->&m_stru_RecValue: 58bb9dc0 m_pRecValue: 58bb9dc0 m_paddr: 7a2c160

帶參：btest2->m_stru_RecValue: 58bb9de0 m_pRecValue: 58bb9de0 , m_paddr: 7a2c0f0

帶參：btest3->m_stru_RecValue: 58bb9dc0 m_pRecValue: 58bb9dc0 , m_paddr: 7a2c160

自定義深拷貝構造函數結果分析：

從結果可以看出，所有成員變量的地址都不相同。

其他：

1. 有時候為了防止默認拷貝發生，可以聲明一個私有的拷貝構造函數（不用寫代碼），這樣的話，如果試圖調用 A b(a); 就調用了私有的拷貝構造函數，編譯器會報錯，這也是一種偷懶的做法。

2. 一個類中可以存在多個拷貝構造函數，例如：

　　Calss A　　{　　Public:　　X(const X&);//const拷貝構造　　X(X &);//非const拷貝構造　　X(X& , int iData);　　}

暫時就先分析到這裡，如果以後遇到新的關於拷貝構造的情況，再繼續分析。