C++运行时如何动态实例化类模板？避免重复代码方案咨询

一、你提出的std::variant方案完全可行 #

std::variant是C++17引入的类型安全联合体，完美契合你“运行时选择模板实例类型”的需求——它能在编译期确定支持的类型列表，运行时存储其中任意一种实例，且无需手动管理内存。

唯一需要注意的是：variant不能直接调用成员函数（因为编译器无法确定当前存储的具体类型），必须用std::visit来统一处理不同类型的实例。举个完整示例：

#include <variant>
#include <iostream>

template<typename T>
struct foo {
    void do_something() {
        std::cout << "foo<" << typeid(T).name() << "> executing\n";
    }
};

int main() {
    bool use_int = true; // 运行时动态决定的条件
    std::variant<foo<int>, foo<float>> f;

    if (use_int) {
        f = foo<int>();
    } else {
        f = foo<float>();
    }

    // 用std::visit统一操作两种类型的实例
    std::visit([](auto& obj) {
        obj.do_something();
    }, f);

    return 0;
}

这个方案的优势是类型安全、性能开销小；缺点是支持的类型必须在编译期预先确定，适合你只需要int和float两种实例的场景。

二、另一种可选方案：基于多态的实现 #

如果foo的不同实例需要更直观的统一接口，可以用“抽象基类+模板派生类”的方式，通过基类指针/引用操作实例：

#include <memory>
#include <iostream>

// 定义统一的虚函数接口
struct foo_base {
    virtual ~foo_base() = default;
    virtual void do_something() = 0;
};

// 模板派生类继承基类
template<typename T>
struct foo : foo_base {
    void do_something() override {
        std::cout << "foo<" << typeid(T).name() << "> executing\n";
    }
};

int main() {
    bool use_int = false;
    std::unique_ptr<foo_base> f;

    if (use_int) {
        f = std::make_unique<foo<int>>();
    } else {
        f = std::make_unique<foo<float>>();
    }

    f->do_something(); // 直接通过基类指针调用统一接口

    return 0;
}

这个方案的优势是接口逻辑更清晰，适合需要长期持有实例并反复调用接口的场景；缺点是需要动态分配内存，且必须能修改foo类让它继承基类（如果是第三方库的类可能无法实现）。

三、避免重复代码的核心逻辑 #

不管用哪种方案，核心都是用统一的逻辑屏蔽类型差异：

• 用std::visit配合lambda/重载函数，处理variant中的不同类型
• 用多态基类的虚函数接口，统一不同模板实例的操作方式

这样就无需为int和float类型分别编写重复代码，所有业务逻辑都能集中在统一处理部分。

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