C++多态继承代码隔离问题：纯虚函数未实现报错求解

问题描述 #

尝试通过抽象保存操作实现代码隔离：定义SaverInterface作为保存操作的抽象接口，SaverImpl提供具体实现；中间类ObjectA继承SaverInterface并封装save方法调用纯虚函数saveData；最终组合类ComposedObjectA同时继承ObjectA和SaverImpl，期望复用SaverImpl的saveData实现。但编译时报错：ComposedObjectA中存在未实现的纯虚方法saveData。

简化测试代码如下：

#include <iostream>
using namespace std;

class SaverInterface {
protected:
    virtual void saveData(int data) = 0;
};

class SaverImpl : public SaverInterface {
protected:
    void saveData(int data) override {
        std::cout << "data to save: " << data << std::endl;
    }
};

class ObjectA : public SaverInterface {
public:
    void save(int data) {
        saveData(data);
    }
};

class ComposedObjectA : public ObjectA, public SaverImpl {
public:
    void publicSave() {
        save(1);
    }
};

int main() {
    auto* objectA = new ComposedObjectA();
    objectA->publicSave();

    delete objectA;
    return 0;
}

错误原因 #

这是非虚多重继承导致的菱形继承歧义问题：

• ObjectA和SaverImpl各自独立继承了SaverInterface，因此ComposedObjectA对象中会包含两个独立的SaverInterface基类子对象。
• ObjectA继承的那个SaverInterface子对象中的saveData纯虚函数并未被实现——SaverImpl的saveData实现仅属于它自己继承的另一个SaverInterface子对象，两者完全独立。
• 当ObjectA::save调用saveData时，它只会调用自身继承的SaverInterface中的纯虚函数，而该函数没有实现，因此编译器判定ComposedObjectA是抽象类，无法实例化。

解决方案 #

方案1：使用虚继承消除重复基类子对象 #

让ObjectA和SaverImpl都虚继承SaverInterface，这样ComposedObjectA中只会存在一个SaverInterface基类子对象，SaverImpl的saveData实现会覆盖这个唯一的纯虚函数：

#include <iostream>
using namespace std;

class SaverInterface {
protected:
    virtual void saveData(int data) = 0;
};

// 虚继承SaverInterface
class SaverImpl : public virtual SaverInterface {
protected:
    void saveData(int data) override {
        std::cout << "data to save: " << data << std::endl;
    }
};

// 虚继承SaverInterface
class ObjectA : public virtual SaverInterface {
public:
    void save(int data) {
        saveData(data);
    }
};

class ComposedObjectA : public ObjectA, public SaverImpl {
public:
    void publicSave() {
        save(1);
    }
};

int main() {
    auto* objectA = new ComposedObjectA();
    objectA->publicSave();

    delete objectA;
    return 0;
}

方案2：用组合代替多重继承（更推荐） #

避免多重继承的复杂性，让ObjectA不继承SaverInterface，而是通过成员变量持有SaverInterface的指针或引用，实现依赖注入：

#include <iostream>
#include <memory>
using namespace std;

class SaverInterface {
public: // 调整为public，方便外部调用
    virtual void saveData(int data) = 0;
    virtual ~SaverInterface() = default; // 基类需添加虚析构
};

class SaverImpl : public SaverInterface {
public:
    void saveData(int data) override {
        std::cout << "data to save: " << data << std::endl;
    }
};

class ObjectA {
private:
    std::unique_ptr<SaverInterface> saver; // 持有保存器实例
public:
    // 通过构造函数注入具体的Saver实现
    ObjectA(std::unique_ptr<SaverInterface> s) : saver(std::move(s)) {}

    void save(int data) {
        saver->saveData(data);
    }
};

class ComposedObjectA : public ObjectA {
public:
    ComposedObjectA() : ObjectA(std::make_unique<SaverImpl>()) {}

    void publicSave() {
        save(1);
    }
};

int main() {
    auto* objectA = new ComposedObjectA();
    objectA->publicSave();

    delete objectA;
    return 0;
}

这种方式更灵活，ObjectA可以适配任意SaverInterface的实现，也避免了多重继承带来的歧义问题。

方案3：CRTP静态多态（编译期绑定） #

利用奇异递归模板模式（CRTP），将具体的保存实现作为模板参数传入ObjectA，实现编译期多态，避免动态多态的运行时开销和多重继承问题：

#include <iostream>
using namespace std;

// 定义保存操作的模板基类
template<typename Impl>
class ObjectA {
public:
    void save(int data) {
        // 调用派生类的saveData实现
        static_cast<Impl*>(this)->saveData(data);
    }
};

class SaverImpl {
protected:
    void saveData(int data) {
        std::cout << "data to save: " << data << std::endl;
    }
};

// ComposedObjectA继承ObjectA并传入SaverImpl作为模板参数
class ComposedObjectA : public ObjectA<ComposedObjectA>, public SaverImpl {
public:
    void publicSave() {
        save(1);
    }
    // 暴露SaverImpl的saveData给ObjectA
    using SaverImpl::saveData;
};

int main() {
    auto* objectA = new ComposedObjectA();
    objectA->publicSave();

    delete objectA;
    return 0;
}

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