如何实现C++聚合结构的（中）相等运算符？

Question

有时我有这样的结构 --

struct aggregate1 {
  std::string name;
  std::vector<ValueT> options;
  size_t foobar;
  // ...
};

-- 其中（内）相等简单地定义为所有成员的（内）相等： lhs_name == rhs_name && lhs_options == rhs_options && lhs_foobar == rhs_foobar。

实现这一点的“最佳”方法是什么？ （最好是：（运行时-）效率、可维护性、可读性）

• operator== 就 operator!= 而言
• operator!= 而言operator== 的
• == 和 != 的单独实现
• 作为成员函数还是作为自由函数？

请注意，这个问题仅涉及（内）相等操作，因为比较 (<, <=, ...) 对于这样的聚合体。

Answer 1

我会这样做，但可能会将operator==定义移动到cpp文件中。将运算符！=保留为内联

记住首先比较最有可能不同的成员变量，以便其余的成员变量被短路并且性能更好。

struct aggregate1 {
  bool operator==(const aggregate1& rhs) const
  {
     return (name == rhs.name)
     && (options == rhs.options)
     && (foobar == rhs.foobar);
  }
  bool operator!=(const aggregate1& rhs) const
  {
    return !operator==(rhs);
  }

  std::string name;
  std::vector<ValueT> options;
  size_t foobar;

  // ...
};

Answer 2

成员函数或自由函数是一个品味问题，在我看来，单独编写 == 和 != 的实现似乎很无聊，而且容易出错（您可能会忘记一个成员）两个运算符之一，并且需要时间才能注意到），而不会在效率方面增加任何内容（调用另一个运算符并应用 ! 的成本可以忽略不计）。

该决定仅限于“用 operator!= 实现 operator== 更好还是相反？

在我看来，从可维护性/可读性/效率角度来看是一样的；为了保持一致性，我只建议在任何地方都以相同的方式进行操作，唯一需要使用其中一个作为“基本运算符”的情况是当您知道这一点时。 ，在结构中包含的类型中，该运算符比其否定更快，但我不知道什么时候会发生这种情况。

Answer 3

在 C++20 中，实现相等和不等运算符可以像将 operator== 声明为 default 一样简单：

struct S {
  int x;
  // ...

  // As member function
  bool operator==(S const &) const = default;
  
  // As non-member function (hidden friend)
  // friend bool operator==(S const &, S const &) = default;
};

如果只有 operator== 是假设，a!=b 根据重载解析被解释为 !(a==b)，因此不需要为 运算符提供显式重载!=。

我认为默认 operator== 作为隐藏友元更好，因为它适用于引用包装的对象：

S s;
auto rs{std::ref(s)};
rs==rs; // OK for hidden friend; ill-formed if declared as member function

在此示例中，operator== 没有为 std::reference_wrapper，但参数相关查找 (ADL) 可以选择隐藏友元，其操作数隐式转换为 S const &。但请注意，::operator==(rs,rs) 仅当 operator== 被定义为自由函数时才起作用，因为限定名称不会触发 ADL 。

Answer 4

恕我直言，以朋友的身份实现并实现 operator== （例如，某些 STL 算法将依赖于此），并且 operator!= 应实现为等于的否定操作员。

Answer 5

（-：自我回答：-）

我想强调聚合 WRT 效率的一个方面：

op== 和 op!=< 的评估顺序/code> 与（平均）性能无关。

假设现在单独实现，并给出两个极端 (a-eq) 所有子元素相等和 (b-neq) 所有子元素不相等，我们有以下情况：

• (a-eq) + operator== ：需要比较所有子元素以返回 true
• (a-eq) + operator!= ：需要比较所有子元素以返回 false
• ( b-neq) + operator== ：确定第一个子元素不相等后返回 false
• (b-neq) + operator!= ：确定第一个子元素后返回 true不相等

由于无论哪种方式，平均性能都是相同的，至少对我来说，根据 op== 实现 op!= 似乎更自然，因为它我觉得实施平等行动更自然。