为什么C ++编译器不定义operator ==和operator！=？

我非常乐于让编译器为您完成尽可能多的工作。在编写简单的类时，编译器可以为您提供以下“免费”功能：

• 默认（空）构造函数
• 复制构造函数
• 析构函数
• 赋值运算符（operator=）

但这似乎无法为您提供任何比较运算符-例如operator==或operator!=。例如：

class foo
{
public:
    std::string str_;
    int n_;
};

foo f1;        // Works
foo f2(f1);    // Works
foo f3;
f3 = f2;       // Works

if (f3 == f2)  // Fails
{ }

if (f3 != f2)  // Fails
{ }

是否有充分的理由呢？为什么进行逐成员比较会是一个问题？显然，如果该类分配了内存，那么您要格外小心，但是对于简单的类，编译器肯定可以为您执行此操作吗？

编译器不会知道您要进行指针比较还是深度（内部）比较。

只执行而不让程序员自己做是比较安全的。然后他们可以做出所有喜欢的假设。

如果编译器可以提供默认的副本构造函数，那么它应该能够提供类似的默认值的说法operator==()具有一定意义。我认为，决定不提供此运算符生成的编译器默认值的原因可以由Stroustrup在“ C ++的设计和演变”（第11.4.1节-复制控制）中对默认副本构造函数的说明中猜到。 ：

我个人认为很遗憾，默认情况下定义了复制操作，并且禁止复制许多类的对象。但是，C ++从C继承了其默认赋值和复制构造函数，并且它们经常使用。

因此operator==()，问题应该是“为什么C ++具有默认的赋值和复制构造函数？”，而不是“为什么C ++没有默认的？”，答案是Stroustrup勉强地包含了这些项，以便与C向后兼容。 （可能是大多数C ++疣的原因，但也可能是C ++普及的主要原因）。

出于我自己的目的，在我的IDE中，我用于新类的代码段包含一个私有赋值运算符和复制构造函数的声明，以便在生成新类时没有默认赋值和复制操作-我必须显式删除该声明private:如果我希望编译器能够为我生成这些操作，请参阅本节中的这些操作。

即使在C ++ 20中，编译器仍不会operator==为您隐式生成

struct foo
{
    std::string str;
    int n;
};

assert(foo{"Anton", 1} == foo{"Anton", 1}); // ill-formed

但是从C ++ 20开始，您将拥有显式默认的== 功能：

struct foo
{
    std::string str;
    int n;

    // either member form
    bool operator==(foo const&) const = default;
    // ... or friend form
    friend bool operator==(foo const&, foo const&) = default;
};

默认值==是按成员进行的==（与默认副本构造函数按成员进行复制的方式相同）。新规则还提供==和之间的预期关系!=。例如，使用上面的声明，我可以同时编写：

assert(foo{"Anton", 1} == foo{"Anton", 1}); // ok!
assert(foo{"Anton", 1} != foo{"Anton", 2}); // ok!

这种特殊的功能（默认operator==和之间的对称==和!=）来自一个建议，这是更广泛的语言特点，那就是的一部分operator<=>。

恕我直言，没有“好的”理由。之所以有很多人同意这一设计决策，是因为他们没有学会掌握基于价值的语义的力量。人们需要编写许多自定义副本构造函数，比较运算符和析构函数，因为他们在实现中使用原始指针。

当使用适当的智能指针（如std :: shared_ptr）时，默认复制构造函数通常很好，并且假设的默认比较运算符的明显实现也可以。

答案是C ++没做==，因为C没做，这就是为什么C首先只提供default =而不提供==的原因。C希望保持简单：C实现=通过memcpy; 但是，由于填充，memcmp无法实现==。由于填充未初始化，因此memcmp表示它们是不同的，即使它们相同。空类存在相同的问题：memcmp表示它们不同，因为空类的大小不为零。从上面可以看出，实现==比在C中实现=更复杂。一些与此相关的代码示例。如果我错了，请多多指教。

在此视频中，STL的创建者Alex Stepanov在13:00左右解决了这个问题。总而言之，在观察了C ++的发展之后，他认为：

• 不幸的是==和！=没有隐式声明（Bjarne同意他的观点）。正确的语言应该已经为您准备好了这些（他进一步建议您不应该定义！=来破坏==的语义）
• 这种情况的原因源于C（与许多C ++问题一样）。在那里，赋值运算符是通过一点一点的赋值隐式定义的，但不适用于==。可以从Bjarne Stroustrup的这篇文章中找到更详细的解释。
• 在随后的问题中，为什么没有按成员进行比较，他说了一件令人惊讶的事情：C是一种本地语言，为Ritchie实现这些东西的家伙告诉他，他发现这很难实现！

