如何在不修改操作数的情况下使用运算符重载链？

Question

假设我们有这个A类:

class A
{
public:
   int a;

   A(int b)
   {
      a = b;
   }
};

我想创建一个+重载,这样我就可以像这样使用它

A a(1),b(2),c(3),&d;
d = a + b + c;

不修改每个对象的内容.下一个合乎逻辑的事情是每次分配一块新的内存,如下所示:

A &operator+ (const A &b)
{
   A *c = new A(a+b.a);
   return *c;
}

但这会产生一个新问题:中间结果丢失,导致内存泄漏.我可以通过制作一个静态函数来轻松解决这个问题,该函数需要三个A对象引用并将前两个的总和存储在第三个中,但我愿意打赌必须有一些方法来使+重载发生的方式我想要.

所以问题是:有没有什么方法可以使用一系列操作符重载,它们不会在不引起内存泄漏的情况下修改操作数？

Answer 1

您可以简单地使用pass by value并执行以下操作:

A operator+ (A other) //pass by value
{
   other.a += a;
   return other;
}

或者,由于该成员a是公共可访问的,您可以(而应该)将operator+非成员函数创建为:

A operator+(A left, A const &right) 
{
   left.a += right.a;
   return left;
}

请注意,第一个参数由值接受,第二个参考由引用接受.这样,您就不需要在函数中声明局部变量.你可以使用第一个参数; 毕竟它是函数的本地函数,你可以做任何你想做的事情:在这种情况下,我们只需添加right.a它,然后返回它.

更好的类设计是:(阅读评论)

class A
{
   int a;  //make it private
public:    
   A(int b) : a(b) //use member initialization list
   {
   }
   A& operator+=(A const & other)  //add `+=` overload, as member of the class
   {
      a += other.a;
      return *this;
   }
};

//and make `+` non-member and non-friend 
A operator+(A left, A const & right) 
{
  left += right; //compute this in terms of `+=` which is a member function
  return left;
}