深度复制

      先从一个问题开始探讨:编写一个类，其中有一个动态的字符数组存储字符串,还有一个整型成员存储字符串的长度,并重载<<输出字符串的内容。

      显然，类的定义应该是:

      class Test

{

private:

            char *str;              //字符串的长度是不固定的，需要使用字符指针

            int len;

public:

            Test(const char *s)

            {

                 len = strlen(s);

                 str = new char[len + 1];   //分配足够的内存

                 strcpy(this->str, s);

            }

            Test();

            ~Test()

            {

                 delete [] this->str;

            }

            friend std::ostream &operator<<(std::ostream & os, const Test & st);

};

 

std::ostream & operator<<(std::ostream & os, constTest & st)

{

      os<< st.str;

      returnos;

}

      类的调用例子:

int main()

{

      Test str("helloworld");

      std::cout<<str;

      std::cin.get();

      return 0;

}

      上述程序将字符串常量赋给类的字符串，将自动调用参数为常量字符串的构造函数，在构造函数中分配内存，并将指针指向那块内容，最后在析构的时候释放内容，是没有问题的.

      但是如果调用的是复制构造函数呐？如下代码产生了错误，就是因为没有使用深度复制的原因.

      int main()

{

            Test str1("hello world");

            Test str2 = str1;

            std::cout<<str2;

            std::cin.get();

            return 0;

}

      乍看之下没有问题，将str1指向的内容拷贝到str2指向的内存，两者的数据类型一样的情况下会完美的复制非静态成员.所以std::cout<<str2;会正常调用重载输出str2.str, 而str2.str又会指向str1.str分配的内存，字符串会正常的输出。问题在哪呢？问题在于两个不相关的对象共有同一块内存!

      指针指向的内容是不会存储在类中的，在复制类(调用默认复制函数)的时候，复制的仅仅是指针的值，使两个类指向同一块内容，这将会导致致命的问题.在析构str1时，会释放str1.str指向的内容，这个时候str2.str指向字符串也同时消失，此时任何调用str2.str指向的值将输出不可预期的结果，而在析构str2的时候必定会导致错误，因为不能释放已经释放的内存.

      要想解决这个问题就要放弃浅复制(仅复制指针)，使用深复制（复制指针指向的内容），是两个对象完全对立，互不干扰。需要显示定义复制构造函数

      Test(const Test&t)

      {

           this->len =t.len;

           this->str =new char[len + 1];     //指针指向又一块内存

           strcpy(str,t.str);

      }

      这样即使释放了str1.str，str2.str也不会受到影响.

      指针bug绝大部分的问题都来源于把指针误当做实际的内容，应该将指针和其指向的内存一起考虑.