String 类的实现（1）浅拷贝存在的问题以及深拷贝实现

1.   浅拷贝 ： 也称位拷贝 ， 编译器只是直接将指针的值拷贝过来， 结果多个对象共用 同 一块内存， 当一个对象将这块内 存释放掉之后， 另 一些对象不知道该块空间已经还给了系统， 以为还有效， 所以在对这段内存进行操作的时候， 发生了违规访问。

先上代码

 class String
 {
 public:
     /* 浅拷贝---下列代码相当于系统合成的
     String()
     {
         _pStr = new char;
         *_pStr = '\0';
     }*/
     String(const char *pStr = "")
     {
         if (pStr == NULL)
         {
             _pStr = new char[];
             *_pStr = '\0';
         }
         else
         {
             _pStr = new char[strlen(pStr) + ];
             strcpy(_pStr, pStr);
         }
     }
     String(const String& s)
         :_pStr(s._pStr)
     {}
     ~String()
     {
         if (_pStr)
             delete[] _pStr;
         _pStr = NULL;
     }
     String& operator=(const String& s)
     {
         if (this != &s)
         {
             _pStr = s._pStr;
         }
         return *this;
     }
 private:
     char *_pStr;
 };/*存在问题：1.同一对象析构多次，程序崩溃；2.内存泄漏*/

int main()
  {
  String s1;
  String s2 = "hello word";
  String s3(s2);
  s1[0] = '5';
  String s4;
  s4 = s2;
  }

编译时可以轻松通过，但是这段代码是有问题的，运行时程序崩溃

这是String类的一个经典反例，下面来具体分析一下这段代码存在的问题：

   当类里面有指针对象时， 拷贝构造和赋值运算符重载只进行值拷贝(浅拷贝) ， 两个对象指向同一块内 存， 对象销毁时该空间被释放了 两次， 因此程序崩溃！下面的 s1[0] = '5';  String s4;  s3 = s4; 也存在类似问题

  

存在问题：1.同一对象析构多次，程序崩溃；2.内存泄漏

那么该如何解决出现的问题呐？这需要我们自己重新定义相关类的成员函数，下面将介绍多种深拷贝方法以解决此问题

我们已经知道了浅拷贝存在的问题，即多次析构同一空间。这个问题是类的成员函数引起的，就是前面浅拷贝里模拟实现的编译器自动合成的函数，确切的说，浅拷贝里的问题是由隐式拷贝构造函数和隐士赋值运算符引起的。

拷贝构造函数用于将一个对象拷贝到新创建的对象中。也就是说，他用于初始化过程中，最常见的是将新对象显式地初始化为现有的对象。每当程序生成了副本对象时，编译器也将使用拷贝构造函数。默认的拷贝构造函数逐个的拷贝非静态成员（即浅拷贝），拷贝的是成员的值。（由于按值传递对象将调用拷贝构造函数，因此应该按引用传递对象。这样可以节省调用构造函数的时间以及存储新对象的空间。）

默认的赋值运算符是通过自动为类重载赋值运算符实现的。它的原型是：Class_name & Class_name ::operator=(const Class_name &);它接受并返回一个指向类对象的引用。将已有的对象赋给另一个对象时，将使用重载的赋值运算符（初始化对象时不一定会使用）。如：String s1=s2;也可能分两步来处理这条语句：使用拷贝构造函数创建一个临时对像，然后通过赋值将临时对象的值复制到新对象中。即初始化总会调用拷贝构造函数，而使用“=“时也可能调用赋值运算符。

2.解决方法：深度复制（deep copy）。定义一个显式拷贝构造函数，拷贝字符串并将副本的地址赋给str成员，而不仅仅是拷贝字符串地址。这样每个对象都有自己的字符串，而不是引用另一个对象的字付串。则调用析构函数都将释放不同的字符串而不是去释放已经释放的字符串。代码如下：

1     String(const String& s)
2         :_pStr(new char[strlen(s._pStr)] + 1)
3     {
4         if (this != &s)
5         {
6             strcpy(_pStr, s._pStr);
7         }
8     }

必须定义拷贝构造函数的原因在于，一些类成员是使用new初始化的、指向数据的指针，而不是数据本身。

总结：如果类中包含了使用new初始化的指针成员，应当定义一个拷贝构造函数，以拷贝指向的数据，而不是指针；浅拷贝仅浅浅的拷贝指针信息，而不会深入”挖掘“以拷贝指针引用的结构。

默认赋值运算符存在的问题与默认拷贝构造函数相同：数据受损。试图删除已经删除的数据导致的结果是不正确的，因此可能改变内存中的内容，导致程序异常终止。解决方法是提供深度拷贝的赋值运算符定义。

 1     String& operator=(const String& s)
 2     {
 3         if (this != &s)
 4         {
 5             char *temp = new char[strlen(s._pStr) + 1];
 6             strcpy(temp, s._pStr);
 7             delete[] _pStr;
 8             _pStr = temp;
 9         }
10         return *this;
11     }

注意：

•由于目标对象可能引用了以前分配的数据，所以函数应使用delete[]来释放这些数据。

•函数应该避免将对象赋值给本身；否则，给对象重新赋值前，释放内存操作可能删除对象的内容，

•函数返回一个指向调用对象的引用。

按照之前讨论的方法重新定义赋值运算符和拷贝构造函数，还有更简洁的方法如下：

 1     String(const String& s)
 2         :_pStr(NULL)     //
 3     {
 4         String strtemp(s._pStr);
 5         std::swap(_pStr, strtemp._pStr);
 6     }
 7
 8     String& operator=(const String& s)
 9     {
10         if (this != &s)
11         {
12             String strtemp(s);
13             std::swap(_pStr, strtemp._pStr);
14         }
15         return *this;
16     }
17
18     String& operator=(String s)
19     {
20         std::swap(_pStr, s._pStr);
21         return *this;
22     }

此外，还有一些深度拷贝的不同方法将在下一篇介绍。