类String的构造函数

class String
{
   public:

        //注意该构造函数原型

         //也可以设为String(const char *str="");(记为原型2)

       //即把默认实参设为空字符串  

  String(const char *str=NULL); //原型1默认实参为空指针                                                      
          String(const String &other);
          ~String(void);
          String& operator=(const String &other);
   private:
          char *m_data;
};


//String 类析构函数的实现
String::~String()
{
    delete [] m_data;
}
String::String(const char *str)
{
    if (str==NULL) //(注意) 如果采用原型2，则这几句语句可以省略
     {
        m_data=new char[1]; //不能写成new char;因为new 与 new[]是两个不同的运算符

                                       //析构中统一为delete[],故构造中应该统一用new[]
        *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);//即使other.m_data指向空字符串，仍然可以使用strcpy函数!
}
String& String::operator =(const String &other)
{
    if (this==&other)
        return *this; 
 
    delete [] m_data;

    int length=strlen(other.m_data);//不能使用sizeof(other.m_data),因为它永远是一个机器字的长度
    m_data=new char[length+1];
    strcpy(m_data,other.m_data);

    return *this; 
}

 

//赋值函数写得不好，最好改为

String& String::operator =(const String &other)
{
    if(this != &other)

  {

    int length=strlen(other.m_data);

try{
    char *p =new char[length+1]; //并不能保证总会申请成功，故先不释放原内存

   }

catch(bac_alloc &ex)

{  ex.what();

    exit(1);

}
    strcpy(p,other.m_data);

 delete [] m_data; //此时必须释放原内存，否则就没有机会释放了

  m_data = p; //让m_data指向新的成功申请的内存

    return *this; 
}