浅拷贝、深拷贝（普、简）、写时拷贝

拷贝：这是 一个简单的名词，就是将右手的东西放到左手，c中有一个函数，strcpy，c++中也有拷贝。

但是你想过拷贝会出现的问题吗？下面我们来探讨一下：

浅拷贝出现的问题：……
解决方案：深拷贝、写时拷贝

先来看一个例子：

//class String//{//public://  String(const char* pStr = "")//      :size(strlen(pStr) + 1)//  {//      _pStr = new char[size];//      strcpy(_pStr, pStr);//      _pStr[size] = '\0';//  }////  String(const String& s)//      :size(s.size)//  {//      if (this != &s)//      {//          _pStr = s._pStr;//      }//  }////  ~String()//  {//      if (NULL != _pStr)//      {//          delete[] _pStr;//          _pStr = NULL;//      }//  }//private://  char*_pStr;//  int size;//};

//1、c++浅拷贝测试函数void FunTest(){    String s1("hello world");    String s2 = s1;//赋值完成之后，s1和s2公用同一块地址空间，再调用析构函数时，就会将同一块空间释放两次，出错}int main(){    FunTest();    return 0;}

那么我们就要想一下了，怎么样解决这个问题呢？

那么我们想从出问题的地方入手吧。这个问题是两个对象共用了一块空间，而释放一个对象的时候，同时释放这块空间，另一个对象并不知道这块空间已经释放了，当其再去使用空间的时候就出现了问题，也就是内存泄漏的问题。

既然是两个对象公用一块内存空间，那么我们可不可以将另一个对象也给一个内存空间呢？这样释放一块空间就不会出现这个问题了。那么接下来我们就来讨论这个问题，也就是深拷贝。

class String{public:    String(char*pStr = "")//构造函数    {        if (NULL == pStr)//如果字符串中没有字符，那么申请一个空间，放入‘\0’        {            _pStr = new char[1];            *_pStr = '\0';        }        else        {            _pStr = new char[strlen(pStr) + 1];//如果有字符,申请空间（strlen不包括‘\0’）            strcpy(_pStr, pStr);        }    }    String(const String & s)        :_pStr(new char[strlen(s._pStr) + 1])//初始化列表中将拷贝构造函数中的变量也开辟空间，避免浅拷贝出现的问题    {        strcpy(_pStr, s._pStr);    }    ~String()    {        if (NULL == _pStr)        {            delete[] _pStr;//释放空间，注意对应new[],对应delete[]            _pStr = NULL;//将指针变量指向NULL，避免其成为野指针        }    }private:    char*_pStr;};

//2、C++深拷贝测试函数void FunTest(){    String s1="Hello World";    String s2 = s1;}int main(){    FunTest();    return 0;}

上面 我们给出的方式是深拷贝的一种写法，即——将要拷贝的对象也给一块空间，这样虽然浪费空间，但是有效的解决了空间泄露的问题。

不过这里的给s2空间是不是感觉很熟悉呢？对，就是构造函数的功能之一，那么，我们可不可以走个捷径呢？直接就调用一下构造函数，不在去写具体的实施了，因为在构造函数中我们已经写好了，只需调用即可，下面就来看一下这种方式的实现吧！

//简洁版的深拷贝class String{public:    String(const char*pStr)    {        if (NULL == pStr)        {            _pStr = new char[1];            *_pStr = '\0';        }        else        {            _pStr = new char[strlen(pStr) + 1];            strcpy(_pStr, pStr);        }    }    String(String&s)//        :_pStr(NULL)    {        String temp(s._pStr);//        std::swap(temp._pStr, _pStr);    }    /*String& operator=(String&s)    {        std::swap(_pStr, s._pStr);        return *this;    }*/    String&operator=(String&s)    {        if (this != &s)        {            String s1(s._pStr);            std::swap(_pStr, s1._pStr);        }        return *this;    }    ~String()    {        if (NULL != _pStr)        {            delete[] _pStr;            _pStr = NULL;        }    }private:    char*_pStr;};

这就是简洁版的深拷贝，也是深拷贝的现代写法，技术都是一步步更新的，同样的代码也是越来越简化，我们要学会更新思想，同样的不能忘记他的由来，所以还是两种方法都记住吧。

刚提到了一个问题，就是深拷贝虽然解决了浅拷贝的问题，同样的也带了一个另外的不大不小的问题，那就是浪费空间。问题的大小取决于具体的环境等。不纠结这个问题了，还是像个办法解决这个问题。

怎样让浪费的空间回来？

那就是深拷贝的那一套不能用了，重新想一种方法来解决浅拷贝的问题，我们先来回想一下，他的问题是：两个对象的内存空间一样，导致其中一个对象释放资源的时候，同时释放内存空间，而另一个对象并不知道，所以，再调用这段内存空间的时候就会出现内存泄漏的问题。

刚才，我们从空间入手，将另一个对象也开辟了一段空间，那么如果对象很多的情况下，就会导致浪费空间，

哎，既然对象很多，那么我们可不可以用一个计数器来确定要不要释放内存空间呢？

来捋一下思路：首先有很多对象同时拥有一段内存，我们再开辟一个内存，专门存储对象的个数，这样，假如有10个对象，那么我们释放一个对象的资源的时候，同时将个数-1，再判断一下这个个数是不是0，如果是，那么就说明没有对象在使用这块内存空间了，就可以安然的释放了，如果不是，那么不释放。

好了，具体的细节都在代码里体现。

//写时拷贝class String{public:    String(const char*pStr)    {        if (NULL == pStr)        {            char*temp = new char[1+4];            _pStr = temp + 4;            GetRefer() = 1;            _pStr = '\0';        }        else        {            char*temp = new char[strlen(pStr) + 1+4];            _pStr = temp + 4;            strcpy(_pStr, pStr);            GetRefer() = 1;        }    }    String(const String&s)        :_pStr(s._pStr)    {        GetRefer()++;    }    ~String()    {        Release();    }    int& String::GetRefer();    void Release();private:    char*_pStr;};

//写时拷贝测试函数int& String::GetRefer(){    return *((int*)_pStr - 1);}void String::Release(){    if (--GetRefer() == 0)    {        _pStr -= 4;        delete[]_pStr;        _pStr = NULL;    }}void FunTest(){    String s1("hello world");    String s2 = s1;}int main(){    FunTest();    return 0;}

我们可以看到在上图从94到9c是存储主要内容的，即“hello world”，而在这段内存空间之前，还有一段内存，就是存储对象的个数，现在只有一个对象，因此显示的数字是1。当释放这个对象的资源的时候，这个数字变成0，就可以释放内存空间了。

现在我们在加一个对象，我们发现这两个 对象的地址是一样的，然后在看内存：

同一样的额内存的内容不变，但是，上面的一段空间的内容变为2，表示这个内存里有两个对象在使用，所以释放的时候就会避免浅拷贝出现的问题。