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异常,此时还没修改原来实例的内存,原来实例还是有效的,这就保证了异常安全性。