类构造、析构、赋值函数示例

平常自己写一些例程的时候，一般想的、写的都比较简单，但是在实际工程应用的时候应该尽可能的将程序写的优美、高效。

class String
{
public:
	String(const char* str = NULL);
	String(const String& other);
	~String(void);
	String& operator=(const String& other);
private:
	char* m_data;
};

String::String(const char* str)
{
	if (str == NULL)  //对空字符串申请存放结束字符的内存
	{
		m_data = new char(1);
		*m_data = '\0';
	}
	else
	{
		int length = strlen(str);       //strlen 不包括结束字符
		m_data = new char(length + 1);
		strcpy(m_data, str);
	}
}

String::String(const String& other)     //拷贝构造，输入参数为const类型
{
	int length = strlen(other.m_data);
	m_data = new char(length + 1);
	strcpy(m_data,other.m_data);
}

String::~String(void)
{
	delete m_data;
	m_data = NULL;
}
/*
1、是否把返回值的类型声明为该类型的引用，并在函数结束前返回实例自身的引用（即* this）。只有返回一个引用，才可以允许连续赋值。否则如果函数的返回值是void，应用该赋值运算符将不能做连续赋值。假设有3个CMyString的对象：str1、str2和str3，在程序中语句str1 = str2 = str3将不能通过编译。
2、是否把传入的参数的类型声明为常量引用。如果传入的参数不是引用而是实例，那么从形参到实参会调用一次复制构造函数。把参数声明为引用可以避免这一无谓消耗，能提高代码的效率。同时，在赋值运算符函数内不会改变传入的实例的状态，因此应该为传入的引用参数加上const关键字。
3、是否释放实例自身已有的内存。如果忘记在分配内存之前释放自身已有的空间，程序将出现内存泄露。
4、是否判断传入的参数和当前的实例（this）是不是同一个实例。如果是同一个，则不进行赋值操作，直接返回。如果事先不判断就进行赋值，那么在释放自身的内存时就会导致严重的问题：当this和传入的参数是同一个实例时，那么一旦释放了自身的内存，传入的参数的内存也同时被释放了，因此找不到需要赋值的内容了。
*/
String& String::operator=(const String& other)  //赋值函数
{
	if (this == &other)  //排除将自己赋值给自己的情况
		return *this;
	delete m_data;   //释放原有内存
	int length = strlen(other.m_data);
	m_data = new char(length + 1);
	strcpy(m_data, other.m_data);
	return *this;   //返回本对象的引用
}

//在前面的函数中，分配内存之前先用了delete释放了实例m_data的内存。如果此时内存不足导致 new char 抛出异常，m_pdata将是一个空指针，这样非常容易导致程序崩溃。
String& String::operator = (const String& str)   //赋值函数 这种形式更加安全
{
	if (this != &str)
	{
		String strTemp(str);
		char* pTemp = strTemp.m_data;
		strTemp.m_data = m_data;
		m_data = pTemp;
	}
	return *this;
}

关于文中赋值运算部分的安全写法，详见剑指offer 赋值运算符函数。