Question

#include<iostream>
using namespace std;

class complex {
    double real;
    double image;
public:
    complex(double r=0,double i=0) : real(r), image(i) { };
    complex(const complex& c) : real(c.real), image(c.image) { };
    ~complex(){};
    double re() const {
        return real;
    };
    double im() const{
        return image;
    };
    const complex& operator =(const complex&c)
    {
        real = c.real;
        image = c.image;
        return *this;
    };
    const complex& operator +=(const complex&c)
    {
        real += c.real;
        image += c.image;
        return *this;
    };
    const complex& operator -=(const complex&c)
    {
        real -= c.real;
        image -= c.image;
        return *this;
    };
    const complex& operator *=(const complex&c)
    {
        double keepreal=real;
        real = real * c.real - image * c.image;
        image = keepreal * c.image + image * c.real;
        return *this;
    };
    const complex& operator /=(double d)
    {
        real/=d;
        image/=d;
        return *this;
    };

    friend complex operator !(const complex &c)
    {
        return complex(c.re(),-c.im());
    };
    friend double abs2(const complex& c)
    {
        return (c.re() * c.re() + c.im() * c.im());
    };
    const complex& operator /=(const complex&c)
    {   
        return *this *= (!c) /= abs2(c);
    };
    const complex operator +(const complex& c, const complex& d)
    {
        return complex(c.re() + d.re(), c.im() + d.im());
    };
    const complex operator -(const complex& c, const complex& d)
    {
        return complex(c.re() - d.re(), c.im() - d.im());
    };
    const complex operator -(const complex&c)
    {
        return complex(-c.re(), -c.im());
    };
    const complex operator /(const complex& c,const complex& d)
    {
        return complex(c) /= d;
    };
};

int main() {
    complex c = 1., d(3.,4.);

    return 0;
}

输出：

第62行：错误：'const complex       complex :: operator +（const complex＆amp ;,,       const complex＆amp;）'必须采取       零或一个参数
  汇编       由于-Wfatal-errors而被终止。

请帮助：http://codepad.org/cOOMmqw1

Answer 1

有两种方法可以重载二元+运算符，作为自由函数或作为成员函数。作为成员函数，签名为Type operator+( Type const & ) const（const在那里是可选的，但我假设a+b不修改a，这似乎是公平的假设。）

另一种方法是使用一个自由函数，它接受两个对象并返回总和。对此有不同的签名，但最广泛接受的是：Type operator+( Type lhs, Type const & rhs )（注意第一个参数是按值），其中实现内部修改并返回lhs 。特别是算术运算符重载的常用方法是将operator+=实现为成员函数，然后根据前者实现自由函数operator+：

struct Type {
   // ...
   Type& operator+=( Type const & );
};
Type operator+( Type lhs, Type const & rhs ) {
   return lhs+=rhs;
}

这样，您不需要为自由函数授予友谊。在某些情况下，尤其是模板，有时建议在类定义中定义运算符，在这种情况下，您必须将其设为friend（不是为了访问，但出于语法原因：

struct Type {
   // ...
   Type& operator+=( Type const & );
   // Still a free function:
   friend Type operator+( Type lhs, Type const & rhs ) {
      return lhs+=rhs;
   }
};

使用此模式的原因...首先在operator+=上实施operator+然后在其上operator+提供两个单独的操作，只需支付额外费用（operator+=是一个-liner功能！）。将其实现为成员函数（operator=也可以是自由函数）使其类似于operator+（必须是成员）并避免需要友谊。

将a+b实现为自由函数的原因与操作的类型对称性有关。添加是可交换的（b+a == complex( double r = 0, double i = 0 )），在使用您的类型时您会期望相同。您提供了一个隐式构造函数（由于构造函数operator+，您的复杂类型可以从int隐式转换，并且如果函数调用与重载不完全匹配，则允许编译器使用这些转换。

如果将complex实现为成员函数，则只允许编译器在第一个参数为complex(0,0)+5时考虑该重载，并且将隐式转换另一个参数，允许您键入{ {1}}。问题是如果您反转顺序5+complex(0,0)，编译器无法将5转换为复合体，然后使用成员operator+。另一方面，如果您将其作为自由函数提供，编译器将检测两个参数中的一个在两种情况下都匹配，并将尝试成功转换另一个参数。最终结果是，通过使用自由函数，您可以通过单个实现允许所有这三个添加：complex+complex，complex+double，double+complex（此外，对于所有积分和浮点类型，因为它们可以转换为double

让operator+按值获取第一个参数意味着编译器在某些情况下可以删除副本：a + b + c绑定为(a+b) + c，可以使用第一个操作的临时结果直接作为第二次调用的参数，无需额外复制。

Answer 2

你像这样重载+，/， - 和*

complex operator+(const complex& c) const

由于左手参数为this

，因此您只需要一个参数

实施例

complex operator+(const complex& c) const 
{
    return complex(c.re()+this->re(),c.im()+this->im());
};

Answer 3

+运算符应该带一个参数：

complex operator+(const complex& c) const
{ 
   return complex(c.re()+re(),c.im()+im());
}

另一个复合体是当前对象。

Answer 4

您

const complex operator+(const complex& c, const complex& d)
{
return complex(c.re()+d.re(),c.im()+d.im());
};

是complex的成员函数。该原型适用于全球operator+。在成员函数c中假定为*this，因此未指定。

但是你真的需要开始正确格式化你的代码，从缩进开始。初学程序员在向其他人展示代码时没有意识到正确格式化的重要性。

Answer 5

如果你真的在寻找两个参数运算符重载，还有另一种重载二元运算符的方法。然后你可以尝试这样的事情。

friend complex operator+(const complex& c, const complex& d)
 {
  complex r;
  r.real = c.re() + d.re();
  r.image = c.im() + d.im();
  return r;
 }

C ++运算符重载错误

5 个答案: