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[1024];//深复制 ,该指针与 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),1);
val = v;
}
~CDemo()
{
if(--ptr->use == 0)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 == 0)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 = 20;
ADemo a(10,prr);
ADemo b = a;
cout<<"a = "<<a.get_ptr_val()<<endl;
cout<<"b = "<<b.get_ptr_val()<<endl;
cout<<"修改之后："<<endl;
a.set_ptr(40);
cout<<"a = "<<a.get_ptr_val()<<endl;
cout<<"b = "<<b.get_ptr_val()<<endl;
}
void test_QianCopy()
{

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

void test_smart()
{
int prr = 90;
CDemo a(100,prr);
CDemo b = a;
cout<<"a = "<<a.get_ptr_val()<<endl;
cout<<"b = "<<b.get_ptr_val()<<endl;
cout<<"修改之后："<<endl;
b.set_Ptr_val(180);
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 0;
}