然后他说，在（遥远的）未来==和！=将隐式生成。

C ++ 20提供了一种轻松实现默认比较运算符的方法。

来自cppreference.com的示例：

class Point {
    int x;
    int y;
public:
    auto operator<=>(const Point&) const = default;
    // ... non-comparison functions ...
};

// compiler implicitly declares operator== and all four relational operators work
Point pt1, pt2;
if (pt1 == pt2) { /*...*/ } // ok, calls implicit Point::operator==
std::set<Point> s; // ok
s.insert(pt1); // ok
if (pt1 <= pt2) { /*...*/ } // ok, makes only a single call to Point::operator<=>

这是不可能的定义默认==，但你可以定义默认!=通过==，你通常应该定义自己。为此，您应该执行以下操作：

#include <utility>
using namespace std::rel_ops;
...

class FooClass
{
public:
  bool operator== (const FooClass& other) const {
  // ...
  }
};

有关详细信息，请参见http://www.cplusplus.com/reference/std/utility/rel_ops/。

此外，如果定义operator< ，则在使用时可以从中推导出<=，>，> =的运算符std::rel_ops。

但是，使用时请务必小心，std::rel_ops因为可以推导出不需要的类型的比较运算符。

从基础推论出相关运算符的更优选方法是使用boost :: operators。

boost中使用的方法更好，因为它为仅想要的类而不是作用域中的所有类定义了运算符的用法。

您还可以从“ + =”生成“ +”，从-=生成-，等等...（在此处查看完整列表）

的C ++ 0x 已经有默认功能的建议，所以你可以说default operator==; 我们已经了解到，它有助于使这些东西明确。

从概念上讲，定义平等并不容易。即使对于POD数据，也可能会争辩说，即使字段相同，但它是一个不同的对象（位于不同的地址），也不一定相等。这实际上取决于操作员的用法。不幸的是，您的编译器并不灵通，无法推断出这一点。

除此之外，默认功能是脚踩自己的好方法。您描述的默认值基本上可以保证与POD结构的兼容性。但是，它们的确给开发人员造成了极大的破坏，使他们忘记了它们或默认实现的语义。

是否有充分的理由呢？为什么进行逐成员比较会是一个问题？

从功能上讲这可能不是问题，但是就性能而言，默认的逐个成员比较比默认的逐个成员分配/复制更次优。与分配顺序不同，比较顺序会影响性能，因为第一个不相等的成员意味着可以跳过其余的成员。因此，如果有一些通常相等的成员，则您要最后比较它们，而编译器不知道哪些成员更可能相等。

考虑这个例子，在哪里verboseDescription从一个相对较小的可能天气描述集中选择了一个长字符串。

class LocalWeatherRecord {
    std::string verboseDescription;
    std::tm date;
    bool operator==(const LocalWeatherRecord& other){
        return date==other.date
            && verboseDescription==other.verboseDescription;
    // The above makes a lot more sense than
     // return verboseDescription==other.verboseDescription
     //     && date==other.date;
    // because some verboseDescriptions are liable to be same/similar
    }
}

（当然，如果编译器认识到它们没有副作用，则有权忽略比较的顺序，但是大概它仍然可以从源代码中获取信息，因为它本身没有更好的信息。）

只是为了使这个问题的答案随着时间的流逝保持完整：由于C ++ 20可以使用命令自动生成 auto operator<=>(const foo&) const = default;

它将生成所有运算符：==，！=，<，<=，>和> =，有关详细信息，请参见https://en.cppreference.com/w/cpp/language/default_comparisons。

由于操作员的外观<=>，它称为太空飞船操作员。另请参见为什么在C ++中我们需要飞船<=>运算符？。

编辑：在C ++ 11中，还可以用 std::tie看到https://en.cppreference.com/w/cpp/utility/tuple/tie与一个完整的代码示例bool operator<(…)。更改为可使用的有趣部分==是：

#include <tuple>

struct S {
………
bool operator==(const S& rhs) const
    {
        // compares n to rhs.n,
        // then s to rhs.s,
        // then d to rhs.d
        return std::tie(n, s, d) == std::tie(rhs.n, rhs.s, rhs.d);
    }
};

std::tie 与所有比较运算符一起使用，并且完全被编译器优化。

我同意，对于POD类型类，编译器可以为您完成。但是，您可能认为简单的编译器可能会出错。因此，最好让程序员来做。

我曾经有过一次POD案例，其中两个字段是唯一的-因此，比较永远不会被认为是正确的。但是，我只需要在有效负载上进行比较，这是编译器永远无法理解或无法自行解决的。

此外-他们不需要花很多时间来写吗？