C++学习基础七——深复制与浅复制

一、深复制与浅复制基本知识

深复制和浅复制，又称为深拷贝和浅拷贝。

深复制和浅复制的区别如下图1所示：

　　　　　　　　　　图1

图1表示的是，定义一个类CDemo,包含int a和char *str两个成员变量，

当深复制时，A中的指针str与B中的指针str指向不同的地址，只是地址所指向的数据相同。

当浅复制时，A中的指针str与B中的指针str指向相同的地址。

 

1.浅复制：如果我们自己不实现复制构造函数，则C++会自动合成一个复制构造函数，又称为浅复制构造函数。

2.深复制：如果使用指针或者系统资源（如数据库，流对象等），则需要自己实现深复制的复制构造函数。

3.深复制与浅复制的代码区别：

 Demo(const Demo &other)
 {
   　this->id= other.id;
     this->str = new char[];//深复制 ,该指针与 other内的指针变量指向两个不同的地址，只是数据相同
     strcpy(this->str,other.str);
 }
 或者
 Demo(const Demo &other)
 {
      this->id= other.id;
       //深复制 ,该指针与 other内的指针变量指向两个不同的地址，只是数据相同
 　　　this->str = other.str;
 }
 Demo(const Demo &other)
 {
      this->id= other.id;
      strcpy(this->str,other.str);//浅复制
 }

4.如果自定义的类中包含指针，则应该自己实现深复制的复制构造函数，赋值操作符和析构函数。

二、管理指针成员

浅复制时因为两个指针指向相同的地址，很有可能出现野指针的情况；

深复制不会出现野指针，但会出现很多相同的对象，浪费内存。

如何有效的使用指针成员呢？管理指针成员的三个方法如图2所示：

　　　　图2

三种方式的具体区别如图3所示：

　　　　　　　　    　　　　图3

总结：智能指针其实是浅复制，只是智能指针不会产生野指针，而浅复制会产生野指针。

 #include <iostream>

 using namespace std;

 class ADemo
 {
 public:
     ADemo(int v, const int &p)
     {
         val = v;
         ptr = new int(p);
     }
     ~ADemo()
     {
         delete ptr;
     }

     ADemo(const ADemo &other)
     {
         val = other.val;
         ptr = new int;
         *ptr = *other.ptr;//深复制
     }

     ADemo& operator=(const ADemo &other)
     {
         val = other.val;
         ptr = new int;
         *ptr = *other.ptr;//深复制
         return *this;
     }

     int get_ptr_val()
     {
         return *ptr;
     }
     void set_ptr(int v)
     {
         *ptr = v;
     }
 private:
     int val;
     int *ptr;
 };

 class BDemo
 {
     public:
     BDemo(int v, const int &p)
     {
         val = v;
         ptr = new int(p);
     }
     ~BDemo()
     {
         delete ptr;
     }

     BDemo(const BDemo &other)
     {
         val = other.val;
         ptr = other.ptr;//浅复制
     }

     BDemo& operator=(const BDemo &rig)
     {
         val = rig.val;
         ptr = rig.ptr;//浅复制
         return *this;
     }

     int get_ptr_val()
     {
         return *ptr;
     }
     void set_ptr(int v)
     {
         *ptr = v;
     }
 private:
     int val;
     int *ptr;

 };

 //====================智能指针start============
 class U_Ptr
 {
     friend class CDemo;
 private:
     int *ptr;
     size_t use;
     U_Ptr(int *p,int u)
     {
         this->ptr = p;
         use = u;
     }
     ~U_Ptr()
     {
         delete ptr;
     }
 } ;

 class CDemo
 {//智能指针
 public:
     CDemo(const int &p,int v)
     {
         ptr = new U_Ptr(new int(p),);
         val = v;
     }
     ~CDemo()
     {
         if(--ptr->use == )delete ptr;
     }

     CDemo(const CDemo &other)
     {
         ++ptr->use;//多了一个对象使用
         val = other.val;
         ptr = other.ptr;//浅复制
     }
     CDemo& operator=(const CDemo &rig)
     {
         ++rig.ptr->use;
         if(--ptr->use == )delete ptr;

         val = rig.val;
         ptr = rig.ptr;//浅复制
         return *this;
     } 

     void set_Ptr_val(int v)
     {
         *ptr->ptr = v;
     }

     int get_ptr_val()
     {
         return *ptr->ptr;
     }
 private:
     int val;
     U_Ptr *ptr;
 };

 void test_ShenCopy()
 {
     int prr = ;
     ADemo a(,prr);
     ADemo b = a;
     cout<<"a = "<<a.get_ptr_val()<<endl;
     cout<<"b = "<<b.get_ptr_val()<<endl;
     cout<<"修改之后："<<endl;
     a.set_ptr();
     cout<<"a = "<<a.get_ptr_val()<<endl;
     cout<<"b = "<<b.get_ptr_val()<<endl;
 }
 void test_QianCopy()
 {

     int prr = ;
     BDemo a(,prr);
     BDemo b = a;
     cout<<"a = "<<a.get_ptr_val()<<endl;
     cout<<"b = "<<b.get_ptr_val()<<endl;
     cout<<"修改之后："<<endl;
     b.set_ptr();
     cout<<"a = "<<a.get_ptr_val()<<endl;
     cout<<"b = "<<b.get_ptr_val()<<endl;
 } 

 void test_smart()
 {
     int prr = ;
     CDemo a(,prr);
     CDemo b = a;
     cout<<"a = "<<a.get_ptr_val()<<endl;
     cout<<"b = "<<b.get_ptr_val()<<endl;
     cout<<"修改之后："<<endl;
     b.set_Ptr_val();
     cout<<"a = "<<a.get_ptr_val()<<endl;
     cout<<"b = "<<b.get_ptr_val()<<endl;
 }
 int main()
 {
     cout<<"深复制："<<endl;
     test_ShenCopy();
     cout<<endl<<"浅复制："<<endl;
     test_QianCopy();
     cout<<endl<<"智能指针："<<endl;
     test_smart();
     return ;
 }