如果类内部涉及到动态内存分配，通常情况下需要实施深拷贝

    如果要共享内存要另当别论，如果要共享内存，最后一个对象销毁的时候才调用析构函数，只析构一次。
 
    系统提供的默认拷贝函数实施的是浅拷贝
 
    深拷贝，是自己定义的拷贝构造函数决定如何复制。
    
    浅拷贝就是位拷贝，如果类有个指针成员，只复制指针，并不复制指针所指向的内存
 
    如果实行位拷贝，也就是把对象里的值完全复制给另一个对象，如A=B。这时，如果B中有一个成员变量指针已经申请了内存，那A中的那个成员变量也指向同一块内存。这就出现了问题：当B把内存释放了（如：析构），这时A内的指针就是野指针了，出现运行错误。
    
    如果一个类拥有资源，当这个类的对象发生复制过程的时候，资源重新分配，这个过程就是深拷贝，反之，没有重新分配资源，就是浅拷贝。
 
 下面用代码示例进行说明：
String.h
  
 
  
  1. //String.h 
  2.  
  3. # ifndef _STRING_H_ 
  4. # define _STRING_H_ 
  5.  
  6. class String 
  7. { 
  8. public: 
  9.     String(char* str = " "); 
  10.     ~String(); 
  11.  
  12.     String(const String& other); 
  13.  
  14.     String& operator = (const String& other); 
  15.  
  16.     void Display(); 
  17.  
  18. private: 
  19.     char* AllocAndCopy(char* str); 
  20.     char* str_; 
  21.     //如果类内部涉及到动态内存分配 
  22.     //通常情况下需要实施深拷贝 
  23.     //如果要共享内存要另当别论 
  24.     //如果要共享内存，最后一个对象销毁的时候才 
  25.     //调用析构函数，只析构一次 
  26.  
  27.  
  28. }; 
  29. # endif // 
 
  

     String.cpp 
  
 
  

      
  
 
  
 
  
  1. //String.cpp 
  2.  
  3. # include "String.h" 
  4. //# include <string.h> 
  5. # include <cstring> 
  6. # include <iostream> 
  7. using namespace std; 
  8.  
  9. //实施浅拷贝,系统默认的构造函数 
  10. String::String(char* str) 
  11. { 
  12.     /*int len = strlen(str) + 1; 
  13.     str_ = new char[len]; 
  14.     memset(str_,0,len); 
  15.     strcpy(str_, str);*/ 
  16.     //以上由AllocAndCopy(str_);代替 
  17.     str_ = AllocAndCopy(str);//此为浅拷贝 
  18.  
  19. } 
  20. //实施深拷贝 
  21. String::String(const String& other) 
  22. { 
  23.     /*int len = strlen(other.str_)+1; 
  24.     str_ = new char[len]; 
  25.     memset(str_,0,len); 
  26.     strcpy(str_, other.str_);*/ 
  27.  
  28.     //以上由AllocAndCopy(char *  str_);代替 
  29.     str_ = AllocAndCopy(other.str_); //此为深拷贝 
  30. } 
  31.  
  32. char* String::AllocAndCopy(char* str) 
  33. { 
  34.     int len = strlen(str) + 1; 
  35.     char * tmp = new char[len]; 
  36.     memset(tmp, 0,len); 
  37.     strcpy(tmp, str); 
  38.          
  39.     return tmp; 
  40.  
  41. } 
  42.  
  43. String& String::operator=(const String &other) 
  44. { 
  45.     if(this == &other) 
  46.     { 
  47.         return *this; 
  48.     } 
  49.     //首先要销毁空间，因为它原来就存在了 
  50.     delete[] str_; 
  51.     str_ = AllocAndCopy(other.str_); 
  52.      
  53.     return *this; 
  54. } 
  55. String::~String() 
  56. { 
  57.     delete[] str_; 
  58. } 
  59.  
  60. void String::Display() 
  61. { 
  62.     cout << "Str = " << str_  << endl; 
  63. } 
 
  

     main.cpp 
  
 
  

      
  
 
  
 
  
  1. # include "String.h" 
  2.  
  3. int main(void) 
  4. { 
  5.     String s1("AAA"); 
  6.     //String s2("BBB"); 
  7.  
  8.     s1.Display(); 
  9.     String s2 = s1;//调用默认的拷贝构造函数,如果有深拷贝调用深拷贝，如果没有深拷贝，则在运行时出错 
  10.                   //系统提供的默认拷贝函数实施的是浅拷贝 
  11.     //等价s2.str_ = s1.str_ ; 指向同一块内存，没有分配自己的内存 
  12.     //当两个对象生成周期结束的时候，被释放了两个同一个内存空间 
  13.     //提供一个自己的拷贝函数 
  14.     s2.Display(); 
  15.  
  16.     String s3; 
  17.     s3.Display(); 
  18.     //s3 = s2; error 本质原因调用了等号运算符， 
  19.     //系统提供的默认=运算符实施的也是浅拷贝 
  20.     //s3.str_ = s2.str; 逐个会员赋值 
  21.     //s3 = s2; 
  22.     //s3.operator = (s2); 
  23.  
  24.     return 0;    
  25. } 
  26. // 
  27. //赋值操作，=运算符的重载 
  28.  
  29.  
  30. //独一无二的对象禁止拷贝 
 
  

      
  
 
  

     运行结果：