关于重载运算符的问题+

Question

考虑以下代码：

class A
{
public:
    A& operator=( const A& );
    const A& operator+( const A& );
    const A& operator+( int m );
};

int main()
{
    A a;
    a = ( a + a ) + 5;   // error: binary '+' : no operator found which takes a left-hand operand of type 'const A'
}

任何人都可以解释为什么上面的内容会作为错误返回吗？

“( a + a )”调用“const A&operator+(const A&)”并返回一个常量引用，然后将其传递给“const A&operator+(const A&)”。如果我没记错的话，operator+( int m )”。

如何修复上述错误（无需创建全局二元运算符+或接受 int 的构造函数），以便允许 main() 内的语句？

Answer 1

如果我没记错的话，它会被传递给“const A& operator+( int m )”

否。因为 LHS 是一个 const A& 而 RHS 是一个 int ，它会调用*，

[anyType] operator+ (int rhs) const
//                            ^^^^^ note the const here.

因为您只提供了非 const 版本 const A& operator+( int m )，编译器会抱怨。

_{*：或者operator+(const int& rhs) const或者operator+(float rhs) const...关键点是它必须是一个const 方法。}

Answer 2

operator+ 应该返回一个实例，而不是一个引用：

// as member function
A operator+(const A& other);

// as free function
A operator+(const A& left, const A& right);

要解释的具体问题是“返回一个常量引用，然后传递给 const A&operator+( int m )”。由于您有一个 const 引用，因此它无法调用该函数，因为它不是 const 方法（即 const A& operator+( int m ) const ）。

也就是说，这不是修复operator+的方法。如果您要返回一个引用，那么它是对什么的引用？运算符 + 中的本地会很糟糕，因为您不应该返回对本地的引用。对全局的引用会很糟糕，因为它会限制代码的正确使用方式。对已分配内存的引用是不好的，因为它会泄漏内存。对 *this 的引用会很糟糕，因为 operator+ 的作用类似于 operator +=。

Answer 3

因为您在添加时正在修改左侧对象。您不能使用 const 对象来做到这一点。顺便说一句，接受塞缪尔的建议，因为惯用的方法是返回所添加对象的新副本。

Answer 4

该函数需要是 const：

const A&运算符+( int m ) const;

Answer 5

作为 const A& operator+( const A& ) 返回一个非 const 成员函数 const 引用 const A&不能通过 const 对象调用operator+( int m )。
或者，第一个运算符应定义为 A& operator+( const A& ) 或者，第二个运算符为 const A&运算符+(int m)const;
然而，这些更改只会使它们在技术上正确，而不是在大多数情况下在美观上正确，因为二元运算符不应修改任何输入参数，但仍要计算结果并返回。因此，结果必须按值返回，或者在 C++0x 的情况下，作为右值引用返回。
即A运算符+(const A& rhs)const或A&&运算符+(const A& rhs)const;

Answer 6

问题是 (a+a) 返回一个所谓的右值（基本上是临时的一个奇特术语）。虽然您可以对右值调用成员函数，但只能调用 const 成员函数。另外，每个人都说 operator+ 必须始终返回一个新值。

您的运算符应该像这样实现：

A operator+( const A& ) const;
A operator+( int m ) const;

但是，不修改其左参数的二元运算符可能更好地实现为自由函数：

class A { ... };

A operator+(const A& lhs, const A& rhs);
A operator+(const A& lhs, int rhs);

通常，它们在 operator+= 之上实现，后者实现为会员：

class A {
  public:
   A& operator+=(const A& rhs);
   A& operator+=(int rhs);
};

inline A operator+(A lhs, const A& rhs) // note: lhs is passed by copy now
{
  lhs += rhs;
  return lhs;
}
A operator+(A lhs, int rhs) // note: lhs is passed by copy now
{
  lhs += rhs;
  return lhs;
}