类string的构造函数、析构函数和赋值函数

class String
{
  public:
    String(const char *str = NULL);           //普通构造函数
    String(const String &other);              //拷贝构造函数
    ~ String(void);                           //析构函数
    String & operator =(const String &other); //赋值函数
  private:
    char *m_data;

};

//析构函数

String::~String(void)
{
   delete []m_data;     //由于m_data是内部数据类型，也可以写成 delete m_data;
}

//普通构造函数
String::String(const char *str)
{
    if(str==NULL)  //指针可能是空的
    {
         m_data = new char[1];
         *m_data = ‘\0’;
    }
    else
    {
         int length = strlen(str);  
         m_data = new char[length+1];
         strcpy(m_data, str);
    }
}

//拷贝构造函数
String::String(const String &other)
{
      int length = strlen(other.m_data);//引用不可能是空，因此不用判断
      m_data = new char[length+1];
      strcpy(m_data, other.m_data);
}

//赋值函数1
String & String::operator =(const String &other)
{
    //(1)检查自赋值，若不检查，第二部会删除掉自己的数据
     if(this == &other)
        return *this;

    //(2)释放原有的内存资源
     delete [] m_data;

    //(3)分配新的内存资源，并复制内容
     int length = strlen(other.m_data);
     m_data = new char[length+1]; // 若能加 NULL 判断则更好
     strcpy(m_data, other.m_data);

    //(4)返回本对象的引用
     return *this;
}

//赋值函数2

String & String::operator =(const String &other)
{
    //(1)用临时指针

     char *tmp = new char[strlen(other.m_data)+1];
     strcpy(tmp, other.m_data);

    //(2)释放原有的内存资源
     delete []m_data;

    //(3)指向临时指针
     m_data = tmp;    

    //(4)返回本对象的引用
     return *this;
}

====================================

赋值运算符(operator=)和拷贝构造函数:A(A& a){}都是用已存在A的对象来创建另一个对象B。不同之处在于：赋值运算符处理两个已有对象，即赋值前B应该是存在的；拷贝构造函数是生成一个全新的对象，即调用复制构造函数之前B不存在。  
       CTemp B(A);      //拷贝构造函数，C++风格的初始化
       CTemp B=A;       //仍然是拷贝构造函数，不过这种风格只是为了与C兼容，与上面的效果一样
       在这之前B不存在，或者说还未构造好。

       CTemp B;
       B = A;           //赋值运算符
       在这之前B已经通过默认构造函数构造完成。