有没有可能的情况是问关于二的问题 对象相等是有意义的，但是问它们不相等 相等没有意义吗?(无论是从用户的角度，还是从 实现者的角度)

这只是个人观点。也许不是。但是语言的设计者并不是无所不知的，他们决定不限制那些可能想出有意义的情况的人(至少对他们来说)。

当a == b返回bool类型以外的值时，您不会希望语言自动将a != b重写为!(a == b)。有几个原因可以让它这样做。

您可能有表达式构建器对象，其中a == b不会也不打算执行任何比较，而只是构建一些表示a == b的表达式节点。

你可能有惰性求值，其中a == b不会也不打算直接执行任何比较，而是返回某种惰性<bool>，可以在以后的某个时间隐式或显式地转换为bool来实际执行比较。可能与表达式构建器对象结合使用，以便在求值之前完成表达式优化。

你可能有一些自定义的可选<T>模板类，其中给定可选变量T和u，你想允许T == u，但让它返回可选<bool>。

可能还有我没想到的事。即使在这些例子中，操作a == b和a != b都是有意义的，但a != b与!(a == b)不是一回事，因此需要单独的定义。

通过自定义操作符的行为，您可以使它们按照您的要求进行操作。

你可能希望自定义一些东西。例如，您可能希望自定义一个类。可以通过检查特定属性来比较该类的对象。了解了这种情况后，您可以编写一些只检查最小值的特定代码，而不是检查整个对象中每个属性的每一位。

Imagine a case where you can figure out that something is different just as fast, if not faster, than you can find out something is the same. Granted, once you figure out whether something is the same or different, then you can know the opposite simply by flipping a bit. However, flipping that bit is an extra operation. In some cases, when code gets re-executed a lot, saving one operation (multiplied by many times) can have an overall speed increase. (For instance, if you save one operation per pixel of a megapixel screen, then you've just saved a million operations. Multiplied by 60 screens per second, and you save even more operations.)

Hvd的回答提供了一些额外的例子。

有一些非常完善的约定，其中(a == b)和(a != b)都是假的，不一定是相反的。特别地，在SQL中，任何与NULL的比较都会产生NULL，而不是true或false。

如果可能的话，创建这样的新示例可能不是一个好主意，因为这太不直观了，但是如果您试图对现有的约定建模，那么可以选择使您的操作符在该上下文中表现得“正确”。

(. .为什么需要两个不同的定义?

需要考虑的一件事是，实现其中一个操作符可能比仅使用另一个操作符的反求值更有效。

(我这里的例子是垃圾，但重点仍然成立，想想bloom过滤器，例如:它们允许快速测试，如果某些东西不在集合中，但测试它是否在集合中可能需要更多时间。)

(. .根据定义，a != b是!(a == b)。

这是你作为程序员的责任。这可能是编写测试的好方法。

但我担心的是，为什么需要两个不同的定义呢?

你不必同时定义两者。 如果它们是互斥的，您仍然可以通过在std::rel_ops旁边定义==和<来保持简洁

Fom cppreference:

#include <iostream>
#include <utility>

struct Foo {
    int n;
};

bool operator==(const Foo& lhs, const Foo& rhs)
{
    return lhs.n == rhs.n;
}

bool operator<(const Foo& lhs, const Foo& rhs)
{
    return lhs.n < rhs.n;
}

int main()
{
    Foo f1 = {1};
    Foo f2 = {2};
    using namespace std::rel_ops;

    //all work as you would expect
    std::cout << "not equal:     : " << (f1 != f2) << '\n';
    std::cout << "greater:       : " << (f1 > f2) << '\n';
    std::cout << "less equal:    : " << (f1 <= f2) << '\n';
    std::cout << "greater equal: : " << (f1 >= f2) << '\n';
}

有没有可能的情况是问关于二的问题 对象相等是有意义的，但是问它们不相等 相等没有意义吗?

我们经常把这些运算符和相等联系起来。 尽管这是它们在基本类型上的行为方式，但没有义务在自定义数据类型上也是如此。 如果你不想，你甚至不需要返回bool值。

我见过人们以奇怪的方式重载操作符，最后却发现这对特定领域的应用程序是有意义的。即使接口显示它们是互斥的，作者也可能希望添加特定的内部逻辑。

(无论是从用户的角度，还是从实现者的角度)

我知道你想要一个具体的例子， 下面是Catch测试框架中我认为比较实用的一个:

template<typename RhsT>
ResultBuilder& operator == ( RhsT const& rhs ) {
    return captureExpression<Internal::IsEqualTo>( rhs );
}

template<typename RhsT>
ResultBuilder& operator != ( RhsT const& rhs ) {
    return captureExpression<Internal::IsNotEqualTo>( rhs );
}

这些操作符做不同的事情，将一个方法定义为另一个方法的!(不是)是没有意义的。这样做的原因是，框架可以打印出所做的比较。为了做到这一点，它需要捕获所使用的重载操作符的上下文。