剑指offer面试题：如下为类型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& 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.

请按任意键继续. . .