如何使用操作符重载链，而无需修改操作数？(How do I use a chain of opera

比方说，我们有这样的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;
}

但是，这将创建一个新的问题：中间结果都将丢失，导致内存泄漏。 我可以做一个静态函数，采用三级对象引用，并存储在第三的前两个的总和很容易地解决了这个问题，但我敢打赌，必须有一些方法，使超载发生的方式我想要。

所以，问题是：有没有什么办法，我可以使用操作符重载链不修改操作数，而不会造成内存泄漏？

Answer 1:

你可以简单地使用值通和这样做：

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

Answer 2:

有没有必要使用内部指针operator+ 。 您可以在堆栈分配的中间目标，然后返回它：

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

要不就：

A operator+ (const A &b)
{
   return A(a+b.a);
}

或者更简单：

A operator+ (const A &b)
{
   return a+b.a;
}

由于这个隐式调用A::A(int)

请注意，我删除从返回类型的参考。 你不能返回一个非const引用到本地。

然后你会使用这种方式：

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

需要注意的是d不再是一个参考。

文章来源: How do I use a chain of operator overloads without modifying the operands?