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

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

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

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

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

Answer 2

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

您可以通过这种方式在子特定赋值之前调用父赋值运算符：

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

Answer 3

只需调用 Parent 运算符：

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

或者说真的，不要实现任何一个运算符，因为它们都很简单！