effective C++ operator=对所有数据成员赋值

当涉及到继承时，情况就会更有趣，因为派生类的赋值运算符也必须处理它的基类成员的赋值！看看下面：

class base {
public:
base(int initialvalue = 0): x(initialvalue) {}

private:
int x;
};

class derived: public base {
public:
derived(int initialvalue)
: base(initialvalue), y(initialvalue) {}

derived& operator=(const derived& rhs);

private:
int y;
};

逻辑上说，derived的赋值运算符应该象这样：

// erroneous assignment operator
derived& derived::operator=(const derived& rhs)
{
if (this == &rhs) return *this;    // 见条款17

y = rhs.y;                         // 给derived仅有的
                                     // 数据成员赋值

return *this;                      // 见条款15
}

不幸的是，它是错误的，因为derived对象的base部分的数据成员x在赋值运算符中未受影响。例如，考虑下面的代码段：

void assignmenttester()
{
derived d1(0);                      // d1.x = 0, d1.y = 0
derived d2(1);                      // d2.x = 1, d2.y = 1

d1 = d2;         // d1.x = 0, d1.y = 1!
}

请注意d1的base部分没有被赋值操作改变。

解决这个问题最显然的办法是在derived::operator=中对x赋值。但这不合法，因为x是base的私有成员。所以必须在derived的赋值运算符里显式地对derived的base部分赋值。

也就是这么做：

// 正确的赋值运算符
derived& derived::operator=(const derived& rhs)
{
if (this == &rhs) return *this;

base::operator=(rhs);    // 调用this->base::operator=
y = rhs.y;

return *this;
}

这里只是显式地调用了base::operator=，这个调用和一般情况下的在成员函数中调用另外的成员函数一样，以*this作为它的隐式左值。base::operator=将针对*this的base部分执行它所有该做的工作——正如你所想得到的那种效果。

但如果基类赋值运算符是编译器生成的，有些编译器会拒绝这种对于基类赋值运算符的调用（见条款45）。为了适应这种编译器，必须这样实现derived::operator=：

derived& derived::operator=(const derived& rhs)
{
if (this == &rhs) return *this;

static_cast(*this) = rhs;      // 对*this的base部分
                                        // 调用operator=
y = rhs.y;

return *this;
}

这段怪异的代码将*this强制转换为base的引用，然后对其转换结果赋值。这里只是对derived对象的base部分赋值。还要注意的重要一点是，转换的是base对象的引用，而不是base对象本身。如果将*this强制转换为base对象，就要导致调用base的拷贝构造函数，创建出来的新对象（见条款m19）就成为了赋值的目标，而*this保持不变(标蓝色的解释：如果是强制转化成base的对象，则会产生一个临时的base对象，因此会调用拷贝构造函数)。这不是所想要的结果。

不管采用哪一种方法，在给derived对象的base部分赋值后，紧接着是derived本身的赋值，即对derived的所有数据成员赋值。

另一个经常发生的和继承有关的类似问题是在实现派生类的拷贝构造函数时。看看下面这个构造函数，其代码和上面刚讨论的类似：

class base {
public:
base(int initialvalue = 0): x(initialvalue) {}
base(const base& rhs): x(rhs.x) {}

private:
int x;
};

class derived: public base {
public:
derived(int initialvalue)
: base(initialvalue), y(initialvalue) {}

derived(const derived& rhs)      // 错误的拷贝
: y(rhs.y) {}                    // 构造函数

private:
int y;
};

类derived展现了一个在所有c++环境下都会产生的bug：当derived的拷贝创建时，没有拷贝其基类部分。当然，这个derived对象的base部分还是创建了，但它是用base的缺省构造函数创建的，成员x被初始化为0（缺省构造函数的缺省参数值），而没有顾及被拷贝的对象的x值是多少！

为避免这个问题，derived的拷贝构造函数必须保证调用的是base的拷贝构造函数而不是base的缺省构造函数。这很容易做，只要在derived的拷贝构造函数的成员初始化列表里对base指定一个初始化值：

class derived: public base {
public:
derived(const derived& rhs): base(rhs), y(rhs.y) {}

...

};

现在，当用一个已有的同类型的对象来拷贝创建一个derived对象时，它的base部分也将被拷贝了。