（剑指Offer)面试题1：赋值运算符函数

题目：

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

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

private:
    char *m_pdata;
};

 

思路：

赋值运算符函数，注意四点：

1、是否将返回值的类型声明为该类型的引用，并在函数结束前返回实例自身的引用，即*this。只有返回一个引用，才可以允许连续赋值。

2、是否把传入参数的类型声明为常量引用。如果传入的参数不是引用而是实例，那么从形参到实参会调用一次复制构造函数，把参数声明为引用可以避免这样的无谓消耗，能提高代码的效率。同时，在赋值运算符函数中不会改变传入的实例的状态，因此应该为传入的引用参数加上const关键字。

3、是否释放实例自身已有的内存，如果忘记在分配新内存之前释放自身已有的空间，程序将出现内存泄露。

4、是否判断传入的参数和当前实例*this是不是同一个实例。如果是同一个，则不进行赋值操作，直接返回。

5、注意浅拷贝和深拷贝

更多考虑：异常安全性等。

代码：

 

#include <iostream>
#include <string.h>

using namespace std;

class CMyString{
public:
    CMyString(const char* pData=NULL);
    CMyString(const CMyString& str);
    CMyString& operator=(const CMyString& str);
    char* getData(){return this->m_pdata;};
    ~CMyString(void);

private:
    char *m_pdata;
};


/*
// shallow copy
CMyString::CMyString(char* pData){
    m_pdata=pData;
}

CMyString::CMyString(const CMyString& str){
    *this=str;
}
*/

// deep copy
CMyString::CMyString(const char* str){
    if(str==NULL){
        m_pdata=new char[1];
        m_pdata[0]='\0';
    }
    else{
        m_pdata=new char[strlen(str)+1];
        strcpy(m_pdata,str);
    }
}

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

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

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;
}

int main()
{
    char a[]="hello";
    CMyString str(a);
    CMyString str1(str);
    CMyString str2;
    CMyString str3;
    str3=str2=str;
    cout << str.getData()<< endl;
    cout << str1.getData()<< endl;
    cout << str2.getData()<< endl;
    cout << str3.getData()<< endl;
    return 0;
}

运行结果：