c++拷贝（shallow/deep拷贝）以及具体例子证明

一、拷贝构造

由已经存在的对象创建新对象。也就是说新对象，不是由构造器来构造，而是由拷贝构造器来完成

拷贝构造器的规则：
1、系统提供默认的拷贝构造器，一经实现，不复存在
2、系统提供的是等位拷贝，是浅拷贝
3、若要实现深拷贝，需自定义

首先我们通过一个例子来看看系统默认的拷贝构造函数：

#include <iostream>
using namespace std;
class data
{
public:
    data(int y=1999,int m=10,int d = 18)
        :year(y),month(m),day(d){}
    void dis()
    {
        cout<<"year:"<<year
           <<"month:"<<month
          <<"day:"<<day<<endl;;
    }
private:
    int year;
    int month;
    int day;
};

int main()
{
    data d(1964,8,27);
    d.dis();

    data m(d);
    m.dis();
    return 0;
}

在本例中，所有的数据都在栈空间内。无论是否自实现拷贝构造，均可以达到拷贝的目的。

二、shallow/deep copy （浅/深拷贝）

2.1、shallow copy

存在的问题：浅拷贝是将a1复制一份a2出来，然后a1与a2指向同一堆空间c ， a1与a2会共享堆空间c；这时就会出现一个问题！！！a1会析构一次，a2也会析构一次，但是只有一个堆空间c。这时就会出现double free

例（证明double free）：
程序：

#include <iostream>
#include<string.h>
using namespace std;

class dataSrt
{
public:
    dataSrt()
    {
       _str = new char[1024];
       strcpy(_str,"best luckily");
    }
    ~dataSrt()
    {
        delete []_str;
    }
    void dis()
    {
        cout<<"_str:"<<_str<<endl;
    }
private:
    char *_str;
};

int main()
{
    dataSrt s;
    s.dis();

    dataSrt ss(s);
    s.dis();
    return 0;
}

在Ubuntu中运行结果：提示出现了double free，产生了两次析构，证明程序中对象s与ss共享同一个堆空间。
为了解决double free的问题，我们可以通过自定义拷贝函数来实现深拷贝！！！

2.2、deep copy

通过自定义拷贝构造函数，实现深拷贝（即复制地址，也申请空间）。将a1复制一份a2出来，同时也为a2申请一个堆空间。
自定义拷贝构造语法定义：

class 类名
{
    类名(const 类名 & another)
    {}
};

class A
{
    A(const A & another)
    {}
};

例（解决double free）：
程序：

#include <iostream>
#include<string.h>
using namespace std;

class dataSrt
{
public:
    dataSrt()
    {
       _str = new char[1024];
       strcpy(_str,"best luckily");
    }
    //将堆空间也再申请一份
    dataSrt(const dataSrt &another)
    {
        _str = new char[strlen(another._str)+1];
        strcpy(_str,another._str);
    }
    ~dataSrt()
    {
        delete []_str;
    }
    void dis()
    {
        cout<<"_str:"<<_str<<endl;
    }
private:
    char *_str;
};

int main()
{
    dataSrt s;
    s.dis();

    dataSrt ss(s);
    s.dis();
    return 0;
}

运行结果：已经正常运行了

总结：shallow copy 如果对象中不含有堆上的空间（），此时浅拷贝可以满足需求，不需要自实现；如果对象上含有堆上的空间（*），此时浅拷贝不能满足需求，需要自实现；浅拷贝会带来重析构 即double free