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

Question

我非常喜欢让编译器为您做尽可能多的工作。在编写一个简单的类时，编译器可以“免费”为您提供以下内容：

• 默认（空）构造函数
• 复制构造函数
• 析构函数
• 赋值运算符 (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
{ }

这样做有充分的理由吗？为什么执行逐个成员的比较会成为问题？显然，如果该类分配内存，那么您要小心，但是对于一个简单的类，编译器肯定可以为您做到这一点吗？

Answer 1

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

我曾经有一个 POD 案例，其中两个字段是唯一的 - 所以比较永远不会被认为是正确的。然而，我只需要在有效负载上进行比较 - 编译器永远无法理解或无法自己弄清楚。

此外，他们不会花很长时间来写吗？！

Answer 2

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

不实现它并让程序员自己做会更安全。然后他们可以做出他们喜欢的所有假设。

Answer 3

C++0x has 有一个关于默认函数的提议，所以你可以说default operator==; 我们了解到，将这些内容明确化是有帮助的。

Answer 4

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

除此之外，默认函数是自爆的绝佳方法。您描述的默认值基本上是为了保持与 POD 结构的兼容性。然而，它们确实会造成足够多的破坏，让开发人员忘记它们或默认实现的语义。

Answer 5

无法定义默认==，但您可以通过通常应该自己定义的== 定义默认!=。 为此，您应该做以下事情：

#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 中使用的方法更好，因为它为您只需要的类定义了运算符的用法，而不是针对范围内的所有类。

您还可以从“+=”生成“+”，从“-=”生成-等等...（参见完整列表here）

Answer 6

如果编译器可以提供默认的复制构造函数，它应该能够提供类似的默认operator==() 的论点有一定的意义。我认为决定不为该运算符提供编译器生成的默认值的原因可以通过 Stroustrup 在“C++ 的设计和演变”（第 11.4.1 节 - 复制控制）中关于默认复制构造函数的说法来猜测。 ：

我个人认为这很不幸 复制操作定义为 默认，我禁止复制 我的许多班级的对象。 但是，C++ 继承了它的默认值 赋值和复制构造函数 C，它们经常被使用。

因此，问题应该是“为什么 C++ 有默认赋值和复制构造函数？”而不是“为什么 C++ 没有默认的 operator==()？”，答案是这些项目不情愿地包含在Stroustrup 与 C 向后兼容（可能是大多数 C++ 缺陷的原因，但也可能是 C++ 流行的主要原因）。

出于我自己的目的，在我的 IDE 中，我用于新类的 sn-p 包含对私有赋值运算符和复制构造函数的声明，因此当我生成一个新类时，我不会得到默认赋值和复制操作 - 我有如果我希望编译器能够为我生成这些操作的声明，则从 private: 部分显式删除这些操作的声明。

Answer 7

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

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

Answer 8

答案是 C++ 没有做 == 因为 C 没有，这就是为什么 C 只提供默认 = 而首先不提供 == 的原因。 C 想保持简单： C 实现 = 通过 memcpy；但是，由于填充，== 无法由 memcmp 实现。 因为填充没有初始化，所以 memcmp 说它们是不同的，即使它们是相同的。 空类也存在同样的问题：memcmp 说它们是不同的，因为空类的大小不为零。 从上面可以看出，实现 == 比在 C 中实现 = 更复杂。 关于此的一些代码example。 如果我错了，感谢您的指正。

Answer 9

在videoAlex Stepanov 中，STL 的创建者在 13:00 左右解决了这个问题。总而言之，在观察了 C++ 的演变之后，他认为：

• 不幸的是，== 和 != 没有被隐式声明（Bjarne 同意他的观点）。正确的语言应该为你准备好这些东西（他进一步建议你不应该定义一个破坏 == 语义的 !=）
• 出现这种情况的原因（与许多 C++ 问题一样）源于 C。在那里，赋值运算符是使用 逐位赋值 隐式定义的，但这不适用于 ==。可以在 Bjarne Stroustrup 的 article 中找到更详细的解释。
• 在后续问题 为什么不使用逐个成员的比较，他说了一个令人惊奇的事情：C 是一种本土语言，是实现的人里奇的这些东西告诉他，他发现这很难实施！

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

Answer 10

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

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

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

但您将获得显式默认==since 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== 以及 == 和 != 之间的对称性）来自 one proposal，它是更广泛的语言功能 operator<=> 的一部分。

Answer 11

这样做有充分的理由吗？为什么逐个成员比较会成为问题？

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

考虑这个例子，其中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
    }
}

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

Answer 12

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<=>

Answer 13

只是为了让这个问题的答案随着时间的推移而保持完整：从 C++20 开始，它可以使用命令 auto operator<=>(const foo&) const = default; 自动生成

它将生成所有运算符：==、!=、 和 >=，详情请参阅https://en.cppreference.com/w/cpp/language/default_comparisons。

由于操作员的外观<=>，它被称为宇宙飞船操作员。另见Why do we need the spaceship <=> operator in 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 适用于所有比较运算符，并被编译器完全优化掉。