effective c++：对象的赋值运算

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只对已初始化对象才有意义”的事意义。