operator 中处理”自我赋值“
operator=操作符缺省情况下返回引用——TYPE& TYPE::operator=(const TYPE&)，原因很简单，operator=返回引用的理由是使你能在一个语句中连接多个赋值。
int x, y, z;
x = y = z = 15; // chain of assignments
赋值采用右结合律，上面的代码被编译器解释为：
x = (y = (z = 15));
在编译过程中，赋值是右结合的。说白了就是如果你想要玩一下多个赋值，operator=返回的东西必须是右（rhs）赋值。除了返回对对象自身的引用还能有什么呢？这就是为什么operator=最后一行总是返回对this的引用：
class Widget {
public:
...
Widget& operator=(const Widget& rhs) // return type is a reference to
{ // the current class
...
return *this; // return the left-hand object
}
...
};
再来看自我赋值，即对象被赋值给自己，假设建立一个class用来保存一个指针指向一块动态分配的bitmap
class Bitmap { ... };
class Widget {
...
private:
Bitmap *pb; // ptr to a heap-allocated object
};
下面是operator=代码，表面上看合理，但自我赋值时并不安全。
Widget&
Widget::operator=(const Widget& rhs) // unsafe impl. of operator=
{
delete pb; // stop using current bitmap
pb = new Bitmap(*rhs.pb); // start using a copy of rhs’s bitmap
return *this; // see Item 10
}
如果rhs与*this指向同一对象，第一句的delete pb就销毁了bitmap中调用的rhs.pb，这一问题的解决方案是copy and swap：
class Widget {
...
void swap(Widget& rhs); // exchange *this’s and rhs’s data;
... // see Item29 for details
};
Widget& Widget::operator=(const Widget& rhs)
{
Widget temp(rhs); // make a copy of rhs’s data
swap(temp); // swap *this’s data with the copy’s
return *this;
}
它先将rhs做一个复本，由这个复本与this交换数据来达到目的。
复制对象时确保复制对象内每个成员变量
类customer如下所示：
void logCall(const std::string& funcName); // make a log entry
class Customer {
public:
...
Customer(const Customer& rhs);
Customer& operator=(const Customer& rhs);
...
private:
std::string name;
};
Customer::Customer(const Customer& rhs)
: name(rhs.name) // copy rhs’s data
{
logCall("Customer copy constructor");
}
Customer& Customer::operator=(const Customer& rhs)
{
logCall("Customer copy assignment operator");
name = rhs.name; // copy rhs’s data
return *this; // see Item 10
}
这个程序完全正确，但当在类中加入一个成员变量，我们同时也要在复制运算中加入相应的变量复制。
class Date { ... }; // for dates in time
class Customer {
public:
... // as before
private:
std::string name;
Date lastTransaction;
};
如果忘记修改operator=函数，编译器不会提醒你，从而造成潜在的漏洞。
再来看派生类复制的情况
class PriorityCustomer: public Customer { // a derived class
public:
...
PriorityCustomer(const PriorityCustomer& rhs);
PriorityCustomer& operator=(const PriorityCustomer& rhs);
...
private:
int priority;
};
PriorityCustomer::PriorityCustomer(const PriorityCustomer& rhs)
: priority(rhs.priority)
{
logCall("PriorityCustomer copy constructor");
}
PriorityCustomer&
PriorityCustomer::operator=(const PriorityCustomer& rhs)
{
logCall("PriorityCustomer copy assignment operator");
priority = rhs.priority;
return *this;
}
PriorityCustomer好像是完全复制了成员变量，但每个PriorityCustomer类都还包含着基类的成员变量未被复制，PriorityCustomer类中的customer成分被不带实参的customer构造函数初始化，customer成员变量初始化为缺省的值。我们所要做的是提供一个第三方的函数来调用基类的复制函数。
注意两个错误用法：1、令copy assignment操作符调用copy构造函数是错误的，因为在这就像试图构造一个已存在的对象。2、令copy构造函数调用copy assignment操作符同样是错误的。构造函数用来出事后对象，而assignment操作符只实行与已初始化的对象身上。对一个尚未构造好的对象赋值，就像在一个尚未初始化的对象身上做“z只对已初始化对象才有意义”的事意义。