C++多继承场景下如何判断两个接口引用指向同一对象？

在C++多重继承场景下，当方法接收InterfaceA&和InterfaceB&两个无直接关联的接口引用时，直接比较引用的地址会因为多重继承的子对象内存布局问题返回错误结果。例如Implementation类同时继承两个接口，其实例转换为两个接口引用后，对应的子对象地址不同，导致&a == &b判断失败。以下是几种可行的解决方案：

方案1：在接口中添加获取实例指针的虚函数（推荐） #

如果有权限修改接口或实现类，最可靠的方式是为两个接口添加统一的虚函数，返回实例的原始指针：

#include <cassert>

class InterfaceA {
public:
    virtual void methodA() = 0;
    // 添加虚函数返回实例指针
    virtual void* getInstancePtr() = 0;
};

class InterfaceB {
public:
    virtual void methodB() = 0;
    // 添加虚函数返回实例指针
    virtual void* getInstancePtr() = 0;
};

class Implementation : public InterfaceA, public InterfaceB
{
public:
    virtual void methodA() override {}
    virtual void methodB() override {}
    virtual void* getInstancePtr() override {
        return this; // 返回当前实例的原始指针
    }
};

bool isSameObject(InterfaceA& a, InterfaceB& b) {
    return a.getInstancePtr() == b.getInstancePtr();
}

// 测试
int main() {
    Implementation impl;
    assert(isSameObject(impl, impl) == true);

    Implementation impl2;
    assert(isSameObject(impl, impl2) == false);
    return 0;
}

优点：无需依赖RTTI，性能高效，逻辑直观，适用于所有实现双接口的类。

方案2：使用dynamic_cast类型转换 #

如果无法修改现有接口，可以利用C++的dynamic_cast特性，尝试在两个接口之间互相转换：

#include <cassert>

class InterfaceA {
public:
    virtual void methodA() = 0;
};

class InterfaceB {
public:
    virtual void methodB() = 0;
};

class Implementation : public InterfaceA, public InterfaceB
{
public:
    virtual void methodA() override {}
    virtual void methodB() override {}
};

bool isSameObject(InterfaceA& a, InterfaceB& b) {
    // 尝试将InterfaceA转换为InterfaceB，成功则比较地址
    if (InterfaceB* bFromA = dynamic_cast<InterfaceB*>(&a)) {
        return bFromA == &b;
    }
    // 尝试将InterfaceB转换为InterfaceA，成功则比较地址
    if (InterfaceA* aFromB = dynamic_cast<InterfaceA*>(&b)) {
        return aFromB == &a;
    }
    // 无法双向转换，说明不是同一对象
    return false;
}

// 测试
int main() {
    Implementation impl;
    assert(isSameObject(impl, impl) == true);

    Implementation impl2;
    assert(isSameObject(impl, impl2) == false);
    return 0;
}

原理：如果a和b属于同一实例，那么将a转换为InterfaceB*会得到该实例中InterfaceB子对象的地址，与&b完全一致；反之同理。若转换失败，说明两个引用不属于同时实现双接口的同一实例。

注意：该方案需要开启编译器的RTTI支持（多数编译器默认开启），性能略低于方案1。

方案3：引入公共虚基类 #

如果可以调整接口的继承结构，可定义一个公共的虚基类，所有接口都继承自它，通过转换到基类指针来比较：

#include <cassert>

// 公共虚基类
class BaseInstance {
public:
    virtual ~BaseInstance() = default;
};

class InterfaceA : virtual public BaseInstance {
public:
    virtual void methodA() = 0;
};

class InterfaceB : virtual public BaseInstance {
public:
    virtual void methodB() = 0;
};

class Implementation : public InterfaceA, public InterfaceB
{
public:
    virtual void methodA() override {}
    virtual void methodB() override {}
};

bool isSameObject(InterfaceA& a, InterfaceB& b) {
    // 转换到公共虚基类指针，虚继承下同一实例的基类指针地址唯一
    return dynamic_cast<BaseInstance*>(&a) == dynamic_cast<BaseInstance*>(&b);
}

// 测试
int main() {
    Implementation impl;
    assert(isSameObject(impl, impl) == true);

    Implementation impl2;
    assert(isSameObject(impl, impl2) == false);
    return 0;
}

优点：统一了实例的标识方式，适合有多个接口的复杂场景；缺点：需要修改接口的继承体系，侵入性较强。

为什么直接地址比较会失败？ #

在多重继承中，每个基类对应对象内存中的一个独立子对象，它们的地址不同。例如Implementation实例的内存布局中，InterfaceA子对象和InterfaceB子对象占据不同的内存位置，因此直接取&a和&b比较会得到false，即使它们属于同一实例。

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