面试题1

面试题1：赋值运算符

题目：如下为类型CMyString的声明，请为该类型添加赋值运算符函数。
class CMyString
{
public:
CMyString(char *pData=NULL);//构造函数
CMyString(const CMyString& str);//拷贝构造函数
~CMyString();//析构函数
private:
char* m_pData;//数据域，字符指针
};

介绍重载赋值

　　重载操作符是一些函数，其名字为关键字operator后紧跟需要重载的运算符，比如"operator="表示需要重载"="。像任何其他函数一样，操作符函数有一个返回值和一个形参表。形参表必须具有与该操作符操作数数目相同的形参，但是如果操作符是一个成员函数，它的第一个操作数隐式绑定到this指针，因此形参表中的参数会减少一个。因为赋值运算符必须是类的成员函数，所以this绑定到左操作数的指针。因此，赋值操作符只接受一个形参，且该形参是同一类型的对象，右操作数一般作为const引用传递，跟拷贝构造函数相同。

　　赋值操作符的返回类型应该与内置类型赋值运算的返回类型相同，内置类型的赋值运算返回对左操作数的引用，因此赋值操作符也返回对同一类类型的引用。赋值必须返回对*this的引用，也就是左操作数的引用。一般而言，赋值操作符与复合赋值操作符应返回左操作数的引用。

　　从上述基础知识我们知道了重载赋值操作符是一个类的成员函数，这个函数的返回类型是左操作数的引用，也就是*this，并且这个函数的参数是一个同类型的常引用变量。通过上述知识我们可以确定重载操作符函数为

写代码是应该注意：

1.是否把返回值的类型声明为该类型的引用，并在函数结束前返回实例自身*this。

2.是否把传入的参数类型声明为常量引用。如果传入的参数不是引用而是实例，那么从形参到实参会调用一次复制构造函数。

3.是否释放实力自身的内存。

4.是否判断传入的参数和当前实例是不是同一个实例。

完整代码：

#include<iostream>
#include<stdlib.h>
#include<string.h>
using namespace std;

class Mystring
{
public:
	Mystring(char *data=NULL);
	Mystring(const Mystring& str);
	~Mystring();
	Mystring& operator=(const Mystring& str);
	void Print();
private:
	char* _data;
};
Mystring::Mystring(char *data)
{
   if(data==NULL)
   {
	   _data=new char[1];
	   _data[0]='\0';
   }
   else
   {
	   int len=strlen(data);
	   _data=new char[len+1];
	   strcpy(_data,data);
   }
}

Mystring::~Mystring()
{
	delete[] _data;
}
Mystring::Mystring(const Mystring& str)
{
	int len=strlen(str._data);
	_data=new char[len+1];
	strcpy(_data,str._data);
}
Mystring& Mystring::operator=(const Mystring &str)
{
	if(this==&str)
		return *this;
	
	delete[] _data;
	_data=NULL;
	
	int len=strlen(str._data);
	_data=new char[len+1];
	strcpy(_data,str._data);
}

void Mystring:: Print()
{ 
	cout<<_data<<endl;
}
int main()
{
	char* s="hello world!";
	Mystring str1(s);
	Mystring str2;
	str2=str1;
	str1=str1;

	str1.Print();
	str2.Print();
	system("pause");
	return 0;
}

存在的问题：

在上述代码中，我满首先释放自己的内存，然后去开辟一块内存空间让_data指向这块空间，最后进行拷贝，

如果因为内存不足，在new char[len+1]阶段抛出异常，那么这时候因为已经释放了_data，导致_data指向一个空指针，这样可能会导致程序崩溃。有两种方案解决上述问题：

• 先用new分配新内容，然后删除自己已有内容，最后进行赋值。
• 创建一个临时实例，交换临时实例与当前实例的_data。代码如下：

  Mystring& Mystring::operator=(const Mystring &str)
  {
  	if(this!=&str)
  	{
  		Mystring strTemp(str);//创建临时实例
  		//交换
  		char* pTemp=strTemp._data;
  		strTemp._data=_data;
  		_data=pTemp;
  	}
  	return *this;
  }

  
  

这样的一个好处是在运行完if语句以后，因为除了strTemp的作用于该实例会自动调用析构函数，把strTemp._data所指向的内存释放掉，而此时strTemp._data指向的是实例原先_data指向的内存，并没有释放当前指向的pTemp这一块内存。还有一点是通过构造函数为临时实例分配内存，如果在new char过程中抛出异常，并没有改变该实例_data所指向的内容，也没有释放内存，所以是 异常安全性 的。