C++可变模板实例化过多导致代码膨胀的解决方案咨询

你可以使用多态基类+模板派生的类型擦除方案解决模板特化爆炸的问题，你的Proxy思路是正确的，仅需要补充一层抽象基类即可落地。

方案1：基于抽象基类的类型擦除 #

步骤1：定义公共抽象接口 #

首先定义非模板的Proxy基类，声明所有需要调用的公共虚函数：

class ProxyBase {
public:
    virtual ~ProxyBase() = default;
    virtual void func1() = 0;
    virtual void func2() = 0;
};

步骤2：实现模板派生Proxy类 #

模板化的派生类继承自ProxyBase，包装具体类型的实例，实现虚函数接口转发调用：

template<typename T>
class Proxy : public ProxyBase {
private:
    T m_instance;
public:
    explicit Proxy(T instance) : m_instance(std::move(instance)) {}
    void func1() override {
        m_instance.func1();
    }
    void func2() override {
        m_instance.func2();
    }
};

步骤3：实现非模板的MyAlgorithm类 #

MyAlgorithm内部存储基类指针的容器，不需要任何模板参数：

class MyAlgorithm {
private:
    std::vector<std::unique_ptr<ProxyBase>> m_args;
public:
    // 模板方法添加任意符合接口要求的类型实例
    template<typename T>
    void add_arg(T instance) {
        m_args.push_back(std::make_unique<Proxy<T>>(std::move(instance)));
    }

    void call_all_func1() {
        for (auto& arg : m_args) {
            arg->func1();
        }
    }

    void call_all_func2() {
        for (auto& arg : m_args) {
            arg->func2();
        }
    }
};

使用示例 #

不需要提前指定类型组合，运行时可以动态添加任意类型的实例：

MyAlgorithm alg;
alg.add_arg(A{});
alg.add_arg(B{});
alg.add_arg(A{});
alg.add_arg(C{});
alg.call_all_func1();

方案2：基于std::function的轻量类型擦除 #

如果不需要复杂的Proxy扩展逻辑，可以用std::function直接包装方法调用，省去Proxy类的编写：

class MyAlgorithm {
private:
    std::vector<std::function<void()>> m_func1_list;
    std::vector<std::function<void()>> m_func2_list;
public:
    template<typename T>
    void add_arg(T instance) {
        m_func1_list.push_back([ins = std::move(instance)]() mutable {
            ins.func1();
        });
        m_func2_list.push_back([ins = std::move(instance)]() mutable {
            ins.func2();
        });
    }

    void call_all_func1() {
        for (auto& f : m_func1_list) f();
    }

    void call_all_func2() {
        for (auto& f : m_func2_list) f();
    }
};

方案优势 #

• 只会为每个用到的类型生成1份对应特化代码，不会因为类型组合的差异生成多余的模板实例，代码体积大幅降低
• 不需要预编译所有可能的类型组合，支持运行时动态添加实例，完全适配在线场景的需求
• 对原有自定义类型无侵入性，不需要修改原有类型的定义

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