C++多继承问题：含重叠虚函数的接口实现编译报错求解

问题根源 #

你的代码编译失败是因为菱形继承导致的歧义：FooInterface被Foo和FooBarInterface分别以普通继承方式继承，这使得FooBar类中存在两个独立的FooInterface基类子对象。Foo实现的foo()属于其中一个子对象，而FooBarInterface要求的foo()属于另一个子对象，因此编译器认为FooBar未覆盖FooBarInterface的纯虚函数foo()，无法将其转换为std::shared_ptr<FooBarInterface>。

解决方案 #

1. 使用虚拟继承消除菱形歧义 #

虚拟继承可以确保整个继承体系中只有一个FooInterface实例，让Foo的foo()实现能够统一覆盖所有接口的要求：

#include <memory>

class FooInterface {
public:
    virtual void foo() = 0;
    virtual ~FooInterface() = default; // 补全虚析构，避免内存泄漏
};

// 虚拟继承FooInterface
class FooBarInterface : public virtual FooInterface {
public:
    virtual void bar() = 0;
    virtual ~FooBarInterface() = default;
};

// 虚拟继承FooInterface
class Foo : public virtual FooInterface {
public:
    void foo() override {};
    virtual ~Foo() = default;
};

class FooBar : public Foo, public FooBarInterface {
public:
    void bar() override {};
    virtual ~FooBar() = default;
};

void func(std::shared_ptr<FooBarInterface> fb) {}

int main() {
    func(std::make_shared<FooBar>()); // 编译通过
}

2. 在FooBar中显式转发foo()调用 #

如果不想引入虚拟继承的开销，可以在FooBar中显式实现foo()，直接调用父类Foo的实现，以此覆盖FooBarInterface的纯虚函数：

#include <memory>

class FooInterface {
public:
    virtual void foo() = 0;
    virtual ~FooInterface() = default;
};

class FooBarInterface : public FooInterface {
public:
    virtual void bar() = 0;
    virtual ~FooBarInterface() = default;
};

class Foo : public FooInterface {
public:
    void foo() override {};
    virtual ~Foo() = default;
};

class FooBar : public Foo, public FooBarInterface {
public:
    // 显式覆盖foo()，转发给Foo的实现
    void foo() override { Foo::foo(); }
    void bar() override {};
    virtual ~FooBar() = default;
};

void func(std::shared_ptr<FooBarInterface> fb) {}

int main() {
    func(std::make_shared<FooBar>()); // 编译通过
}

3. 重构接口继承结构（推荐） #

避免菱形继承的最佳方式是重新设计接口体系，遵循接口分离原则：

• 让FooBarInterface不再继承FooInterface，成为独立接口；
• 让FooBar同时实现FooInterface和FooBarInterface；
• 调整func的参数要求，确保传入的对象同时满足两个接口。

示例代码：

#include <memory>
#include <type_traits>

class FooInterface {
public:
    virtual void foo() = 0;
    virtual ~FooInterface() = default;
};

// FooBarInterface独立，不再继承FooInterface
class FooBarInterface {
public:
    virtual void bar() = 0;
    virtual ~FooBarInterface() = default;
};

class Foo : public FooInterface {
public:
    void foo() override {};
    virtual ~Foo() = default;
};

// FooBar同时实现两个独立接口
class FooBar : public Foo, public FooBarInterface {
public:
    void bar() override {};
    virtual ~FooBar() = default;
};

// 用模板约束参数必须同时实现两个接口
template<typename T>
void func(std::shared_ptr<T> fb) {
    static_assert(std::is_base_of_v<FooInterface, T> && std::is_base_of_v<FooBarInterface, T>,
                  "Type must implement both FooInterface and FooBarInterface");
    fb->foo();
    fb->bar();
}

int main() {
    func(std::make_shared<FooBar>()); // 编译通过
}

可参考的设计模式 #

• 适配器模式：如果无法修改原有接口体系，可以编写适配器类，将Foo的实例适配为FooBarInterface的实现，或者让FooBar作为适配器转发调用。
• 组合优于继承：用组合代替多重继承，比如让FooBar持有Foo的实例，同时实现FooBarInterface，避免继承带来的歧义问题。
• 接口分离原则（ISP）：拆分臃肿的接口，让每个接口只负责单一职责，减少不必要的继承依赖，从根源上避免菱形继承。

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