Effective C++ (E3 10、11)笔记之在operator=中返回*this、处理自我赋值

版权声明:本文为博主原创文章,未经博主允许不得转载。 https://blog.csdn.net/brahmsjiang/article/details/79504614

为了实现“连锁赋值”,即

	Widget wig4,wig3;	
	wig3.printname();
	wig4.printname();
	//continous assigiment
	wig4=wig3=wig1;
	wig3.printname();
	wig4.printname();

operator=必须返回一个reference指向操作符的左侧实参。这项不成文的规定同样适用于其他赋值相关运算,比如+=、-=、*=等等。下面是返回*this的operator=实现:

class Widget{
public:
	Widget(std::string str="")
		:name(str)
	{}
	//void operator=(const Widget& wig)
	//{
	//	name=wig.name;
	//}
	Widget& operator=(const Widget& wig)
	{
		name=wig.name;
		return *this;
	}
	void printname()
	{
		cout<<name<<endl;
	}
private:
	std::string name;
};

如果使用注释掉的operator=,将导致“连锁赋值”编译错误。


所谓“自我赋值”,可能一眼可辨认:

w=w;

也可能是潜在的:

a[i]=a[j];
*px=*py;

尤其是对于资源管理类(有成员指针指向其他对象),如果A=B(B可能就是A),

自我赋值可能会掉进“在赋值给A之前,已经将B对象释放了”的陷阱之中。如下面这个实现:

class TestClass
{
public:
	TestClass(char* ptr)
	{
		pname=ptr;
	}
	TestClass(const TestClass& tc)
	{
		pname=crtstr(tc.pname);	//deep copy
	}
	~TestClass()
	{
		cout<<"call ~TestClass"<<endl;
		if(pname!=NULL){
			cout<<"delete pname"<<endl;
			delete pname;	
			pname=NULL;
		}
	}
	void print()
	{
		if(pname)
			cout<<pname<<endl;
		else
			cout<<"pname is NULL!\n";
	}
	TestClass& operator=(const TestClass& tc)
	{
		delete pname;pname=NULL;
		if(tc.pname==NULL){
			cout<<"tc.pname is NULL!"<<endl;
		}else
			pname=crtstr(tc.pname);
		return *this;
	}
private:
	char* pname;
};

char* crtstr(char* par)
{
	unsigned size=strlen(par);//strlen()不计算\0
	char* tmpptr=new char[size];
	memset(tmpptr,' ',size);//memset(tmpptr,'',10) is forbidden
	memcpy(tmpptr,par,size);
	par[size]='\0';
	return tmpptr;
	
}

这里的operator=不管三七二十一,先delete this的成员指针。如若tc就是this,那tc的成员指针在赋值前已经销毁。测试:

	char* pstr1=new char(10);
	memset(pstr1,' ',10);
	memcpy(pstr1,"MIKE",sizeof("MIKE"));
	TestClass tc1(pstr1);
	tc1.print();
	tc1=tc1;
	tc1.print();

结果:


传统做法是在operator=前面加个“证同测试”。如是同一对象,直接返回*this

	TestClass& operator=(const TestClass& tc)
	{
		if(this==&tc) return *this;
		delete pname;pname=NULL;
		if(tc.pname==NULL)
			cout<<"tc.pname is NULL!"<<endl;
		pname=crtstr(tc.pname);
		return *this;
	}

结果:


这个做法仍有缺点,那便是不具有异常安全性。简单说来,如果某个操作(如new)抛出异常,则pname的状态能否回到有效状态,或者调用operator=之前的状态,或者干脆保证该函数不抛出异常。

其实将语句次序精心安排,就可以得到异常安全代码。即先备份原指针,将原指针指向生成的一个副本,最后删除备份以释放原指针指向的对象。并且此举往往一箭双雕,得到自我赋值安全的回报

	TestClass& operator=(const TestClass& tc)
	{
		//printf("==>%d, %s\n",sizeof(*pname),pname);//output 1,MIKE==>char* result is char,not whole string. so result is 1
		char* ptmp=pname;
		//pname=new char[] , memset(pname,..)... will refresh tc.pname,if tc and this is the same object. Must use a tmp var
		pname=crtstr(tc.pname);	
		delete ptmp;
		return *this;
	}

不过这里要注意,我使用了crtstr函数来new一个副本。按注释所言,在得到这副本前不能对pname进行memset等操作,因为这等于又走回了自我赋值的老路,将tc.pname也memset了。直接返回一个副本的指针就OK!

同时获得异常安全和自我赋值安全的更先进的做法是copy and swap技术。即先复制一个临时(栈)对象,用一个tmp指针指向此临时对象,然后交换tmp指针和pname指针的值。交换后tmp指针指向原资源,因为在栈上自动释放。并且除了复制构造函数外,其他语句都是内置类型操作,而内置类型操作一般不会抛出异常:

	TestClass& operator=(const TestClass& tc)
	{
		TestClass tmpobj(tc);
		char* tmpptr=tmpobj.pname;
		tmpobj.pname=pname;
		pname=tmpptr;
		return *this;
	}

展开阅读全文

没有更多推荐了,返回首页