C++：使用纯抽象类构建稳定API时避免多重继承

嘿，这个场景我太熟悉了——想用纯抽象类做自研库的稳定API，又不想因为复用实现代码陷入多重继承的坑对吧？咱们来聊聊几个靠谱的解决方案，都能完美避开多重继承问题：

这是最直接的思路：把原本想通过继承复用的Base实现，改成让具体实现类持有Base的实例，通过委托来复用代码，而不是继承它。这样你的实现类只需要继承对应的API接口，完全不用碰多重继承。

示例代码如下：

// 你的原有API接口完全不变，保持稳定
struct IBase{ virtual void something() = 0; };
struct IDerivedA : public IBase{ virtual void another() = 0; };
struct IDerivedB : public IBase{ virtual void another(int a) = 0; };

// 把Base改成纯实现类，不需要继承IBase了
struct BaseImpl {
    int x;
    // 实现IBase要求的something方法
    void something() { 
        /* 这里写具体的实现逻辑 */ 
    }
};

// 实现IDerivedA的类，只继承IDerivedA，通过组合BaseImpl复用代码
struct DerivedAImpl : public IDerivedA {
private:
    BaseImpl base_; // 持有Base实例
public:
    // 把IBase的方法委托给base_处理
    void something() override { base_.something(); }
    // 实现IDerivedA特有的方法
    void another() override { 
        /* 这里写DerivedA专属的实现逻辑 */ 
    }
};

// DerivedB的实现同理
struct DerivedBImpl : public IDerivedB {
private:
    BaseImpl base_;
public:
    void something() override { base_.something(); }
    void another(int a) override { 
        /* 这里写DerivedB专属的实现逻辑 */ 
    }
};

如果觉得组合的委托代码有点繁琐，可以试试模板混入——把Base的实现做成一个模板类，让它继承你传入的API接口，这样你的具体实现类只需要单一继承这个模板实例，就能同时获得API接口和Base的实现。

示例代码：

// 原有API接口保持不变
struct IBase{ virtual void something() = 0; };
struct IDerivedA : public IBase{ virtual void another() = 0; };
struct IDerivedB : public IBase{ virtual void another(int a) = 0; };

// 模板Mixin类，继承传入的接口类型，实现IBase的方法
template <typename Interface>
struct BaseMixin : public Interface {
    int x;
    // 实现IBase的something方法
    void something() override { 
        /* 这里写具体的实现逻辑 */ 
    }
};

// 实现IDerivedA的类，只需要继承BaseMixin<IDerivedA>
struct DerivedAImpl : public BaseMixin<IDerivedA> {
    // 只需要实现IDerivedA特有的方法
    void another() override { 
        /* 这里写DerivedA专属的实现逻辑 */ 
    }
};

// DerivedB的实现同理
struct DerivedBImpl : public BaseMixin<IDerivedB> {
    void another(int a) override { 
        /* 这里写DerivedB专属的实现逻辑 */ 
    }
};

这个方案既复用了代码，又保持了单一继承的简洁性，而且模板编译期就能确定类型，性能上也没额外开销。

如果你的库需要更灵活的扩展（比如后续要加不同的Base实现，或者API和实现需要完全解耦），桥接模式是个绝佳选择。它把API接口和底层实现分成两个独立的层级，接口类持有实现类的指针，完全避免继承带来的耦合。

示例代码：

// 第一步：定义底层实现的抽象接口，和API完全分离
struct IBaseImpl {
    virtual void doSomething() = 0;
    virtual ~IBaseImpl() = default; // 记得加虚析构
};

// 具体的Base实现
struct BaseImpl : public IBaseImpl {
    int x;
    void doSomething() override { 
        /* 这里写具体的实现逻辑 */ 
    }
};

// 第二步：定义API接口层，持有实现层的指针
struct IBase {
    virtual void something() = 0;
    virtual ~IBase() = default;
protected:
    std::unique_ptr<IBaseImpl> impl_; // 用智能指针管理实现实例
};

struct IDerivedA : public IBase {
    virtual void another() = 0;
    // 构造时初始化实现实例
    IDerivedA() : impl_(std::make_unique<BaseImpl>()) {}
};

struct IDerivedB : public IBase {
    virtual void another(int a) = 0;
    IDerivedB() : impl_(std::make_unique<BaseImpl>()) {}
};

// 第三步：实现具体的API类
struct DerivedAImpl : public IDerivedA {
    void something() override { impl_->doSomething(); } // 委托给实现层
    void another() override { 
        /* 这里写DerivedA专属的实现逻辑 */ 
    }
};

struct DerivedBImpl : public IDerivedB {
    void something() override { impl_->doSomething(); }
    void another(int a) override { 
        /* 这里写DerivedB专属的实现逻辑 */ 
    }
};

这个方案的好处是，后续修改底层实现完全不会影响API接口，甚至可以在运行时切换不同的实现，灵活性拉满。

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