C++模板多态workaround：如何实现Base类的泛型get<T>()接口

核心实现思路 #

利用类型擦除技术，在基类中隐藏派生类的具体类型信息，通过泛型接口封装类型转换逻辑，既不需要基类感知派生类的值类型，也不需要提前定义大量特定类型的虚函数。

完整实现代码 #

基类定义 #

#include <any>
#include <stdexcept>
#include <type_traits>
#include <string>

class Base {
public:
    virtual ~Base() = default; // 多态基类必须提供虚析构函数

    // 你需要的泛型get接口
    template <typename T>
    T getValueAs() const {
        std::any raw_val = getRawValue();
        // 类型完全匹配直接返回
        if (raw_val.type() == typeid(T)) {
            return std::any_cast<T>(raw_val);
        }
        // 算术类型自动显式转换
        if constexpr (std::is_arithmetic_v<T>) {
            if (raw_val.type() == typeid(float)) return static_cast<T>(std::any_cast<float>(raw_val));
            if (raw_val.type() == typeid(double)) return static_cast<T>(std::any_cast<double>(raw_val));
            if (raw_val.type() == typeid(int)) return static_cast<T>(std::any_cast<int>(raw_val));
            if (raw_val.type() == typeid(bool)) return static_cast<T>(std::any_cast<bool>(raw_val));
            // 可自行扩展支持更多算术类型
        }
        // 字符串转换规则可按需扩展
        if constexpr (std::is_same_v<T, std::string>) {
            if (raw_val.type() == typeid(int)) return std::to_string(std::any_cast<int>(raw_val));
            if (raw_val.type() == typeid(float)) return std::to_string(std::any_cast<float>(raw_val));
        }
        throw std::bad_any_cast();
    }

    // 你需要的泛型set接口
    template <typename T>
    void setValueFrom(T val) {
        setRawValue(std::move(val));
    }

protected:
    // 类型擦除用的虚函数接口
    virtual std::any getRawValue() const = 0;
    virtual void setRawValue(std::any val) = 0;
};

派生类模板定义 #

template<typename T>
class Impl : public Base {
public:
    virtual void setValue(const T& val) {
        value = val;
    }
    virtual T getValue() const {
        return value;
    }

protected:
    std::any getRawValue() const override {
        return value;
    }

    void setRawValue(std::any val) override {
        // 类型完全匹配直接赋值
        if (val.type() == typeid(T)) {
            value = std::any_cast<T>(val);
            return;
        }
        // 算术类型自动转换
        if constexpr (std::is_arithmetic_v<T>) {
            if (val.type() == typeid(float)) {
                value = static_cast<T>(std::any_cast<float>(val));
                return;
            }
            if (val.type() == typeid(int)) {
                value = static_cast<T>(std::any_cast<int>(val));
                return;
            }
            // 可自行扩展更多转换规则
        }
        throw std::bad_any_cast();
    }

    T value;
};

// 自定义特殊派生类示例
class NumVal : public Impl<int> {};

调用示例 #

完全符合你期望的调用方式：

int main() {
    Impl<float> var;
    var.setValue(42.0f);
    Base* baseVar = &var;

    int convertedVal = baseVar->getValueAs<int>(); 
    // convertedVal的值为42，符合预期
    return 0;
}

方案优势 #

• 基类Base完全不需要感知派生类的具体值类型，符合你的限制要求
• 不需要提前定义大量特定类型的虚函数，泛型接口支持任意类型扩展，只需补充对应的转换规则即可
• 上层调用逻辑完全不需要修改，和你期望的写法一致

可选轻量化方案 #

如果对运行时性能要求较高，不想使用std::any的开销，且仅需要支持有限的数值类型，可以自己实现轻量级类型擦除：用共用体存储值+类型枚举标识，替换std::any即可，开销和普通虚函数调用几乎一致。

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