1.赋值运算符函数

2019-11-17 本文已影响0人带带吴腾跃

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

class CMystring
{
public:
    CMystring(char* pData = nullptr);
    CMystring(const CMystring &str);
    ~CMystring(void);
private:
    char* m_pData;
}

首先，题目的意思是让你添加一个赋值运算符函数，什么叫赋值运算符函数呢？其实就是操作符重载，既然是添加赋值运算符，也就是=号，意思就是把=号重载，实现这个类的赋值。

上述类中的三个成员函数：

CMystring(char* pData = nullptr); // 构造函数
CMystring(const CMystring &str); // 拷贝构造函数
~CMystring(void); // 析构函数

运算符重载形式一般如下：

返回值类型 operator 要重载但运算符 (传入的参数)

对这个类进行赋值也就是让它的成员指针m_pData指向一个字符串。

当面试官要求定义一个赋值运算符的时候，一般会关注如下几点：

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

考虑到如上四点，我们的程序如下：

CMystring& CMystring::operator=(const CMystring &str)
{
    if (this == &str)
    {
        return *this;
    }
    else
    {
        delete []m_pData;
        m_pData = nullptr;

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

        return *this;
    }
}

上述代码中我们在分配内存之前先用delete释放了m_pData的内存，如果此时内存不足导致new char抛出异常，则m_pData将是一个空指针，这样非常容易导致程序崩溃。也就是说，一旦在赋值运算符函数内部欧抛出一个异常，CMystring的实例不再保持有效的状态，这就违背了异常安全性的原则。
要想在赋值运算符函数中实现异常安全性，我们有两种办法。一种是先用new分配新内容，再用delete释放已有内容。这样只在分配内容成功之后再释放原来的内容，也就是当分配内存失败时我们能确保CMystring实例不会被修改。
代码如下：

CMystring& CMystring::operator=(const CMystring& str)
{
    if (this != &str)
    {
        //先分配内存
        char *pTemp = new char[strlen(str.m_pData)+1];
        strcpy(pTemp,str.m_pData);
        //分配成功后释放原来的内存
        delete [] m_pData;
        m_pData = nullptr;
        m_pData = pTemp;
    }
    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;
}

或者写成这样：

CMyString& CMyString::operator=(const CMyString& str)
{
    if (this != &other)
    {
        CMyString temp(str);
        swap(temp.m_pData, m_pData);        
    }
    return *this;
}

在新的代码中，我们在CMystring的构造函数里用new 分配内存，即使分配失败抛出异常，但我们还没有修改原来的实例，所以实例还是有效的，这就保证了异常安全性。
注：为什么要写成swap(temp.m_Data,m_pData)?不直接写成m_pData = temp.m_pData?
因为你赋值之后你需要释放掉指针原来指向的内存，所以交换之后，temp就指向实例原来指向的内存块，由于temp是个局部变量，所以if执行完毕后temp会调用自身的析构函数释放内存，也就是释放掉了原来实例所指向的内存！

1.赋值运算符函数

猜你喜欢

热点阅读