C++模板类返回不同模板参数对象的函数实现问题

A<B,1>、A<C,2>、A<D,3>是完全不同的C++类型——模板实例化后会生成独立的类。普通函数无法返回多种不同类型的对象，直接写A getObject()会报错，因为A只是模板名，不是具体类型。

以下是两种常用的解决思路：

方案一：基类+多态（兼容C++11及以上） #

通过定义非模板基类，让模板类A继承它，利用多态实现返回不同实例。

步骤1：定义基类 #

添加包含纯虚函数的基类，必须包含虚析构函数以保证子类析构正确执行：

class BaseA {
public:
    virtual ~BaseA() = default;
    virtual void someMethod() = 0; // 统一接口的纯虚函数
};

步骤2：修改模板类A #

让A继承BaseA并覆写虚函数：

template <class C, int I>
class A : public BaseA {
public:
    A() {};
    void someMethod() override { 
        // 原有的someMethod实现逻辑
    };
};

步骤3：修改getObject函数 #

返回基类的智能指针（避免手动管理内存）：

#include <memory>

std::unique_ptr<BaseA> getObject() {
    if(condition1)
        return std::make_unique<A<B, 1>>();
    else if(condition2)
        return std::make_unique<A<C, 2>>();
    else
        return std::make_unique<A<D, 3>>();
}

使用方式 #

auto obj = getObject();
obj->someMethod(); // 自动调用对应子类的实现

优点：兼容性好，符合传统OOP思路；缺点：需要修改原模板类，存在虚函数调用的运行时开销。

方案二：使用std::variant（C++17及以上） #

std::variant是C++17引入的类型安全联合体，可存储多种不同类型的对象，无需修改原模板类。

步骤1：定义variant类型 #

#include <variant>

// 声明可存储的所有A实例类型
using AVariant = std::variant<A<B,1>, A<C,2>, A<D,3>>;

步骤2：修改getObject函数 #

AVariant getObject() {
    if(condition1)
        return object1; // 假设object1是全局/静态对象，或返回临时对象
    else if(condition2)
        return object2;
    else
        return object3;
}

使用方式 #

用std::visit调用统一接口：

AVariant obj = getObject();
// 调用someMethod
std::visit([](auto& a) { a.someMethod(); }, obj);

// 若需多次调用，可封装成函数
auto callSomeMethod = [](auto& var) {
    std::visit([](auto& a) { a.someMethod(); }, var);
};
callSomeMethod(obj);

优点：无需修改原类，编译期处理无虚函数开销；缺点：依赖C++17，类型较多时variant定义会变长。

你原本期望的A obj = getObject();无法实现，因为不同模板参数的A是独立类型，没有共同的非模板类型可以直接接收。必须通过基类指针/引用或std::variant来间接处理。

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