如何用模板子类正确重写基类？解决编译报错与多态存储问题

核心问题分析 #

你编译失败的根本原因是子类的set(T)与基类的set(float)签名不匹配，这属于函数重载而非覆盖，导致基类的虚函数未被正确实现。要将不同模板实例的子类指针存入同一vector，必须保证子类严格覆盖基类的虚函数，同时保留模板类型的灵活性。

正确实现方案 #

1. 基类设计（非模板，带虚析构） #

基类必须定义虚析构（避免多态析构时内存泄漏），以及统一的虚函数接口：

#include <vector>
#include <memory>
#include <iostream>

class Configuration {
public:
    // 必须添加虚析构，确保子类对象能被正确销毁
    virtual ~Configuration() = default;
    
    // 统一的虚函数接口
    virtual void set(float value) = 0;
    virtual float get() const = 0;
};

2. 模板子类实现（正确覆盖虚函数） #

子类需用override关键字明确覆盖基类虚函数，同时可额外提供类型安全的set/get方法（方便直接操作子类对象时的类型检查）：

template<typename T>
class Config : public Configuration {
private:
    T m_value;
public:
    // 严格覆盖基类的set(float)：完成float到T的类型转换
    void set(float value) override {
        m_value = static_cast<T>(value);
    }

    // 严格覆盖基类的get()：完成T到float的类型转换
    float get() const override {
        return static_cast<float>(m_value);
    }

    // 额外提供类型安全的set方法（仅子类对象可调用）
    void set(const T& value) {
        m_value = value;
    }

    // 额外提供类型安全的get方法（仅子类对象可调用）
    const T& get() const {
        return m_value;
    }
};

3. 特殊类型的模板特化（可选） #

如果某些类型（如std::string）无法直接通过static_cast转换，可针对该类型做模板特化：

#include <string>

template<>
class Config<std::string> : public Configuration {
private:
    std::string m_value;
public:
    void set(float value) override {
        m_value = std::to_string(value);
    }

    float get() const override {
        try {
            return std::stof(m_value);
        } catch (...) {
            return 0.0f; // 处理字符串转float失败的情况
        }
    }

    void set(const std::string& value) {
        m_value = value;
    }

    const std::string& get() const {
        return m_value;
    }
};

4. 多态存储与使用 #

使用vector存储基类指针（推荐用智能指针避免内存泄漏）：

int main() {
    // 用智能指针管理，无需手动delete
    std::vector<std::unique_ptr<Configuration>> configs;

    // 添加int类型的配置
    auto int_cfg = std::make_unique<Config<int>>();
    int_cfg->set(42); // 调用子类类型安全的set(int)
    configs.push_back(std::move(int_cfg));

    // 添加double类型的配置
    auto double_cfg = std::make_unique<Config<double>>();
    double_cfg->set(3.14); // 调用子类类型安全的set(double)
    configs.push_back(std::move(double_cfg));

    // 添加string类型的配置
    auto str_cfg = std::make_unique<Config<std::string>>();
    str_cfg->set("123.45"); // 调用子类类型安全的set(string)
    configs.push_back(std::move(str_cfg));

    // 多态调用基类接口
    for (const auto& cfg : configs) {
        std::cout << "Value (float): " << cfg->get() << std::endl;
    }

    // 如果需要调用子类类型安全的方法，可强制转换（需确保类型正确）
    auto casted_int_cfg = static_cast<Config<int>*>(configs[0].get());
    std::cout << "Original int value: " << casted_int_cfg->get() << std::endl;

    return 0;
}

关键注意事项 #

• override关键字：强制编译器检查是否正确覆盖基类虚函数，避免因签名错误导致的隐性问题。
• 虚析构：基类必须定义虚析构，否则通过基类指针销毁子类对象时会泄漏内存。
• 智能指针：优先使用std::unique_ptr或std::shared_ptr管理动态对象，避免手动内存管理的风险。

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