Effective C++学习笔记：在operator=中对所有数据成员赋值

重载operator=时关键的有三点：

（1）检查自赋值。

（2）调用基类的赋值函数。

（3）返回本对象的引用。

例1

template           // 名字和指针相关联的类的模板
class namedptr

{          

public:
  namedptr(const string& initname, t *initptr);            //构造函数
  namedptr& operator=(const namedptr& rhs);            //赋值函数

private:
  string name;                                                               //名称
  t *ptr;                                                                         //
};

template
namedptr & namedptr ::operator=(const namedptr & rhs)
{
  if (this == &rhs)                                    //检查自赋值
    return *this;                                       //直接 返回本对象的引用

  // assign to all data members
  name = rhs.name;                                // 给name赋值

  *ptr = *rhs.ptr;                                     // 对于ptr，赋的值是指针所指的值，
                                                              // 不是指针本身

  return *this;                                         // 返回本对象的引用

}

 

当有类继承时，情况复杂一些。派生类的赋值函数必须调用基类的赋值函数。

例2.

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& derived::operator=(const derived& rhs)
{
  if (this == &rhs) return *this;

    y = rhs.y;

  return *this;
}

但是这样写的话，没有给base类的变量赋值，直接写对base::x赋值也不允许，因为x是private类型的，下面的赋值函数是合理的。

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

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

  return *this;
}

上述的operator=如果是编译器自动生成的，那么这种写法未必都能通的过，为了适应这种编译器，必须这样实现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的拷贝构造函数，创建出来的新对象就成为了赋值的目标，而*this保持不变。这不是所想要的结果。

在派生类的拷贝构造函数也会发生类似的问题。

例3.

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;
};

例3中派生类的拷贝构造函数，没有调用基类的拷贝构造函数，但是编译器会调用基类的缺省拷贝构造函数，没有顾及被拷贝对象。解决这个问题的办法就是在派生类的构造函数初始化列表中初始化base，派生类的定义应该如下所示：

class derived: public base {
public:
 

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

  derived(const derived& rhs) ：base（rhs）,y(rhs.y)  // 正确的拷贝构造函数
  {}                                

private:
  int y;

};