如何定位C++20默认比较运算符(==、<=>)失败对应的结构体成员？

针对使用默认比较运算符的聚合类型（你的示例代码中的struct A、B都属于聚合类型，业务中绝大多数用default ==的简单结构体都符合该定义：无自定义构造函数、无私有非静态成员、无基类、无虚函数），可以通过编译期聚合成员计数+结构化绑定的技巧实现自动成员差异比对，纯标准C++实现，无需修改原有结构体定义。

核心思路 #

• 第一步：利用聚合初始化的语法特性，编译期探测出目标结构体的成员数量
• 第二步：根据成员数量，通过结构化绑定把结构体成员逐个展开，依次对比
• 第三步：遇到嵌套聚合类型时递归执行对比逻辑，非聚合类型直接用==判断，不匹配时输出成员路径和两边的取值

可运行示例代码（C++20标准） #

#include <iostream>
#include <string>
#include <type_traits>

// 辅助工具：编译期探测聚合体成员数量，可根据实际场景扩展最大支持成员数
template<typename T>
constexpr size_t count_members() {
    if constexpr (requires { T{{}, {}, {}, {}, {}, {}, {}, {}}; }) return 8;
    else if constexpr (requires { T{{}, {}, {}, {}, {}, {}, {}}; }) return 7;
    else if constexpr (requires { T{{}, {}, {}, {}, {}, {}}; }) return 6;
    else if constexpr (requires { T{{}, {}, {}, {}, {}}; }) return 5;
    else if constexpr (requires { T{{}, {}, {}, {}}; }) return 4;
    else if constexpr (requires { T{{}, {}, {}}; }) return 3;
    else if constexpr (requires { T{{}, {}}; }) return 2;
    else if constexpr (requires { T{{}}; }) return 1;
    else return 0;
}

// 前置声明对比函数
template<typename T>
bool compare(const T& a, const T& b, std::string path = "");

// 非聚合类型直接对比
template<typename T>
requires (!std::is_aggregate_v<T>)
bool compare(const T& a, const T& b, std::string path) {
    if (a == b) return true;
    std::cout << "不匹配：路径 " << path << "，左边值：" << a << "，右边值：" << b << std::endl;
    return false;
}

// 聚合类型按成员数量展开对比
template<typename T>
requires std::is_aggregate_v<T>
bool compare(const T& a, const T& b, std::string path) {
    constexpr size_t n = count_members<T>();
    if constexpr (n == 2) {
        auto&& [a1, a2] = a;
        auto&& [b1, b2] = b;
        bool ok = true;
        ok &= compare(a1, b1, path + ".[0]");
        ok &= compare(a2, b2, path + ".[1]");
        return ok;
    } else if constexpr (n == 3) {
        auto&& [a1, a2, a3] = a;
        auto&& [b1, b2, b3] = b;
        bool ok = true;
        ok &= compare(a1, b1, path + ".[0]");
        ok &= compare(a2, b2, path + ".[1]");
        ok &= compare(a3, b3, path + ".[2]");
        return ok;
    }
    // 可按需扩展更多成员数量的分支
    return a == b;
}

// 原有结构体完全无需修改
struct A{
    int x;
    int y;
    bool operator == (const A& ) const = default;
};

struct B {
    A a;
    int z;
    bool operator == (const B& ) const = default;
};

int main() {
    B b1{.a{.x=1, .y=2}, .z{3}};
    B b2{.a{.x=1, .y=8472}, .z{3}};
    std::cout << "整体相等？" << std::boolalpha << (b1 == b2) << std::endl;
    std::cout << "差异详情：" << std::endl;
    compare(b1, b2, "b");
}

运行输出 #

整体相等？false
差异详情：
不匹配：路径 b.[0].[1]，左边值：2，右边值：8472

如果需要输出成员名而非索引，可以额外加一个编译期的成员名映射表，和索引一一对应即可。

局限性 #

• 仅支持聚合类型，如果是包含私有成员、自定义构造函数的非聚合类，因为无法通过结构化绑定获取成员，该方案不适用
• 成员数量的探测分支需要提前写好，如果结构体成员数量超过已写的最大分支数，自行补充对应分支即可
• C17环境下可以把requires表达式替换为SFINAE实现相同逻辑，不需要依赖C20

内容的提问来源于stack exchange，提问作者NoSenseEtAl