如何在无基类虚函数时，从模板派生类容器调用基类函数？

当你把派生类实例存入std::vector<std::unique_ptr<IModule>>后，遍历容器时编译器只能识别到指针的静态类型是IModule*——而IModule中并没有声明BaseFoo、ABaseFoo这些函数，C++的静态类型检查会直接抛出编译错误，这是语言特性决定的，没有绕开的可能。

如果不想在IModule中添加业务相关的虚函数，可以考虑以下几种实用思路：

1. 类型标识+动态转换 #

在IModule中加一个类型标识枚举，每个派生类返回对应标识，遍历的时候用dynamic_cast转换到具体类型后调用函数：

enum class ModuleType { BaseInt, ABaseIntFloat, BDerived };

class IModule {
public:
    virtual ~IModule() = default;
    virtual ModuleType getType() const = 0;
};

// 派生类示例：
class BDerived : public BBase<int, double> {
public:
    ModuleType getType() const override { return ModuleType::BDerived; }
};

// 遍历调用：
for (auto& ptr : modules) {
    switch (ptr->getType()) {
        case ModuleType::BaseInt:
            if (auto* base = dynamic_cast<Base<int>*>(ptr.get())) {
                base->BaseFoo();
            }
            break;
        case ModuleType::ABaseIntFloat:
            if (auto* abase = dynamic_cast<ABase<int, float>*>(ptr.get())) {
                abase->ABaseFoo();
            }
            break;
        case ModuleType::BDerived:
            if (auto* bderived = dynamic_cast<BDerived*>(ptr.get())) {
                bderived->BaseFoo();
            }
            break;
    }
}

缺点是新增派生类就要修改枚举和分支，违反开闭原则，且dynamic_cast有运行时开销。

2. 访问者模式 #

通过访问者接口实现类型分发，不需要在IModule中添加业务虚函数，只需要一个accept方法：

class IModuleVisitor;

class IModule {
public:
    virtual ~IModule() = default;
    virtual void accept(IModuleVisitor& visitor) = 0;
};

class IModuleVisitor {
public:
    virtual ~IModuleVisitor() = default;
    virtual void visit(Base<int>&) = 0;
    virtual void visit(ABase<int, float>&) = 0;
    virtual void visit(BDerived&) = 0;
};

// 模板基类实现accept：
template<typename T>
class Base : public IModule {
public:
    void accept(IModuleVisitor& visitor) override {
        visitor.visit(*this);
    }
    void BaseFoo() { /* 实现 */ }
};

// 具体访问者，负责调用对应函数：
class ModuleCaller : public IModuleVisitor {
public:
    void visit(Base<int>& m) override { m.BaseFoo(); }
    void visit(ABase<int, float>& m) override { m.ABaseFoo(); m.BaseFoo(); }
    void visit(BDerived& m) override { m.BaseFoo(); }
};

// 遍历调用：
ModuleCaller caller;
for (auto& ptr : modules) {
    ptr->accept(caller);
}

这种方式更优雅，新增模块只需要扩展访问者接口，符合开闭原则，但需要维护访问者与模块类型的对应关系。

3. 按类型分组存储 #

如果业务允许，放弃统一容器，把不同类型的模块分别存在各自的容器里：

std::vector<std::unique_ptr<Base<int>>> base_list;
std::vector<std::unique_ptr<ABase<int, float>>> abase_list;
std::vector<std::unique_ptr<BDerived>> bderived_list;

// 直接遍历对应容器调用函数：
for (auto& ptr : base_list) ptr->BaseFoo();
for (auto& ptr : abase_list) ptr->ABaseFoo();

这是最直接的方案，没有额外开销，但失去了统一管理所有模块的便利性，适合模块类型明确且不需要统一遍历的场景。

4. 使用std::variant替代多态 #

如果所有模块类型在编译期就确定，用std::variant存储实例，通过std::visit编译时分发调用：

using ModuleVar = std::variant<Base<int>, ABase<int, float>, BDerived>;
std::vector<ModuleVar> modules;

// 遍历调用：
for (auto& var : modules) {
    std::visit([](auto& m) {
        using Type = std::decay_t<decltype(m)>;
        if constexpr (std::is_same_v<Type, Base<int>>) {
            m.BaseFoo();
        } else if constexpr (std::is_same_v<Type, ABase<int, float>>) {
            m.ABaseFoo();
        } else if constexpr (std::is_same_v<Type, BDerived>) {
            m.BaseFoo();
        }
    }, var);
}

这种方式没有运行时多态开销，是编译时处理，但要求所有模块类型提前确定，灵活性稍差。

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