Question

考虑下面的Parent和Child类中的赋值运算符。

#include <iostream>
class Parent 
{
public:
  Parent(){};
  virtual ~Parent(){};
  Parent& operator=(const Parent& other){mP = other.mP; return *this;};

  void setP(double inP){mP = inP;};
  double getP(){return mP;};
protected:
  double mP;
};


class Child : public virtual Parent
{
public:
  Child(){};
  virtual ~Child(){};
  Child& operator=(const Child& other)
  {
     mC = other.mC;
     mP = other.mP;// this line
     return *this;
  };

  void setC(double inC){mC = inC;};
  double getC(){return mC;};
protected:
  double mC;
};

这是避免重复行mP = other.mP;的方法吗？

我要问的原因是随着基数的增加以及继承结构变得越来越复杂，很容易失去对成员的追踪。

修改

我需要实现operator=的原因是它需要在分配之前检查一些事情。

Answer 1

只需调用Parent运算符：

Child& operator=(const Child& other)
{
     mC = other.mC;
     Parent::operator=(other);
     return *this;
}

或者真的，不要实施任何一个运营商，因为两者都是微不足道的！

Answer 2

避免此问题的最佳方法是删除两个operator=函数。

编译器生成的operator=将operator=应用于每个成员变量和基类，这正是您尝试做的事情。

重新实现滚轮只会使您的代码更难以阅读和维护 - 有时效率会降低。

Answer 3

Child& operator=(const Child& other)   {
     mC = other.mC;
     mP = other.mP; 
}

您可以通过以下方式在子特定分配之前调用父级的赋值运算符：

 Child& operator=(const Child& other)
  {
     Parent::operator=(other);
     mC = other.mC;
     return *this;
  };

避免派生类的赋值运算符中的重复

3 个答案: