类中构造函数、析构函数与赋值函数的重写

class String

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


private:
    char *m_data; // 用于保存字符串
};


// String 的析构函数
String::~String(void)
{
if (m_data)
{
   delete[] m_data; //由于m_data是内部数据类型，可以写成 delete m_data;
   m_data = NULL;
}
}


//String的普通构造函数
String::String(const char *str)
{
if (NULL == str)// 若能加 NULL 判断则更好
{
   m_data = new char[1]; 
   m_data[0] = '\0';
}
else
{
   int length = strlen(str);


   m_data = new char[length+1]; //+1是为'\0'分配一个字符
            if (NULL != m_data)
            {
                strcpy(m_data, str);
            }
   else {
                //异常处理
            }
}
}


// 拷贝构造函数
String::String(const String &other)
{
int length = strlen(other.m_data);//由于other是condt类型，因此不用判断是否为NULL


m_data = new char[length+1];  //+1是为'\0'分配一个字符
        if (NULL != m_data)
        {
            strcpy(m_data, other.m_data);
        }
else {
            //异常处理
        }
}




// 赋值函数
String & String::operate=(const String &other)
{
if (this == &other) //(1)检查自赋值
{
   return *this;
}


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

//(3)分配新的内存资源，并复制内容
int length = strlen(other.m_data);
m_data = new char[length+1]; //+1是为'\0'分配一个字符
        if (NULL == m_data)
        {
            ...//异常处理
            return *this;
        }
        else
        {
            strcpy(m_data, other.m_data);
        }


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