01_AssignmentOperator（赋值运算符）

01_AssignmentOperator

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

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

	CMyString& operator = (const CMyString& str);

	void Print();

private:
	char* m_pData;
};

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

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

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

考虑到需要连续赋值的情况，因为我们需要赋值运算符返回值类型为引用，需要在函数结束前返回自身的引用（即*this）,要考虑实例释放自身内存以及自赋值的情况。

下面是一种没有考虑异常安全部的写法

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

    delete []m_pData;
    m_pData = nullptr;

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

    return *this;
}

该函数在分配内存之前释放了m_pData的内存，而内存不足会导致new char抛出异常，m_pData将会是空指针，这样容易导致程序崩溃。

下面是一种考虑了异常安全的写法，运用了copy and swap 的技巧

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

	return *this;
}

这里先创建了一个临时strTemp,接着将strTemp.m_pData和m_pData进行了交换。由于strTemp是一个局部变量，运行到if的外面时也就出了该变量的作用域，就会自动调用strTemp析构函数，将strTemp.m_pData所指向的内存释放掉，也就是之前m_pData所指的内存。

完整代码

#include<cstring>
#include<cstdio>

using namespace std;

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

	CMyString& operator = (const CMyString& str);

	void Print();

private:
	char* m_pData;
};

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

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

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

CMyString& CMyString::operator = (const CMyString& str)
{
	if (&str != this)
	{
		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");

    const  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");

	const 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");

	const 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, char* argv[])
{
	Test1();
	Test2();
	Test3();

	return 0;
}