深拷贝&浅拷贝&写时拷贝

对于C++中的深拷贝与浅拷贝，就类似一个人去模仿一个人
浅拷贝：（影子复制，也称影子克隆），就算怎样去模仿那个人，可是也不是成为本尊，只是与本尊极为相似的一个人。
深拷贝：(深度克隆):不紧复制对象的基本类,同时也复制原对象中的对象.就是说完全是新对象产生的.就像对一个人通过克隆技术，实现他的另一个。
下面我们就对浅拷贝与深拷贝做一个具体的分析吧！
1.管理字符串string
2.深拷贝与浅拷贝中，构造函数与析构函数是一致的，不影响函数的运行。
一、浅拷贝
浅拷贝：当类中有指针对象时，拷贝构造和赋值运算符重载只进行值拷贝，两个对象指向同一个空间，当对象销毁之时，该空间被释放了两次，因此程序崩溃。

下面我们就来抛一段具体的代码来分析吧！

//浅拷贝，，只拷贝内存中的值，如果调用这个函数的话，会使一块内存被释放两次，，从而导致程序崩溃      //导致两个对象共用同一块一块空间      //反例      String(const String &s)            :_pStr(s._pStr)      {}      String&operator=(const String &s)      {            if (this != &s)            {                  _pStr = s._pStr;            }            return *this;      }

在此处调用拷贝构造函数之时，由于两个对象甚至更多的对象同时指向同一块内存，因此在释放之时，由于多次释放，因此使得程序崩溃。

对于赋值运算符的重载，由于与拷贝构造函数一致，在上面已经给出分析，因此在这里就不在给出他的分析了。
总结：如果在类中没有显式地声明一个拷贝构造函数，那么，编译器将会自动生成一个默认的拷贝构造函数，该构造函数完成对象之间的位拷贝。位拷贝又称浅拷贝。
二、深拷贝
深拷贝是指源对象与拷贝对象互相独立，其中任何一个对象的改动都不会对另外一个对象造成影响。
深拷贝：构造s2之时，拷贝一块与s1指向数据一样大的数据块，并将值拷贝下来，这样s1和s2指向各自的数据块，析构时各自释放各自的。如果一个类拥有资源，当这个类的对象发生复制过程的时候，资源重新分配，这个过程就是深拷贝，反之，没有重新分配资源，就是浅拷贝。
下面，上代码

//深拷贝      String(const String& s)//拷贝构造（普通版）            :_pStr(new char[strlen(s._pStr) + 1])//为传递过来的函数开辟空间，防止两块空间共用一块空间      {            strcpy(_pStr, s._pStr);      }String& operator=(const String& s)//（普通版）1.开辟新空间2.拷贝元素3.释放旧空间      {            if (this != &s)//如若不相等，则对齐进行赋值            {                  char *tmp = new char[strlen(s._pStr) + 1];//s传过来就是一个指向第一个元素的指针，开辟新空间                  strcpy(tmp, s._pStr);                  delete[] _pStr;                  _pStr = tmp;            }            return *this;      }

深拷贝与浅拷贝最大的区别就是，在深拷贝之时，会为对象重新分配内存，使其指向新的内存空间，因此使得其在释放之时，不会因为一块空间被释放多次而使得程序崩溃。

深拷贝的简洁版：

String(const String& s)//拷贝构造（简洁版）      :_pStr(NULL)//防止_pStr称为野指针，，为其开辟空间{      String tmp(s._pStr);//创建临时变量，调用构造函数      swap(_pStr, tmp._pStr);}String& operator=(const String& s){      if (this != &s)      {            String tmp(s._pStr);//调用构造函数            swap(_pStr, tmp._pStr);      }      return *this;}String& operator=( String s)//调用拷贝构造{      swap(_pStr, s._pStr);      return *this;}String& operator=(const String& s){      if (this != &s)      {            String tmp(s);            swap(_pStr, tmp._pStr);      }      return *this;}

总结（深拷贝与浅拷贝）
浅拷贝是指将对象中的数值类型的字段拷贝到新的对象中，而对象中的引用型字段则指复制它的一个引用到目标对象。如果改变目标对象 中引用型字段的值他将反映在原是对象中，也就是说原始对象中对应的字段也会发生变化。
深拷贝与浅拷贝不同的是对于引用的处理，深拷贝将会在新对象中创建一 个新的和原是对象中对应字段相同（内容相同）的字段，也就是说这个引用和原是对象的引用是不同的，我们在改变新对象中的这个字段的时候是不会影响到原始对 象中对应字段的内容。

三、浅拷贝与写时拷贝的结合体
如果不想为对象开辟新的内存空间，但是也不想使得程序崩溃，因此在此处我们就需要定义引用计数的指针，他的任务就是指向对象使用的这块空间，如果这块内存一直在使用，因此就不释放他，如果已经是最后一个对象在使用，在由此对其进行释放。

