比较 C++ 中的结构时未找到 == 运算符

Question

比较以下结构的两个实例，我收到一个错误：

struct MyStruct1 {
    MyStruct1(const MyStruct2 &_my_struct_2, const int _an_int = -1) :
        my_struct_2(_my_struct_2),
        an_int(_an_int)
    {}

    std::string toString() const;

    MyStruct2 my_struct_2;
    int an_int;
};

错误是：

错误 C2678：二进制“==”：无运算符 发现它需要一个左手操作数 类型为“myproj::MyStruct1”（或者 是不可接受的转换）

为什么？

Answer 1

在 C++ 中，struct 默认情况下不生成比较运算符。您需要编写自己的：

bool operator==(const MyStruct1& lhs, const MyStruct1& rhs)
{
    return /* your comparison code goes here */
}

Answer 2

C++20 引入了默认比较，又名“太空飞船”运算符<=> ，它允许您请求编译器生成的</<=/==/!=/>=/ 和/或 > 运算符，具有明显/天真的（？）实现......

auto operator<=>(const MyClass&) const = default;

但是你可以针对更复杂的情况进行自定义（下面讨论）。请参阅此处了解语言提案，其中包含理由和讨论。这个答案仍然与 C++17 及更早版本相关，并深入了解何时应该自定义 operator<=> 的实现....

C++ 不这样做似乎有点无益之前已经对此进行了标准化，但结构/类通常有一些数据成员要从比较中排除（例如计数器、缓存结果、容器容量、上次操作成功/错误代码、游标），以及< strong>对无数事情做出的决定，包括但不限于：

• 首先比较哪些字段，例如比较特定的int成员可能会很快消除99％的不相等对象，而< code>map 成员可能通常具有相同的条目，并且比较成本相对较高 - 如果在运行时加载值，程序员可能会获得编译器
• 在比较字符串时不可能获得的见解：区分大小写、空白和分隔符的等价性、转义约定...
• 比较浮点数/双精度数时的精度
• NaN 浮点值是否应被视为相等
• 比较指针或指向数据（如果是后者，如何知道指针是否指向数据）数组以及需要比较的对象/字节的数量）
• 在比较未排序的容器（例如 vector、list）时顺序是否重要，如果是，是否可以对它们进行排序 -在比较之前放置 vs. 每次进行比较时使用额外内存对临时对象进行排序
• 有多少数组元素当前保存了应该比较的有效值（某处是否有大小或哨兵？）
• 联合体的哪个成员code> 来比较
• 标准化：例如，日期类型可能允许超出范围的月份或月份，或者有理数/分数对象可能有 6/8，而另一个有 3/4，这对于出于性能原因，他们通过单独的标准化步骤来延迟纠正；您可能必须在比较之前决定是否触发规范化
• 当弱指针无效时该怎么做
• 如何处理本身没有实现 operator== 的成员和基类（但可能有 compare() 或 operator< 或 str() 或 getters...)
• 在读取/比较其他线程可能想要的数据时必须采取哪些锁定因此

，在您明确考虑比较对您的特定结构意味着什么之前，有一个错误是件好事，而不是让它编译但不会给您一个有意义的结果在运行时。

话虽如此，如果 C++ 让您在决定“天真的”逐个成员 == 时说 bool operator==() const = default; ，那就太好了 测试没问题。与 != 相同。给定多个成员/基础，“默认”<、<=、> 和 >= > 尽管实现似乎无望 - 基于声明顺序的级联是可能的，但不太可能是想要的，因为成员排序的命令相互冲突（基数必须在成员之前，按可访问性分组，在依赖使用之前构建/销毁）。为了更广泛地使用，C++ 需要一个新的数据成员/基本注释系统来指导选择 - 不过，这在标准中是一件很棒的事情，最好与基于 AST 的用户定义代码生成相结合......我希望有一天它会发生。

相等运算符的典型实现

合理的实现

合理且高效的实现可能是：

inline bool operator==(const MyStruct1& lhs, const MyStruct1& rhs)
{
    return lhs.my_struct2 == rhs.my_struct2 &&
           lhs.an_int     == rhs.an_int;
}

请注意，这需要 MyStruct2 的 operator==也。

此实现的含义和替代方案将在下面的标题讨论 MyStruct1 下进行讨论。

==、<、> 的一致方法<= 等

利用 std::tuple 的比较运算符来比较您自己的类实例很容易 - 只需使用 std::tie 创建字段引用的元组按照所需的比较顺序。从此处概括我的示例：

inline bool operator==(const MyStruct1& lhs, const MyStruct1& rhs)
{
    return std::tie(lhs.my_struct2, lhs.an_int) ==
           std::tie(rhs.my_struct2, rhs.an_int);
}

inline bool operator<(const MyStruct1& lhs, const MyStruct1& rhs)
{
    return std::tie(lhs.my_struct2, lhs.an_int) <
           std::tie(rhs.my_struct2, rhs.an_int);
}

