基类虚函数参数依赖实现类：模板方案的优化疑问

你的模板基类方案确实能解决问题，但模板实例化带来的编译时间增加、以及不同派生类对应不同基类实例的问题确实存在。下面给出几个更优的替代方案，按需选择：

方案1：CRTP（奇异递归模板模式）—— 无虚函数开销（无需运行时多态时用） #

如果你的场景不需要把Derived1和Derived2当成统一的Base类型处理（比如不需要放入同一个vector<Base*>容器），用CRTP可以彻底消除虚函数，同时保留模板的灵活性，编译效率也会有所提升。

template<typename Derived>
class Base {
protected:
    std::vector<typename Derived::ParamType> components;

public:
    explicit Base(std::vector<typename Derived::ParamType> comps)
        : components(std::move(comps)) {}

    void doSomething() {
        // 直接调用派生类的实现，跳过虚函数机制
        static_cast<Derived*>(this)->doSomethingSpecific(components[0]);
    }
};

class Derived1 : public Base<Derived1> {
public:
    using ParamType = Derived1Type;

private:
    // 让基类能调用私有方法
    friend class Base<Derived1>;
    void doSomethingSpecific(ParamType param) {
        // 写你的具体逻辑
    }
};

// Derived2 实现逻辑完全一致
class Derived2 : public Base<Derived2> {
public:
    using ParamType = Derived2Type;

private:
    friend class Base<Derived2>;
    void doSomethingSpecific(ParamType param) {
        // 写你的具体逻辑
    }
};

优势：没有虚函数调用的运行时开销，模板实例化的编译开销比原方案更低，代码逻辑更直接。

方案2：类型擦除—— 支持统一基类（需要运行时多态时用） #

如果需要把不同派生类对象统一当成Base类型处理，用类型擦除可以让基类脱离模板，避免大量模板实例化带来的编译负担。这里用std::any和std::function实现简单的类型擦除：

#include <any>
#include <functional>
#include <vector>

class Base {
protected:
    std::any components;
    std::function<void()> do_something_impl;

public:
    template<typename T>
    explicit Base(std::vector<T> comps)
        : components(std::move(comps)) {
        // 绑定具体调用逻辑，固化类型信息
        do_something_impl = [this]() {
            auto& vec = std::any_cast<std::vector<T>&>(components);
            static_cast<Derived<T>*>(this)->doSomethingSpecific(vec[0]);
        };
    }

    void doSomething() {
        do_something_impl();
    }

private:
    template<typename T>
    friend class Derived;
    // C++20 支持auto参数的虚函数，兼容旧标准可以改用模板函数封装
    virtual void doSomethingSpecific(const auto& param) = 0;
};

template<typename T>
class Derived : public Base {
private:
    void doSomethingSpecific(const T& param) override {
        // 写你的具体逻辑
    }

public:
    using Base::Base; // 继承基类的构造函数
};

// 使用示例
int main() {
    std::vector<Derived1Type> comps1 = {...};
    Derived<Derived1Type> obj1(std::move(comps1));
    obj1.doSomething();

    std::vector<Derived2Type> comps2 = {...};
    Derived<Derived2Type> obj2(std::move(comps2));
    obj2.doSomething();

    // 现在可以把不同派生类对象统一放入Base*容器
    std::vector<Base*> objs = {&obj1, &obj2};
    for (auto* obj : objs) {
        obj->doSomething();
    }
}

优势：基类是单一类型，不会产生大量模板实例化，编译时间大幅降低，同时保留了运行时多态的能力。

方案3：参数类型统一基类—— 完全无模板（参数可抽象时用） #

如果Derived1Type和Derived2Type可以抽象出一个共同的基类（比如BaseParam），那可以彻底抛弃模板，用传统的多态实现：

#include <vector>
#include <memory>

class BaseParam {
public:
    virtual ~BaseParam() = default; // 必须有虚析构，避免内存泄漏
};

class Derived1Type : public BaseParam {
    // 你的Derived1Type成员
};

class Derived2Type : public BaseParam {
    // 你的Derived2Type成员
};

class Base {
protected:
    std::vector<std::unique_ptr<BaseParam>> components;

public:
    explicit Base(std::vector<std::unique_ptr<BaseParam>> comps)
        : components(std::move(comps)) {}

    void doSomething() {
        doSomethingSpecific(*components[0]);
    }

private:
    virtual void doSomethingSpecific(BaseParam& param) = 0;
};

class Derived1 : public Base {
private:
    void doSomethingSpecific(BaseParam& param) override {
        // 动态转换到具体类型，确保类型安全
        auto& derived_param = dynamic_cast<Derived1Type&>(param);
        // 处理derived_param的逻辑
    }
};

class Derived2 : public Base {
private:
    void doSomethingSpecific(BaseParam& param) override {
        auto& derived_param = dynamic_cast<Derived2Type&>(param);
        // 处理derived_param的逻辑
    }
};

优势：完全不需要模板，编译速度最快，代码最符合传统C++多态思维；缺点是需要参数类型能抽象出共同基类，且存在动态转换的少量运行时开销。

内容的提问来源于stack exchange，提问作者domen hočevar