C++继承体系中默认operator==引发的无限递归问题解析

在 C++ 面向对象编程中，利用虚函数实现多态是再常见不过的设计。然而，当你尝试为继承体系添加比较操作时，一个关于默认operator==的陷阱可能正在等你。最近就遇到了一个由这种设计模式引发的、颇具迷惑性的无限递归 Bug。

我们来逐步还原这个场景。首先，定义一个抽象基类 Base，它包含一个纯虚的相等比较运算符：

struct Base {
    virtual ~Base() = default;
    virtual auto operator==(const Base &) const -> bool = 0;
};

接着，我们定义一个派生类 Derived。它需要实现基类的虚函数 operator==，同时为了比较同类型对象方便，我们也希望它能使用编译器生成的默认成员比较。一种常见的实现思路是使用 typeid 进行运行时类型检查：

struct Derived : Base {
    int m1;
    int m2;
    // ...

    auto operator==(const Base &rhs) const -> bool override {
        if (typeid(rhs) == typeid(Derived)) {
            return *this == static_cast<const Derived&>(rhs);
        } else {
            return false;
        }
    }

    auto operator==(const Derived& rhs) const -> bool = default;
};

此时，如果存在另一个更深层次的派生类 SuperDerived，其逻辑与 Derived 高度相似：

struct SuperDerived : Derived {
    int m3;

    auto operator==(const Base& rhs) const -> bool override {
        if (typeid(rhs) == typeid(SuperDerived)) {
            return *this == static_cast<const SuperDerived&>(rhs);
        }
        return false;
    }

    auto operator==(const SuperDerived&) const -> bool = default;
};

看到代码中的重复模式了吗？我们自然想到了使用模板来提炼通用逻辑：

template <class D>
bool Equality(const D& lhs, const Base& rhs){
    if (typeid(rhs) == typeid(D)) {
        return lhs == static_cast<const D&>(rhs);
    }
    return false;
}

这样，派生类的实现就能得到简化：

struct Derived : Base {
    int m1;
    int m2;
    // ...

    auto operator==(const Base & rhs) const -> bool override {
        return Equality(*this, rhs);
    }

    auto operator==(const Derived& rhs) const -> bool = default;
};

struct SuperDerived : Derived {
    int m3;

    auto operator==(const Base& rhs) const -> bool override {
        return Equality(*this, rhs);
    }

    auto operator==(const SuperDerived&) const -> bool = default;
};

看起来一切都很优雅，对吧？让我们写一个简单的测试程序来验证一下：

#include <iostream>
#include <typeinfo>

struct Base {
    virtual ~Base() = default;
    virtual bool operator==(const Base&) const = 0;
};

template <class D>
bool Equality(const D& lhs, const Base& rhs){
    if (typeid(rhs) == typeid(D)) {
        return lhs == static_cast<const D&>(rhs);
    }
    return false;
}

struct Derived : Base {
    int m1;
    int m2;

    bool operator==(const Base& rhs) const override {
        return Equality(*this, rhs);
    }

    bool operator==(const Derived&) const = default;
};

int main(){
    Derived a;
    Derived b;

    std::cout << (a == b) << std::endl;
}

运行这个程序，你可能会得到一个段错误（Segmentation Fault）信号：

Program terminated with signal: SIGSEGV

经过调试，问题的根源是栈溢出。这直接指向了无限递归。

问题的根源：operator==() = default 的真实行为

很多人可能会直观地认为 = default 会为派生类生成逐个成员（member-wise）比较的代码。但实际上，对于有基类的类型，编译器生成的默认相等运算符执行的是逐个基类子对象（base-class-subobject-wise）比较。

对于我们的 Derived 类，编译器不会生成下面这种我们期望的代码：

auto Derived::operator==(const Derived & rhs) const -> bool {
    return m1 == rhs.m1
       and m2 == rhs.m2;
}

相反，它生成的是这样的代码：

auto Derived::operator==(const Derived& rhs) const -> bool {
    return static_cast<const Base&>(*this) == static_cast<const Base&>(rhs)
       and m1 == rhs.m1
       and m2 == rhs.m2;
}

看到了吗？在比较 Derived 对象时，它会先去比较基类 Base 部分，而这是通过虚函数调用完成的！

无限递归调用链

现在，让我们追踪一下 Derived a == Derived b 的完整调用链条，一切就豁然开朗了：

1. 调用 Derived::operator==(const Derived&)（由= default生成）。
2. 该函数首先比较 Base 子对象，即调用 static_cast<const Base&>(*this) == static_cast<const Base&>(rhs)。
3. 由于 Base::operator== 是虚函数，这里发生虚调用，实际调用的是 Derived::operator==(const Base&)。
4. Derived::operator==(const Base&) 内部调用 Equality(*this, rhs)。
5. Equality 函数检查类型匹配（匹配成功），然后将 rhs 转型为 const Derived&，并调用 lhs == static_cast<const D&>(rhs)。
6. 这又回到了第 1 步，调用 Derived::operator==(const Derived&)。

一个完美的死亡循环就此形成，直到栈空间耗尽。

解决方案

理解了问题本质，解决起来就有方向了。核心思路是打破 Derived::operator==(const Derived&) 中对基类虚函数的依赖。

方案一：拆分比较接口
将多态比较和类型自身比较分离开。基类保留一个纯虚的 equals 函数用于多态比较，而 operator== 仅用于常规比较。

struct Base {
    virtual ~Base() = default;
    virtual auto equals(const Base&) const -> bool = 0;
    auto operator==(const Base&) const -> bool = default; // 使用默认，但在此例中可能不需要
};

struct Derived : Base {
    int m1;
    int m2;

    auto equals(const Base& rhs) const -> bool override{
        return Equality(*this, rhs);
    }

    auto operator==(const Derived& rhs) const -> bool = default; // 现在安全了
};

方案二：封装成员对象
将派生类独有的成员封装到一个内部结构体中，然后让派生类的 operator==(const Derived&) 只比较这个结构体，从而绕过对基类虚函数的调用。

struct Base {
    virtual ~Base() = default;
    virtual auto operator==(const Base&) const -> bool = 0;
};

// Equality 模板保持不变...

struct Derived : Base {
    struct Members {
        int m1;
        int m2;

        auto operator==(const Members&) const -> bool = default;
    };
    Members m;

    auto operator==(const Base& rhs) const -> bool override {
        return Equality(*this, rhs);
    }

    // 手动实现，只比较成员对象
    auto operator==(const Derived& rhs) const -> bool {
        return m == rhs.m;
    }
};

这个 Bug 生动地展示了 C++ 中设计模式的细节与编译器行为的交互可能产生的意外结果。= default 并非总是“安全”的捷径，尤其是在涉及多态和继承的复杂场景中。理解编译器为我们生成的代码的具体含义，是避免此类深层错误的关键。希望这个案例能帮助你在未来的 C++ 开发中绕过类似的陷阱。如果你有更多关于 C++ 语言特性的疑问或心得，欢迎在云栈社区与其他开发者交流探讨。