实现简单String类

1、实现String类，关键是重载赋值运算符的解法，下面先分析赋值运算符函数的关键点：

1）是否把返回值的类型声明为该类型的引用；

2）是否把传入的参数的类型声明为常量引用，若传入的参数不是引用而是实例，则从形参到实参会调用一次复制构造函数，而声明为const，是保证不改变实参；

3）在赋值新值之前，是否释放实例自身之前已有的内存，否则容易出现内存泄漏；

4）是否判断传入的参数和当前实例是不是同一个实例，是的话，不用赋值，直接返回；若事先不判断就进行赋值，那么在释放实例自身的内存的时候就会出现问题：一旦释放了实例自身内存，传入参数因为是同一个实例，参数的内存也同时释放了，因此再也找不到需要赋值的内容。

2、简单String类代码如下：

<pre name="code" class="cpp">#include <iostream>
#include <cstring>

using namespace std;
class MyString
{
public:
	MyString(char* pData = NULL);
	~MyString();
	MyString(const MyString& str);
	MyString& operator=(const MyString& str);
	inline friend ostream& operator<<(ostream& os, MyString str)
	{
		os << str.m_pData;
		return os;
	}
private:
	char* m_pData;
};

MyString::MyString(char* pData)
{
	if(pData == NULL)
	{
		m_pData = NULL;
	}
	else
	{
		int length = strlen(pData) + 1;
		m_pData = new char[length];
		strncpy(m_pData, pData, length);
	}
}

MyString::~MyString()
{
	if(m_pData != NULL)
	{
		delete []m_pData;
	}
}

MyString::MyString(const MyString& str)
{
	int length = strlen(str.m_pData) + 1;
	m_pData = new char[length];
	if(m_pData != NULL)
		strncpy(m_pData, str.m_pData, length);
}
//常用解法 
MyString& MyString::operator = (const MyString& str)
{
	if(this == &str)
		return *this;
	delete []m_pData;
	m_pData = NULL;
	int length = strlen(str.m_pData) + 1;
	m_pData = new char[length];
	if(m_pData != NULL)
		strncpy(m_pData, str.m_pData, length);
	
	return *this;
}

在上面的重载赋值运算符函数中，有些瑕疵，在函数中，在分配内存之前先用delete释放了实例m_pData的内存，假如此时内存不足导致new抛出异常，m_pData将是一个空指针，容易导致程序崩溃。也就是说一旦在赋值运算符函数内部抛出一个异常，MyString的实例不再保持有效状态，违背了异常安全性原则。

要想保证异常安全，有两种方法，一个简单方法是先用new分配新内存再用delete释放已有的内容，这样只在分配内存成功之后再释放原来的内存，也即当分配内存失败时，MyString实例还是有效的。还有一个更好的方法是先创建一个临时对象，再交换临时对象和原来的对象。代码如下：

MyString& MyString::operator = (const MyString& str)
{
	if(this != &str)
	{
		MyString tmpStr(str);
		char* pTmp = tmpStr.m_pData;
		tmpStr.m_pData = m_pData;
		m_pData = pTmp;
	} 
	return *this;
}

在上面函数中，临时对象tmpStr使用赋值对象初始化，接着把tmpStr.m_pData和实例对象本身的m_pData交换，tmpStr是个局部对象，出了作用域就会被析构，内存也会被释放，而释放的内存就是交换前对象本身的m_pData。且函数中，是在MyString的构造函数中new分配内存，若出现bad_alloc异常，此时还没修改原来实例的内存，原来实例还是有效的，这就保证了异常安全性。