私有继承场景下C++非成员二元运算符==的实现问题求助

私有继承的核心限制是：子类对象到基类的转换仅允许在子类的成员函数或友元函数中进行。由于社区推荐将operator==实现为非成员函数，我们需要突破这个限制，同时遵循封装原则，有两种可靠方案：

方案1：将子类的operator==声明为友元 #

直接让子类的非成员operator==成为子类的友元，这样它就能合法地将子类对象转换为基类引用，调用父类的operator==：

#include <iostream>

class Parent {
    int x_;
public:
    Parent(int x) : x_(x) {}
};

// 父类的非成员operator==
bool operator==(const Parent& lhs, const Parent& rhs) {
    return lhs.x_ == rhs.x_;
}

class Child : private Parent {
    int y_;
    // 声明子类的operator==为友元，获得基类转换权限
    friend bool operator==(const Child& lhs, const Child& rhs);
public:
    Child(int x, int y) : Parent(x), y_(y) {}
};

// 子类的非成员operator==
bool operator==(const Child& lhs, const Child& rhs) {
    // 合法转换为基类引用，调用父类的==
    const auto& lhs_parent = static_cast<const Parent&>(lhs);
    const auto& rhs_parent = static_cast<const Parent&>(rhs);
    return lhs_parent == rhs_parent && lhs.y_ == rhs.y_;
}

这种方案的优势是无需额外暴露接口，直接让operator==访问子类的私有基类部分和自身私有成员，逻辑紧凑。

方案2：提供公共接口暴露基类部分 #

如果不想用友元（更倾向于封装），可以在子类中添加一个公共成员函数，返回基类的const引用，让非成员operator==通过这个接口访问父类部分：

#include <iostream>

class Parent {
    int x_;
public:
    Parent(int x) : x_(x) {}
};

bool operator==(const Parent& lhs, const Parent& rhs) {
    return lhs.x_ == rhs.x_;
}

class Child : private Parent {
    int y_;
public:
    Child(int x, int y) : Parent(x), y_(y) {}
    
    // 公共接口：返回基类的const引用
    const Parent& as_parent() const {
        return *this;
    }
    
    int get_y() const {
        return y_;
    }
};

bool operator==(const Child& lhs, const Child& rhs) {
    // 通过公共接口访问基类部分
    return lhs.as_parent() == rhs.as_parent() && lhs.get_y() == rhs.get_y();
}

这种方案更符合封装原则，将基类部分的访问控制在子类手中，同时避免了友元带来的耦合。

两种方案都不需要自行重写父类operator==的逻辑，完全复用已有实现，符合需求。

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