如何根据输入指定类型创建C++模板类MyClass的对象？

问题说明 #

现有一个C++模板类：

template<class T>
class MyClass
{
    // 类成员实现
};

输入会明确指定数据类型及对应数据，例如：

int
1 2 3 4 5

或

float 
1.5 2.3 4.2 5.9

需求是根据输入的类型创建对应MyClass<输入类型>的对象，但之前尝试的“抽象基类+纯虚函数+动态初始化”方案不仅复杂度高，还无法很好适配模板，下面是两种更合适的实现方式。

方法1：类型分发+函数重载 #

核心思路是先解析输入的类型字符串，再根据类型调用对应的重载函数，在函数内部创建对应模板实例并处理逻辑，完全不需要修改原模板类。

示例代码：

#include <iostream>
#include <string>
#include <vector>

template<class T>
class MyClass
{
public:
    MyClass(const std::vector<T>& data) : m_data(data) {}
    void process() {
        // 示例处理逻辑
        std::cout << "处理" << typeid(T).name() << "类型数据:\n";
        for (const auto& val : m_data) {
            std::cout << val << " ";
        }
        std::cout << "\n";
    }
private:
    std::vector<T> m_data;
};

// 处理int类型的重载函数
void handle_input(const std::vector<int>& data) {
    MyClass<int> obj(data);
    obj.process();
}

// 处理float类型的重载函数
void handle_input(const std::vector<float>& data) {
    MyClass<float> obj(data);
    obj.process();
}

int main() {
    std::string type_str;
    std::cin >> type_str;

    if (type_str == "int") {
        std::vector<int> data;
        int val;
        while (std::cin >> val) {
            data.push_back(val);
        }
        handle_input(data);
    } else if (type_str == "float") {
        std::vector<float> data;
        float val;
        while (std::cin >> val) {
            data.push_back(val);
        }
        handle_input(data);
    } else {
        std::cerr << "不支持的类型\n";
    }

    return 0;
}

后续要新增支持的类型，只需要添加对应的handle_input重载函数和输入解析分支即可，扩展性强，逻辑清晰。

方法2：用std::variant存储多态对象（C++17及以上） #

如果需要在后续逻辑中统一持有不同类型的MyClass对象，可以用std::variant来存储不同模板实例，结合std::visit统一调用成员函数，同样不需要修改原模板类。

示例代码：

#include <iostream>
#include <string>
#include <vector>
#include <variant>

template<class T>
class MyClass
{
public:
    MyClass(const std::vector<T>& data) : m_data(data) {}
    void process() const {
        std::cout << "处理" << typeid(T).name() << "类型数据:\n";
        for (const auto& val : m_data) {
            std::cout << val << " ";
        }
        std::cout << "\n";
    }
private:
    std::vector<T> m_data;
};

// 定义variant类型，包含所有需要支持的MyClass实例
using MyClassVariant = std::variant<MyClass<int>, MyClass<float>>;

int main() {
    std::string type_str;
    std::cin >> type_str;

    MyClassVariant obj_variant;

    if (type_str == "int") {
        std::vector<int> data;
        int val;
        while (std::cin >> val) {
            data.push_back(val);
        }
        obj_variant = MyClass<int>(data);
    } else if (type_str == "float") {
        std::vector<float> data;
        float val;
        while (std::cin >> val) {
            data.push_back(val);
        }
        obj_variant = MyClass<float>(data);
    } else {
        std::cerr << "不支持的类型\n";
        return 1;
    }

    // 统一调用process函数
    std::visit([](const auto& obj) {
        obj.process();
    }, obj_variant);

    return 0;
}

这种方式利用std::variant的类型安全特性，避免了传统虚基类的运行时开销，同时能在运行时灵活切换不同类型的模板对象。

为什么之前的虚基类方案不适用？ #

MyClass<int>和MyClass<float>是完全独立的类型，没有天然的继承关系。如果要通过虚基类统一管理，必须修改MyClass让所有模板实例继承同一个基类，还要把所有需要调用的成员函数声明为虚函数。这不仅会增加模板类的复杂度，带来虚函数调用的开销，后续新增类型时还要同步更新基类的虚函数表，维护成本很高。而上面两种方案都不需要改动原模板类，更轻量高效。

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