==和！=是否相互依赖？

我正在学习C ++中的运算符重载，我看到了==，!=它们只是一些可以针对用户定义的类型进行自定义的特殊功能。但是，我担心的是，为什么需要两个单独的定义？我认为如果a == b为true，则a != b自动为false，反之亦然，并且没有其他可能性，因为根据定义，a != b为!(a == b)。而且我无法想象任何情况都不是真的。但是也许我的想象力有限，或者我什么都不知道？

我知道我可以用另一个来定义，但这不是我要问的。我也没有问比较按值或按身份比较对象之间的区别。或者两个对象是否可以同时相等和不相等（这绝对不是选择！这些东西是互斥的）。我要问的是：

是否有可能问到关于两个对象相等的问题是有意义的，而问他们不相等是没有意义的呢？（从用户角度或从实施者角度）

如果没有这种可能性，那么为什么在地球上C ++会将这两个运算符定义为两个不同的函数？

您不希望该语言自动重写a != b为!(a == b)当a == b比其他收益东西bool。并且有一些原因使您可以做到这一点。

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

您可能有一个懒惰的评估，在这里a == b不打算也不打算直接执行任何比较，而是返回某种lazy<bool>可以bool在以后的某个时间隐式或显式转换为实际执行比较的结果。可能与表达式构建器对象结合使用，以允许在评估之前进行完整的表达式优化。

您可能有一些自定义optional<T>模板类，其中给定了可选变量，t并且u您希望允许t == u，但要使其返回optional<bool>。

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

如果没有这种可能性，那么为什么在地球上C ++会将这两个运算符定义为两个不同的函数？

因为您可以使它们过载，并且通过使它们过载，您可以赋予它们与原始含义完全不同的含义。

以operator为例，<<最初是按位左移运算符，现在通常像in一样重载为插入运算符std::cout << something。与原始含义完全不同。

因此，如果您接受运算符的含义在重载时会发生变化，那么就没有理由阻止用户给运算符赋予的含义==并不完全是对运算符的否定!=，尽管这可能会造成混淆。

但是，我担心的是，为什么需要两个单独的定义？

您不必同时定义两者。
如果它们是互斥的，那么您仍然可以通过仅定义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';
}

是否有可能问到关于两个对象相等的问题是有意义的，而问他们不相等是没有意义的呢？

我们经常将这些运算符与平等联系在一起。
尽管这是它们在基本类型上的行为，但没有义务将其作为自定义数据类型的行为。如果您不想这样做，甚至不需要退还布尔值。

我见过人们以奇怪的方式重载运算符，却发现这对于他们的特定于域的应用有意义。即使界面似乎表明它们是互斥的，作者也可能想添加特定的内部逻辑。

（从用户角度或从实施者角度）

我知道您想要一个特定的示例，
因此这是我认为实用的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 );
}

这些运算符在做不同的事情，将一个方法定义为另一种方法（不是）是没有意义的。这样做的原因是为了使框架可以打印出进行的比较。为此，它需要捕获所使用的重载运算符的上下文。

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

如果可能的话，尽可能地创建一个新的示例可能不是一个好主意，因为它很不直观，但是如果您要对现有的约定进行建模，那么可以选择让操作员对此“正确地表现”是很好的选择。上下文。

我只会回答您问题的第二部分：

如果没有这种可能性，那么为什么在地球上C ++会将这两个运算符定义为两个不同的函数？

允许开发人员重载两者的原因之一就是性能。您可以同时实现==和来允许优化!=。那x != y可能比!(x == y)现在。一些编译器可能能够为您优化它，但也许没有，特别是如果您有涉及很多分支的复杂对象。

即使在Haskell（开发人员非常重视法律和数学概念）中，仍然可以允许它们重载==和/=，如您在此处所见（http://hackage.haskell.org/package/base-4.9.0.0/docs/Prelude .html＃v：-61--61-）：

