C++ c++；重载==运算符需要一个和两个参数

在我正在做的项目中，我试图重载==运算符。声明和定义如下：

friend bool operator==(const TradeItem& item);

bool TradeItem::operator==(const TradeItem& item)

当我编译它时，它会说：'bool operator==（const TradeItem&'）必须正好包含两个参数。所以我修改了它，使它有两个参数，如下所示：

friend bool operator==(const TradeItem& i1, TradeItem& i2);

bool TradeItem::operator==(const TradeItem& i1, TradeItem& i2)

friend bool operator==(const TradeItem& i1, TradeItem& i2);

bool TradeItem::operator==(const TradeItem& i )    

---

但当我编译它时，它告诉我它只需要一个参数。。。。谈谈给我借口。有人知道出了什么问题吗？

记住，

==

是一个二进制运算符。这意味着它必须始终有两个参数。如果将

operator==（）

作为成员函数重载，其中一个参数就是传递给每个成员函数的隐式

this

---

在您的代码中，您声明了一个全局

操作符==（）

函数，它是

TradeItem

类的

friend

。同时，您将定义一个

操作符==（）

作为

TradeItem

的成员。挑一个；您不应该同时执行这两项操作。

请记住，

=

是一个二进制运算符。这意味着它必须始终有两个参数。如果将

operator==（）

作为成员函数重载，其中一个参数就是传递给每个成员函数的隐式

this

---

在您的代码中，您声明了一个全局

操作符==（）

函数，它是

TradeItem

类的

friend

。同时，您将定义一个

操作符==（）

作为

TradeItem

的成员。挑一个；您不应该同时执行这两项操作。

运算符的类成员版本采用一个参数，而友元版本采用两个参数，因此应如下所示：

friend bool operator==(const TradeItem& i1, TradeItem& i2);

bool TradeItem::operator==(const TradeItem& i1, TradeItem& i2)

friend bool operator==(const TradeItem& i1, TradeItem& i2);

bool TradeItem::operator==(const TradeItem& i )    

---

这是因为成员版本有一个隐藏的

This

参数。成员版本也将优先于朋友版本。您应该选择一个或另一个。

运算符的类成员版本采用一个参数，而友元版本采用两个参数，因此应如下所示：

friend bool operator==(const TradeItem& i1, TradeItem& i2);

bool TradeItem::operator==(const TradeItem& i1, TradeItem& i2)

friend bool operator==(const TradeItem& i1, TradeItem& i2);

bool TradeItem::operator==(const TradeItem& i )    

---

这是因为成员版本有一个隐藏的

This

参数。成员版本也将优先于朋友版本。您应该选择一个或另一个。

运算符==包含两个参数的重载不能是成员函数-将其声明为

bool运算符==（const T&，const T&）

运算符==包含两个参数的重载不能是成员函数-将其声明为

bool运算符==（const T&，const T&）

问题在于：

friend bool operator==(const TradeItem& item);

需要两个参数和：

bool TradeItem::operator==(const TradeItem& item)

需要一个参数

这是因为

operator==

的非成员版本总是需要两个，而成员版本需要一个。您的好友声明声明了一个非成员运算符重载

class C {
    friend bool operator==(const C &lhs, const C &rhs);
public:
    bool operator==(const C& rhs);
};

bool operator==(const C &lhs, const C &rhs) { return true; }

bool C::operator==(const C& rhs) { return true; }

此外，如果需要允许在左侧进行类型转换，则只需要使用两个成员版本。例如：

bool operator==(int lhs, const C &rhs);
bool operator==(double lhs, const C &rhs);

10 == C();
3.0 == C();

您可以不将这些重载声明为C的朋友而逃之夭夭。可能类似于：

class C {
public:
    bool operator==(const C& rhs);
    bool operator==(int rhs);
    bool operator==(double rhs);
};

bool operator==(int lhs, const C &rhs) { return rhs == lhs; }
bool operator==(double lhs, const C &rhs) { return rhs == lhs; }

bool C::operator==(const C& rhs) { return true; }
bool C::operator==(int rhs) { return *this == convert_int_to_C(rhs); }
bool C::operator==(double rhs) { return *this == convert_double_to_C(rhs); }

---

此外，由于检查相等性不应更改对象，因此应

const

限定成员函数：

class C {
    bool operator== (C const &rhs) const;
}

问题在于：

friend bool operator==(const TradeItem& item);

需要两个参数和：

bool TradeItem::operator==(const TradeItem& item)

需要一个参数

这是因为

operator==

的非成员版本总是需要两个，而成员版本需要一个。您的好友声明声明了一个非成员运算符重载

class C {
    friend bool operator==(const C &lhs, const C &rhs);
public:
    bool operator==(const C& rhs);
};

bool operator==(const C &lhs, const C &rhs) { return true; }

bool C::operator==(const C& rhs) { return true; }

此外，如果需要允许在左侧进行类型转换，则只需要使用两个成员版本。例如：

bool operator==(int lhs, const C &rhs);
bool operator==(double lhs, const C &rhs);

10 == C();
3.0 == C();

您可以不将这些重载声明为C的朋友而逃之夭夭。可能类似于：

class C {
public:
    bool operator==(const C& rhs);
    bool operator==(int rhs);
    bool operator==(double rhs);
};

bool operator==(int lhs, const C &rhs) { return rhs == lhs; }
bool operator==(double lhs, const C &rhs) { return rhs == lhs; }

bool C::operator==(const C& rhs) { return true; }
bool C::operator==(int rhs) { return *this == convert_int_to_C(rhs); }
bool C::operator==(double rhs) { return *this == convert_double_to_C(rhs); }

---

此外，由于检查相等性不应更改对象，因此应

const

限定成员函数：

class C {
    bool operator== (C const &rhs) const;
}

---

必须同时创建一个接受一个参数的函数和一个接受2；）必须同时创建一个接受一个参数的函数和一个接受2；）只需添加一个提问者可能会觉得有用的澄清：您可能只需要其中一个。除非在极端情况下，宣布（和实施）这两项都是多余的。如果您将此运算符作为成员函数编写，则不需要友元声明，也不需要它的两个参数版本。程序指南告诉我它需要友元重载，因此我将消除成员重载。谢谢您的帮助。我还建议您研究一下boost:：operator，以简化运算符重载的处理。此外，如果您拥有运算符的成员函数版本，则很可能不需要使用frienddeclaration@YaserZhian如果两个都写，会不会导致编译器错误？我想我可以试着确认一下。如果有一个运算符同时作为成员和朋友重载，编译器或链接器似乎无法决定调用哪一个。@代码专家当然，如果您正确且相同地编写这两个版本（即都使用const&），它将生成一个编译错误（它会说运算符不明确）这两个声明在调用站点都是可见的，您实际上从某个地方调用了相等运算符。如果不满足这些条件，例如，如果您实际上还没有调用运算符，您的类将编译（我认为），但稍后您会遇到问题。只需添加一个澄清，问问题的人可能会觉得有用：您可能只需要其中一个。除非在极端情况下，宣布（和实施）这两项都是多余的。如果您将此运算符作为成员函数编写，则不需要友元声明，也不需要它的两个参数版本。程序指南告诉我它需要友元重载，因此我将消除成员重载。谢谢您的帮助。我还建议您研究一下boost:：operator，以便轻松地进行交接