为类型CMyString的声明，请为该类型添加赋值运算符函数

转自
题目：如下为类型CMyString的声明，请为该类型添加赋值运算符函数。

class CMyString
{
public:
CMyString(char* pData = NULL);
CMyString(const CMyString& str);
~CMyString(void);
private:
char* pData;
};

分析：赋值运算符要注意以下四点：

1. 把返回值的类型声明为该类型的引用，并在函数结束前返回实例自身的引用（即*this）。只有返回一个引用，才可以连续赋值。否则如果函数的返回值是void，应用该赋值运算符将不能做连续赋值。假设有3个CMyString的对象：str1、str2、str3，在程序中语句str1=str2=str3将不能通过编译。。
2. 把传入的参数的类型声明为常量引用。如果传入的参数不是引用而是实例，那么从形参到实参会调用一次复制构造函数。把参数声明为引用可以避免这样的无谓消耗，能提高代码的效率。同时，我们在赋值运算符函数内不会改变传入的实例的状态，因此应该为传入的引用参数加上const关键字。
3. 释放实例自身已有的内存,如果忘记在分配新内存之前释放自身已有的空间，程序将出现内存泄漏。
4. 判断传入的参数和当前的实例(*this)是否是同一个实例。若是，则不进行赋值操作，直接返回；否则在释放实例自身的内存的时候就会导致严重的问题：当*this和传入的参数是同一个实例时，一旦释放了自身的内存，传入的参数内存也同时被释放了，因此再也找不到需要赋值的内容了。

经典解法代码如下：

CMyString& CMyString::operator = (const CMyString& str)  
{  
    if (this == &str)  
    {   
        return *this;  
    }  

    delete[] m_pData;  
    m_pData = NULL;  
    m_pData = new char[strlen(str.m_pData) + 1];  
    strcpy(m_pData, str.m_pData);  

    return *this;  

}  

考虑更多的安全性问题：
上面代码中的new部分要是内存不足则会抛出异常，此时实例的m_pData已经被删除，而新的内存又没申请到，就会导致数据丢失，所以我们可以采用下面的两种代码来保证代码的安全性。
代码一：先用new分配新内容，再用delete释放已有的内容，这样即使当

CMyString& CMyString::operator = (const CMyString &str)  
{  
    if (this == &str)  
    {  
        return *this;  
    }  

    char * pTemp = new char[strlen(str.m_pData) + 1];  
    delete[] m_pData;  
    m_pData = NULL;  
    m_pData = pTemp;  
    strcpy(m_pData, str.m_pData);  
    return *this;  
}  

代码二：先创建一个临时实例，再交换临时实例和原来的实例。

CMyString& CMyString::operator=(const CMyString &str)  
{  
    if (this != &str)  
    {  
        CMyString strTemp(str);  
        char* pTemp = strTemp.m_pData;  
        strTemp.m_pData = m_pData;  
        m_pData = pTemp;  
    }  

    return *this;  
}  

完整代码及测试用例实现：

#define  _CRT_SECURE_NO_WARNINGS  

#include<iostream>  
using namespace std;  
#include <string>  

class CMyString  
{  
public:  
    CMyString(char* pData = NULL);  
    CMyString(const CMyString& str);  
    ~CMyString(void);  
    CMyString& operator = (const CMyString& str);  
    void Print();  

private:  
    char* m_pData;  
};  

CMyString::CMyString(char *pData)  
{  
    if (pData == NULL)  
    {  
        m_pData = new char[1];  
        m_pData[0] = '\0';  
    }  
    else  
    {  
        int length = strlen(pData);  
        m_pData = new char[length + 1];  
        strcpy(m_pData, pData);  
    }  

}  

CMyString::CMyString(const CMyString &str)  
{  
    int length = strlen(str.m_pData);  
    m_pData = new char[length + 1];  
    strcpy(m_pData, str.m_pData);  
}  

CMyString::~CMyString()  
{  
    delete[] m_pData;  
}  

// 方法一：经典解法，未考虑内存不足导致new char抛出异常  
CMyString& CMyString::operator = (const CMyString& str)  
{  
    if (this == &str)  
    {   
        return *this;  
    }  

    delete[] m_pData;  
    m_pData = NULL;  
    m_pData = new char[strlen(str.m_pData) + 1];  
    strcpy(m_pData, str.m_pData);  

    return *this;  

}  

// 方法二：考虑异常安全性，分配内容成功后再释放原来的内容  
//CMyString& CMyString::operator = (const CMyString &str)  
//{  
//  if (this == &str)  
//  {  
//      return *this;  
//  }  
//  
//  char * pTemp = new char[strlen(str.m_pData) + 1];  
//  delete[] m_pData;  
//  m_pData = NULL;  
//  m_pData = pTemp;  
//  strcpy(m_pData, str.m_pData);  
//  
//  return *this;  
//}  

// 方法三：先创建一个临时实例，再交换临时实例和原来的实例  
//CMyString& CMyString::operator=(const CMyString &str)  
//{  
//  if (this != &str)  
//  {  
//      CMyString strTemp(str);  
//      char* pTemp = strTemp.m_pData;  
//      strTemp.m_pData = m_pData;  
//      m_pData = pTemp;  
//  }  
//  
//  return *this;  
//}  



// 测试代码  

void CMyString::Print()  
{  
    printf("%s", m_pData);  
}  

void Test1()  
{  
    printf("Test1 begins:\n");  

    char* text = "Hello world";  
    CMyString str1(text);  
    CMyString str2;  
    str2 = str1;  

    printf("The expected result is: %s.\n", text);  
    printf("The actual result is: ");  
    str2.Print();  
    printf(".\n");  

}  



// 赋值给自己  
void Test2()  
{  
    printf("Test2 begins:\n");  

    char* text = "Hello world";  
    CMyString str1(text);  
    str1 = str1;  
    printf("The expected result is: %s.\n", text);  
    printf("The actual result is: ");  
    str1.Print();  
    printf(".\n");  

}  

// 连续赋值  
void Test3()  
{  
    printf("Test3 begins:\n");  

    char* text = "Hello world";  
    CMyString str1(text);  
    CMyString str2, str3;  
    str3 = str2 = str1;  

    printf("The expected result is: %s.\n", text);  

    printf("The actual result is: ");  
    str2.Print();  
    printf(".\n");  

    printf("The expected result is: %s.\n", text);  
    printf("The actual result is: ");  
    str3.Print();  
    printf(".\n");  

}  

int main(int argc, CMyString* argv[])  
{  
    Test1();  

    Test2();  

    Test3();  
    system("pause");  
    return 0;  

}  

运行结果：

Test1 begins:
The expected result is: Hello world.
The actual result is: Hello world.
Test2 begins:
The expected result is: Hello world.
The actual result is: Hello world.
Test3 begins:
The expected result is: Hello world.
The actual result is: Hello world.
The expected result is: Hello world.
The actual result is: Hello world.
请按任意键继续. . .