// ...etc...

当您“拥有”（即可以编辑企业和第三方库的因素）时对于您想要比较的类，尤其是 C++14 已准备好从 return 语句推断函数返回类型，向您希望能够比较的类添加一个“tie”成员函数通常会更好比较：

auto tie() const { return std::tie(my_struct1, an_int); }

那么上面的比较简化为：

inline bool operator==(const MyStruct1& lhs, const MyStruct1& rhs)
{
    return lhs.tie() == rhs.tie();
}

如果您想要一组更完整的比较运算符，我建议 增强运算符（搜索less_than_comparable）。如果由于某种原因不适合，您可能喜欢也可能不喜欢支持宏的想法（在线）:

#define TIED_OP(STRUCT, OP, GET_FIELDS) \
    inline bool operator OP(const STRUCT& lhs, const STRUCT& rhs) \
    { \
        return std::tie(GET_FIELDS(lhs)) OP std::tie(GET_FIELDS(rhs)); \
    }

#define TIED_COMPARISONS(STRUCT, GET_FIELDS) \
    TIED_OP(STRUCT, ==, GET_FIELDS) \
    TIED_OP(STRUCT, !=, GET_FIELDS) \
    TIED_OP(STRUCT, <, GET_FIELDS) \
    TIED_OP(STRUCT, <=, GET_FIELDS) \
    TIED_OP(STRUCT, >=, GET_FIELDS) \
    TIED_OP(STRUCT, >, GET_FIELDS)

...然后可以使用...

#define MY_STRUCT_FIELDS(X) X.my_struct2, X.an_int
TIED_COMPARISONS(MyStruct1, MY_STRUCT_FIELDS)

(C++14 成员绑定版本 此处）

讨论 MyStruct1 的细节 对于

选择提供独立式与成员 operator==() 的选择有影响...

独立式实现

您需要做出一个有趣的决定。由于您的类可以从 MyStruct2 隐式构造，因此独立/非成员 bool 运算符 ==(const MyStruct2& lhs, const MyStruct2& rhs) 函数将支持...

my_MyStruct2 == my_MyStruct1

...首先从 my_myStruct2 创建临时 MyStruct1，然后进行比较。这肯定会将 MyStruct1::an_int 设置为构造函数的默认参数值 -1。根据您是否在 operator== 的实现中包含 an_int 比较，MyStruct1 可能会或可能不等于 MyStruct2 本身与 MyStruct1 的 my_struct_2 成员相等！此外，创建临时 MyStruct1 可能是一种非常低效的操作，因为它涉及将现有 my_struct2 成员复制到临时成员，然后在比较后将其丢弃。 （当然，您可以通过使构造函数显式或删除an_int的默认值来防止这种隐式构造MyStruct1进行比较。）

成员实现

如果您想避免从 MyStruct2 隐式构造 MyStruct1，请将比较运算符设为成员函数：

struct MyStruct1
{
    ...
    bool operator==(const MyStruct1& rhs) const
    {
        return tie() == rhs.tie(); // or another approach as above
    }
};

请注意 const 关键字 - 仅在成员实现时需要 - 建议编译器比较对象不会修改它们，因此可以在 const 对象上使用。

比较可见的表示

有时，获得您想要的比较的最简单方法可以是......

    return lhs.to_string() == rhs.to_string();

这通常也非常昂贵 - 那些痛苦地创建的字符串只是为了被丢弃！对于具有浮点值的类型，比较可见表示意味着显示的位数决定了比较过程中将几乎相等的值视为相等的容差。

Answer 3

您需要为 MyStruct1 显式定义 operator ==。

struct MyStruct1 {
  bool operator == (const MyStruct1 &rhs) const
  { /* your logic for comparision between "*this" and "rhs" */ }
};

现在 == 比较对于 2 个这样的对象是合法的。

Answer 4

从 C++20 开始，应该可以通过声明向类添加一整套默认比较运算符（==、<= 等） 默认三向比较运算符（“spaceship”运算符），如下所示：

struct Point {
    int x;
    int y;
    auto operator<=>(const Point&) const = default;
};

使用兼容的 C++20 编译器，假设 MyStruct2 的定义是兼容的，将该行添加到 MyStruct1 和 MyStruct2 可能足以允许相等比较。

Answer 5

默认情况下，结构体没有 == 运算符。您必须编写自己的实现：

bool MyStruct1::operator==(const MyStruct1 &other) const {
    ...  // Compare the values, and return a bool result.
  }

Answer 6

开箱即用的 == 运算符仅适用于基元。为了让您的代码正常工作，您需要重载结构体的 == 运算符。

Answer 7

因为您没有为结构编写比较运算符。编译器不会为你生成它，所以如果你想要比较，你必须自己编写它。

Answer 8

比较不适用于 C 或 C++ 中的结构。而是按字段进行比较。