转载：melonstreet

带有指针数据成员的类：记得写三大件（拷贝构造函数、拷贝赋值函数、析构函数）

C++的类可以分为带指针数据成员与不带指针数据成员两类,complex就属于不带指针成员的类。而这里要说的字符串类String，一般的实现会带有一个char *指针。带指针数据成员的类，需要自己实现class三大件：拷贝构造函数、拷贝赋值函数、析构函数。

  

   

    

     

    
    

     

      class String
     
    
   

    

     

    
    

     

      {
     
    
   

    

     

    
    

     

      public:
     
    
   

    

     

    
    

     

      String (const char * cstr = 0);
     
    
   

    

     

    
    

     

      String (const String & str);
     
    
   

    

     

    
    

     

      String & operator = (const String & str);
     
    
   

    

     

    
    

     

      ~String();
     
    
   

    

     

    
    

     

      char * get_c_str() const {return m_data};
     
    
   

    

     

    
    

     

      private:
     
    
   

    

     

    
    

     

      char * m_data;
     
    
   

    

     

    
    

     

      }
     
    
  
 

如果没有写拷贝构造函数、拷贝赋值函数、析构函数，编译器默认会给我们写一套。然而带指针的类不能依赖编译器的默认实现——这涉及到资源的释放、深拷贝与浅拷贝的问题。在实现String类的过程中我们来阐述这些问题。

①析构函数释放动态分配的内存资源

如果class里有指针，多半是需要进行内存动态分配（例如String），析构函数必须负责在对象生命结束时释放掉动态申请来的内存，否则就造成了内存泄露。局部对象在离开函数作用域时，对象析构函数被自动调用，而使用new动态分配的对象，也需要显式的使用delete来删除对象。而delete实际上会调用对象的析构函数，我们必须在析构函数中完成释放指针m_data所申请的内存。下面是一个构造函数，体现了m_data的动态内存申请：

  

   

    

     

    
    

     

      /*String的构造函数*/
     
    
   

    

     

    
    

     

      inline 
     
    
   

    

     

    
    

     

      String ::String (const char *cstr = 0)
     
    
   

    

     

    
    

     

      {
     
    
   

    

     

    
    

     
 if(cstr)
     
    
   

    

     

    
    

     

       {
     
    
   

    

     

    
    

     

        m_data = new char[strlen(cstr)+1]; // 这里，m_data申请了内存
     
    
   

    

     

    
    

     
  strcpy(m_data,cstr);
     
    
   

    

     

    
    

     

       }
     
    
   

    

     

    
    

     
 else
     
    
   

    

     

    
    

     

       {
     
    
   

    

     

    
    

     

        m_data= new char[1];
     
    
   

    

     

    
    

     

        *m_data = '\0';
     
    
   

    

     

    
    

     

       }
     
    
   

    

     

    
    

     

      }
     
    
  
 

这个构造函数以C风格字符串为参数，当执行

String *p = new String ("hello");
 

m_data向系统申请了一块内存存放字符串hello：

析构函数必须负责把这段动态申请来的内存释放掉：

  

   

    

     

    
    

     

      inline 
     
    
   

    

     

    
    

     

      String ::~String()
     
    
   

    

     

    
    

     

      {
     
    
   

    

     

    
    

     
 delete[]m_data;
     
    
   

    

     

    
    

     

      }
     
    
  
 

②拷贝赋值函数与拷贝构造函数负责进行深拷贝

来看看如果使用编译器为String默认生成的拷贝构造函数与赋值操作符会发生什么事情。默认的拷贝构造函数或赋值操作符所做的事情是对类的内存进行按位的拷贝，也称为浅拷贝，它们只是把对象内存上的每一个bit复制到另一个对象上去，在String中就只是复制了指针，而不复制指针所指内容。现在有两个String对象：

  

   

    

     

    
    

     

      String a("Hello");
     
    
   

    

     

    
    

     

      String b("World");
     
    
  
 

a、b在内存上如图所示：

如果此时执行

b = a;
 

浅拷贝体现为：

存储World\0的内存块没有指针所指向，已经成了一块无法利用内存，从而发生了内存泄露。不止如此，如果此时对象a被删除，使用我们上面所写的析构函数，存储Hello\0的内存块就被释放调用，此时b.m_data成了一个野指针。来看看我们自己实现的构造函数是如何解决这个问题的，它复制的是指针所指的内存内容，这称为深拷贝

  

   

    

     

    
    

     

      /*拷贝赋值函数*/
     
    
   

    

     

    
    

     

      inline String &String ::operator= (const String & str)
     
    
   

    

     

    
    

     

      {
     
    
   

    

     

    
    

     
    if(this == &str)           //①
     
    
   

    

     

    
    

     
        return *this;
     
    
   

    

     

    
    

     
    delete[] m_data;        //②
     
    
   

    

     

    
    

     

          m_data = new char[strlen(str.m_data)+1];        //③
     
    
   

    

     

    
    

     
    strcpy(m_data,str.m_data);            //④
     
    
   

    

     

    
    

     
    return *this
     
    
   

    

     

    
    

     

      }
     
    
  
 

这是拷贝赋值函数的经典实现，要点在于:
① 处理自我赋值，如果不存在自我赋值问题，继续下列步骤：
② 释放自身已经申请的内存
③ 申请一块大小与目标字符串一样大的内存
④ 进行字符串的拷贝

对于a = b,②③④过程如下：

同样的，复制构造函数也是一个深拷贝的过程：

  

   

    

     

    
    

     

      inline String ::String(const String & str )
     
    
   

    

     

    
    

     

      {
     
    
   

    

     

    
    

     

          m_data = new char[ strlen (str) +1];
     
    
   

    

     

    
    

     
    strcpy(m_data,str.m_data);
     
    
   

    

     

    
    

     

      }
     
    
  
 

另外，一定要在operator = 中检查是否self assignment 假设这时候确实执行了对象的自我赋值，左右pointers指向同一个内存块，前面的步骤②delete掉该内存块造成下面的结果。当企图对rhs的内存进行访问是，结果是未定义的。

文章来源: panda1234lee.blog.csdn.net，作者：panda1234lee，版权归原作者所有，如需转载，请联系作者。

原文链接：panda1234lee.blog.csdn.net/article/details/51794429