【剑指offer】01.赋值运算符函数

题目：为类型添加赋值运算符函数。

#include<iostream>
#include<cstring>


using namespace std;

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];          //字符串结尾为'\0'，故比实际长大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;                                     //释放定义的数组空间 
}

CMyString& CMyString::operator =(const CMyString& str)       //返回值类型声明为该类型的引用;常量引用：a.如为实例，形参到实参会调用一次复制构造函数，降低代码效率 b.不改变传入实例状态，加上const关键字 
{
	if(this==&str)                                              //判断传入的参数和当前的实例是不是同一个实例，否则在释放实例自身的内存时会导致严重问题 
	return *this;
else
{
	CMyString strTemp(str);
	
	char* pTemp=strTemp.m_pData;                   //考虑异常安全性，当分配内存失败时能确保CMyString的实例不会被修改，创建一个临时实例，再交换临时实例和原来实例。 
	strTemp.m_pData=m_pData;
	m_pData=pTemp;
}
	
	return *this;                                             //在函数结束时返回自身的引用（*this），才可允许连续赋值（str1=str2=str3)  
	
}

//============================================测试代码=========================================
void CMyString::Print() 
{
	cout<<m_pData<<endl;
}

void Test1()
{
	cout<<"Test1 begins:"<<endl;
	
	char* text="Hello world";
	
	CMyString str1(text);
	CMyString str2;
	CMyString str3(str1);                        //构造函数 CMyString(const CMyString& str);
	str2=str1;                                   //常规赋值 
	
	cout<<"The expected str2 is: "<<text<<endl;
	cout<<"The actual str2 is:";
	str2.Print();
	
	cout<<"The expected str3 is: "<<text<<endl;
	cout<<"The actual str3 is:";
	str3.Print();
}

//赋值给自己
 void Test2()
 {
 	cout<<"Test2 begins:"<<endl;
 	
 	char* text="Hello World";
 	CMyString str1(text);
 	str1=str1;
 	
 	cout<<"The expected result is "<<text<<endl;
 	cout<<"The actual result is:";
 	str1.Print();
 }
 
 //连续赋值
 void Test3()
 {
 	cout<<"Test3 begins:"<<endl;
 	
 	char* text="Hello world";
 	
 	CMyString str1(text);
 	CMyString str2,str3;
 	str3=str2=str1;
	 
	cout<<"The expected str2 is:"<<text<<endl;
	cout<<"The actual str2 is:";
	str2.Print() ;
	
	cout<<"The expected str3 is:"<<text<<endl;
	cout<<"The actual str3 is:";
	str3.Print();
	
	 }
	 
	 int main(int argc,char* argv[])
	 {
	 	Test1();
	 	Test2();
	 	Test3();
	 	
	 	return 0;
	 	
	  } 

 注意点：

1.实现连续赋值（str3=str2=str1)，故赋值函数返回值为实例自身的引用（*this)。

2.自身赋值，增加判断传入参数是否为当前实例（*this)步骤。如果事先不判断就进行赋值，那么在释放实例自身的内存的时候就会导致严重的问题：一旦释放自身的内存，那么传入参数的内存也同时被释放了。

3.把传入参数类型声明为常量引用：a.如果传入参数为实例，那么从形参到实参会调用一次复制构造函数，把参数声明为引用可以避免无谓的消耗；b.为不改变实例，增加const关键字。

4.是否释放自身已有内存，如果忘记，程序将出现内存泄漏。

运行结果：

参考：何海涛《剑指offer》

-------------------------------------------------------------------------------------------------------------------------------------------------------------------------存疑：赋值时为何不能直接使用 m_pData=str.m_pData（实验：当这样使用时给自身赋值运行不成功）