C++运算符重载时出错

Error with C++ operator overloading

本文关键字：出错 重载 运算符 C++      更新时间：2023-10-16
#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 行：错误："常量复合体" complex：：operator+（const complex&， 常量复合体&）' 必须采取 零个或一个参数
汇编 由于 -Wfatal-错误而终止。

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

有两种

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

另一种方法是使用一个 free 函数，该函数接受两个对象并返回总和。对此有不同的签名，但最广泛接受的是：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+=也可以是自由函数）使其类似于operator=（必须是成员），并避免了友谊的需要。

将

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

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

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

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

complex operator+(const complex& c) const

您只需要一个参数，因为左侧参数是this

例

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

+ 运算符应采用一个参数：

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

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

您的

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

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

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

还有

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

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;
 }
相关文章：