c语言为什么要释放所分配的内存(深拷贝与浅拷贝的理解)(1)

先说下自己的理解吧,浅拷贝,即在定义一个类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等)

c语言为什么要释放所分配的内存(深拷贝与浅拷贝的理解)(2)

浅拷贝:也就是在对象复制时,只是对对象中的数据成员进行简单的赋值,如果对象中存在动态成员,即指针,浅拷贝就会出现问题,下面代码:

  #include <stdio.h>    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 <stdio.h>  #include <string>    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 <iostream>  #include <errno.h>  #include <vector>  #include <stdio.h>    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<<endl;   recorder btest;   recorder btest1(btest);     printf("非参:btest ->&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<<endl;       recorder btest2(1, 100);   recorder btest3(btest2);   printf("带参:btest2->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);  }

暂时就先分析到这里,如果以后遇到新的关于拷贝构造的情况,再继续分析。

,