C++通过基类指针访问模板派生类存储值的实现方案

你原代码编译失败有两个层面的原因：

1. 语法层面：C标准规定虚函数不能使用auto作为返回值（C20放宽了该限制，但要求所有重写版本的返回类型完全一致，根本无法适配不同模板参数的派生类），同时成员变量m_val漏写类型、构造函数赋值语句末尾缺分号、基类没有定义虚析构函数，这些都会直接触发编译错误。
2. 类型系统层面：C++是静态强类型语言，所有表达式的类型必须在编译阶段确定。你期望的v.at(2)->get()写法，编译器在处理这行代码时，根本无法预知下标2位置存储的是derived<int>、derived<std::string>还是其他模板实例，自然不可能凭空确定get()的返回类型，这是静态类型系统的底层规则，没有语法层面的“绕过”技巧，只能通过类型擦除的设计实现需求。

如果容器内存储的派生类模板参数类型是可提前枚举的（比如只会存int、double、std::string三类），这是最安全、最接近你预期写法的实现，完全不需要不安全的强制类型转换：

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

// 枚举所有支持的存储类型，作为get方法的统一返回值
using Value = std::variant<int, double, std::string>;

class base {
public:
    virtual ~base() = default; // 基类必须定义虚析构，否则通过基类指针释放派生类会触发内存泄漏
    virtual Value get() = 0;
};

template <typename T>
class derived : public base {
public:
    derived(T val) : m_val(std::move(val)) {} // 用初始化列表初始化成员，不要在构造函数体内赋值
    Value get() override {
        return m_val; // 任意T只要在Value的枚举列表里，就会自动包装成variant
    }
private:
    T m_val; // 补全成员变量的类型声明
};

使用方式完全符合你的预期，拿到variant后可以用std::visit做分支处理，或者确定类型时直接用std::get<T>取值：

int main() {
    std::vector<base*> v;
    v.push_back(new derived<int>(42));
    v.push_back(new derived<double>(3.14));
    v.push_back(new derived<std::string>("hello"));

    // 直接调用get拿到统一类型的返回值
    Value val = v.at(2)->get();
    std::cout << std::get<std::string>(val) << std::endl; // 输出hello

    // 记得释放内存，生产环境建议存std::unique_ptr<base>自动管理生命周期
    for (auto ptr : v) delete ptr;
    return 0;
}

如果需要支持任意T类型，无法提前枚举所有可能的存储类型，就用访问者模式把“对值的操作”下沉到派生类内部，避免在调用点做类型判断：

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

// 定义访问者基类，所有对存储值的操作都通过访问者的重载方法实现
class ValueVisitor {
public:
    virtual ~ValueVisitor() = default;
    virtual void apply(int val) = 0;
    virtual void apply(double val) = 0;
    virtual void apply(const std::string& val) = 0;
    // 需要支持新类型时，在这里加对应apply重载即可
};

class base {
public:
    virtual ~base() = default;
    virtual void accept(ValueVisitor* visitor) = 0; // 不直接返回值，把访问者传入派生类
};

template <typename T>
class derived : public base {
public:
    derived(T val) : m_val(std::move(val)) {}
    void accept(ValueVisitor* visitor) override {
        visitor->apply(m_val); // 派生类明确知道自身T类型，直接调用对应重载
    }
private:
    T m_val;
};

// 示例：实现一个打印值的访问者
class PrintVisitor : public ValueVisitor {
public:
    void apply(int val) override {
        std::cout << "int: " << val << '\n';
    }
    void apply(double val) override {
        std::cout << "double: " << val << '\n';
    }
    void apply(const std::string& val) override {
        std::cout << "string: " << val << '\n';
    }
};

使用示例：

int main() {
    std::vector<base*> v;
    v.push_back(new derived<int>(42));
    v.push_back(new derived<double>(3.14));
    v.push_back(new derived<std::string>("hello"));

    PrintVisitor printer;
    v.at(2)->accept(&printer); // 输出string: hello

    for (auto ptr : v) delete ptr;
    return 0;
}

如果业务场景非常简单，也可以在调用点用dynamic_cast判断派生类实际类型后再取值，但这种写法维护成本极高，每新增一个支持的类型就要修改所有调用点的分支逻辑，非常容易漏写出bug：

// 派生类可以直接定义返回T的get方法，不需要虚函数
template<typename T>
T derived<T>::get() {
    return m_val;
}

// 调用点手动判断类型
auto* item = dynamic_cast<derived<std::string>*>(v.at(2));
if (item) {
    std::string val = item->get();
}

不要尝试用void*存储值再强制转换，这种写法完全绕过类型系统，出现问题极难排查，属于C++开发中的反模式。

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