(C++) 这些重载的操作符函数有什么区别？

Question

这两种重载下面的 != 运算符的方法有什么区别。哪个比较好？

Class Test  
{  
...//
private:  
int iTest

public:  
BOOL operator==(const &Test test) const;
BOOL operator!=(const &Test test) const;  
}

BOOL operator==(const &Test test) const  
{  
    return (iTest == test.iTest);  
}    

//overload function 1  
BOOL Test::operator!=(const &Test test) const  
{  
    return !operator==(test);  
}

//overload function 2  
BOOL Test::operator!=(const &Test test) const  
{  
    return (iTest != test.iTest);  
}  

我最近刚刚看到函数 1 调用同级运算符函数的语法，想知道这样编写是否有任何好处。

Answer 1

它们几乎肯定会编译成相同的机器码。

我更喜欢选择 2，只是因为我觉得说“operator==”很尴尬。但你可以使用

return ! (*this == test)

恕我直言，这也很清楚易懂。

Answer 2

您的第一个重载确保在您的类型上调用 != 将始终提供与调用 == 相反的结果，即使您的 == 的实现会发生变化。

您的第二个重载函数没有，因为可以为== 提供任何实现并在将来更改现有实现。

如果您想确保!= 始终与== 相反，请使用第一个（以额外的函数调用为代价，无论如何这很可能会被内联）。

这是一个很好的例子。假设您有一个类 Point2D，其中包含字段 x 和 y。如果要实现==，则必须在字段x 和字段y 上进行比较。如果您通过调用operator== 来实现!=，那么您的代码会更短，并且如果您曾经使用极坐标表示，那么需要更改的函数就会减少。

随着类字段的变化，等式测试和比较总是容易受到维护错误的影响。尽量减少直接访问状态的方法的数量可以降低出错的风险。

Answer 3

版本 #1，恕我直言，虽然语法丑陋，但允许您在一个地方更改相等逻辑（在 == 运算符重载中）。它保证两个重载总是同步的。

Answer 4

我可以想到很多原因（或者可能是同一原因的某些方面）以这种方式编写它。他们都归结为：DRY。

• 确保两个对象始终是== 或!=

• 如果您决定更改类中的内容或用于相等性测试的内容，您只需在一处进行更改

我认为从概念上讲，您在这里定义了两个不同的东西：

• Test 类“平等”的定义

• 一个有用的接口，使用这个类的人可以确定他们的实例是否相等

使用方法 2，您同时进行了临时操作。使用方法 1，您在 operator== 中定义相等，并通过 operator!= 提供接口的其余部分。

一些语言/库更进一步，例如，在 Ruby 中，您可以定义 just <=> 来比较有序对象并混合 Comparable 并获得相等、不等式和 @987654329 @。

Answer 5

一般来说，如下声明：
return !(*this == object);
允许您根据一个函数定义!=。在继承的世界里，子对象只需要定义operator==就可以使用基类operator!=：

struct Base
{
  virtual bool isEqual(const Base& other) const = 0;
  bool  operator==(const Base& other) const
  {
    return isEqual(other);
  }
  bool  operator!=(const Base& other) const
  {
    return !(*this == other);  // Uses Base::operator==
  }
};

使用上述基类，使用!= 定义operator!= 将需要后代实现更多方法。

另外，!(*this == other) 允许为!= 定义一个全局通用函数：

template <typename T>
bool operator!=(const T& a, const T& b)
{
  return !(a == b);
}

虽然这种模式对== 和!= 的作用不大，但使用关系运算符时差异更大：<, <=, >, >=。

Answer 6

一般来说，相互关联地实现相关功能总是更好。对于操作员，总是有组。比如!=可以按照==来实现；后增量可以按照前增量来实现； >、<= 和 >= 可以按照 < 来实现（参见 <utility> 中的 std::rel_ops）等。如果类的某些内容需要更改，您只需要修改核心操作符，并且其余所有内容将自动更新以反映新行为。

所有“辅助”运算符的一般实现总是相同的，因此甚至还有一个库可以自动提供根据少数提供的运算符定义的运算符。见Boost.Operators

你的例子：

#include <boost/operators.hpp>

class Test : boost::equality_comparable<Test, Test>
{
private:
    int iTest;

public:
    bool operator==(const Test& test) const;
    //look, no operator !=
};

int main()
{
    Test a, b;
    a != b; //still works
}