$ ghci
GHCi, version 7.10.2: http://www.haskell.org/ghc/  :? for help
λ> :i Eq
class Eq a where
  (==) :: a -> a -> Bool
  (/=) :: a -> a -> Bool
        -- Defined in `GHC.Classes'

这可能被认为是微优化，但是在某些情况下可能是必要的。

是否有可能问到关于两个对象相等的问题是有意义的，而问他们不相等是没有意义的呢？（从用户角度或从实施者角度）

那是一个意见。也许不是。但是语言设计人员并非全知，决定不限制可能提出合理建议的人（至少对他们而言）。

响应编辑；

就是说，如果某种类型可能有运算符==而不是!=，反之亦然，那么什么时候才有意义。

在一般的，不，这是没有意义的。平等和关系运算符通常成对出现。如果存在平等，那么不平等也是如此。小于，然后大于，等等。<=等等。类似的方法也应用于算术运算符，它们通常也属于自然逻辑集。

这在std::rel_ops命名空间中得到了证明。如果实现等于且小于运算符，则使用该命名空间将为您提供其他名称，这些名称空间是根据原始实现的运算符实现的。

综上所述，是否存在一个条件或情况，其中一个不会立即意味着另一个，或者无法就另一个实施？是的，可以说是很少，但是他们在那里。再次，如rel_ops了自己是一个名称空间。因此，允许它们独立实现可以使您利用该语言来获得所需或所需要的语义，这种方式对于代码的用户或客户而言仍然是自然而直观的。

已经提到的惰性评估就是一个很好的例子。另一个很好的例子是给他们提供根本不等于平等或不平等的语义。与此类似的示例是位移运算符<<，>>它用于流插入和提取。尽管它可能在一般圈子中不被接受，但在某些特定领域，它可能是有意义的。

如果==and !=运算符实际上并不暗示相等，则与<<and >>流运算符并不暗示位移相同。如果将符号当作其他含义使用，则它们不必相互排斥。

就相等性而言，如果用例保证将对象视为不可比较的对象，则是有意义的，因此每个比较都应返回false（如果运算符返回非布尔值，则返回比较结果类型）。我无法想到有什么必要的具体情况，但我可以看到它足够合理。

强大的能力会负责任地发挥作用，或者至少是非常好的样式指南。

==并且!=可以超负荷执行您想要的任何操作。这既是福也是祸。没有保证!=意味着!(a==b)。

enum BoolPlus {
    kFalse = 0,
    kTrue = 1,
    kFileNotFound = -1
}

BoolPlus operator==(File& other);
BoolPlus operator!=(File& other);

我无法证明此运算符重载是合理的，但是在上面的示例中，不可能将其定义operator!=为的“相反” operator==。

最后，您要使用这些运算符检查的是该表达式a == b或a != b正在返回布尔值（true或false）。这些表达式在比较后返回布尔值，而不是互斥的。

[..]为什么需要两个单独的定义？

要考虑的一件事是，可能存在比仅使用另一个运算符更有效地实现其中一个运算符的可能性。

（我的示例在这里是垃圾，但问题仍然存在，例如，考虑使用bloom过滤器：如果不包含某些内容，它们可以快速测试，但是如果要放入其中，则可能需要花费更多时间。）

[..]的定义a != b是!(a == b)。

作为程序员，这是您的责任。编写测试可能是一件好事。

通过自定义操作员的行为，可以使他们做自己想要的事情。

您可能希望自定义内容。例如，您可能希望自定义一个类。可以通过检查特定属性来比较此类的对象。知道是这种情况，您可以编写一些特定的代码，仅检查最少的内容，而不用检查整个对象中每个属性的每个位。

想象一下这样一种情况，您可以发现某些不同之处与发现某些相同之处一样快（如果不是更快）。当然，一旦弄清楚某个事物是相同还是不同，那么只需翻转一下就可以知道相反的事物。但是，翻转该位是额外的操作。在某些情况下，当大量代码重新执行时，节省一个操作（乘以多次）可以总体上提高速度。（例如，如果您在一个百万像素屏幕的每个像素上保存一个操作，那么您只保存了一百万个操作。乘以每秒60个屏幕，则可以保存更多的操作。）

hvd的答案提供了一些其他示例。

是的，因为一个表示“等效”，另一个表示“非等效”，并且此术语互斥。此运算符的任何其他含义都令人困惑，因此应尽量避免使用。

也许不可比的规则，即a != b是虚假的和a == b是假的就像无状态的一样。

if( !(a == b || a != b) ){
    // Stateless
}