class String{public:      String(char* pStr = "")//构造函数            :_pCount(new int(1))//为引用计数开辟空间      {            if (pStr == NULL)//传过来的字符串为空            {                  _pStr = new char[1];//此处这样申请的原因就是，为了释放时的安全，防止内存泄漏，为了达到释放空间时的匹配                  *_pStr = '\0';//将内容放在_pStr中            }            else            {                  _pStr = new char[strlen(pStr) + 1];                  strcpy(_pStr, pStr);//此处拷贝，连同“\0”一起拷贝            }      }      String(const String &s)            :_pStr(s._pStr)//字符串空间的共用            , _pCount(s._pCount)      {            ++(*_pCount);//如果共用一块空间，则让其引用计数自增      }      String&operator=(const String &s)      {            if (this != &s)            {                  if (0 == --(*_pCount))//当前空间只有一个对象在使用s3=s2;赋值方式                  {                        delete _pStr;                        _pStr = NULL;                  }                  _pStr = s._pStr;//s2=s3;这种赋值方式                  _pCount = s._pCount;                  ++(*_pCount);            }            return *this;      }      ~String()//析构函数      {            if (_pStr&&(0 == --(*_pCount)))//当当前空间只有一个对象在使用之时，就将此空间释放            {                  delete _pStr;                  _pStr = NULL;            }      }private:      char* _pStr;      int *_pCount;//定义引用计数的空间};

再利用此种方式之时，或许有的人就会有人有疑问，为什么不将计数定义为普通变量或者静态变量，现在我们就一一对其作出解答。
1、为什么不将其定义为普通变量
定义为普通变量之时，在析构函数之时，只是对其一个对象中的计数进行改变，，从而使得对象一直不能被销毁，从而导致程序的崩溃。
2.既然要实现共享，那为什么不使用静态变量（static）
在使用静态变量之时，虽然实现了对象的共享，但是在又重新创建另一个对象之时，又将计数的值置为初始值，从而使得被共用的内存不能得到适合的释放，从而又变成了简单的浅拷贝了，从而使得程序崩溃。

因此在引用计数之时，才定义一个指针变量，让其为每个对象均创建一个指针，实时监控着内存的变化，从而实现了引用计数的目的。

四、写时拷贝
利用上面引用计数的方法，虽然可以很好的实现利用浅拷贝实现正确的拷贝，但是在维护起两个指针有些困难，有时会忘了释放某个动态开辟的内存，从而使得内存泄漏，因此，我们就想出一个更好的办法，用来实现浅拷贝，从而更加方便了我们的管理。

class String{public:      String(char* pStr = "")//构造函数      {            if (pStr == NULL)//传过来的字符串为空                  pStr = '\0';//将内容放在_pStr中                  _pStr = new char[strlen(pStr) + 1 + 4];//在此处，多开辟4个字节，将引用计数放在空间的起始位置，真正放字符串的空间，则在内存中的起始偏移4个字节                  strcpy(_pStr, pStr);                  GetReference() = 1;      }      String(const String &s)            :_pStr(s._pStr)//字符串空间的共用      {            ++GetReference();      }      String& operator=(const String &s)      {            if (this != &s)            {                  Release();//将其旧空间释放                  _pStr = s._pStr;                  ++GetReference();            }            return *this;      }      char &operator[](size_t index)      {            if (GetReference() > 1)//判断是否共用空间            {                  String str(_pStr);//为要修改的空间新开辟另一段空间                  swap(_pStr, str._pStr);//在交换期间，又为引用计数加为原来的数，所以在这个函数体内，不用对引用计数的改变。            }            return _pStr[index];      }      ~String()//析构函数      {            Release();      }private:      int& GetReference()      {            return *(int*)(_pStr - 4);//找到起始位置,堆上的空间      }      void Release()//释放空间      {            if (_pStr && (0 == --GetReference()))            {                  _pStr -= 4;                  delete[] _pStr;                  _pStr = NULL;            }      }private:      char* _pStr;};int main(){      String s1("hello");      String s2(s1);      String s3(s2);      s1[0] = 'w';      String s4;      s4 = s2;      //s2 = s4;      system("pause");      return 0;}

虽然用这种方法，极好的实现了浅拷贝，但是在需要改变哪个字符串中的值时，还有些不方便，因此才有了上面的[]运算符的重载，仅仅只改变某个对象中的某个字符，从而不至于形成“牵一发而动全身”的后果。

下面给出测试代码：

int main(){    String s1("hello");    String s2(s1);    String s3(s2);    String s4;    s1[0]='w';    s4 = s2;    //s2 = s4;    system("pause");    return 0;}

对于深拷贝与浅拷贝的内容，大概就这么多了，希望我们一起学习，一起进步。
有什么问题，还请指正!!!!谢谢大家的几分钟。