如何避免模板派生类从基类转换后出现类型不匹配问题？

我需要实现一个管理ObjArray模板类的容器，ObjArray继承自基类IObjArray，容器存储基类指针，操作时需转换为对应类型。当前存在核心问题：调用者可将错误类型对象添加到对应ObjArray中（如把CustomA对象加入CustomB类型的ObjArray，代码可编译但会引发未定义行为）。

需求约束：

• 采用基于ID的索引机制保证效率
• 不使用typeid映射方式
• 无法将AddObj这类模板方法加入IObjArray接口

请问是否有办法解决该问题，还是只能依赖调用者自行注意？

代码示例 #

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

struct CustomA{
    int a;
};

struct CustomB{
    float b;
};

class IObjArray{
    public:
    virtual void RemoveObj(int obj_id) = 0;
    virtual ~IObjArray() = default;
};

template<typename T>
class ObjArray : public IObjArray{
    public:
    void RemoveObj(int obj_id) override {
        std::cout << "Removing object of id" << obj_id << "\n";
        // 移除对象的逻辑...
    }
    void AddT(T obj){
        vec_of_T_.push_back(obj);
    }
private:
    std::vector<T> vec_of_T_;
};

class ObjManager{
    public:
    template<typename obj>
    size_t RegisterObj(){
        list_.emplace_back(std::make_unique<ObjArray<obj>>());
        return list_.size() - 1;
    }
    
    template<typename T>
    void AddObj(size_t obj_array_id, T obj){
        static_cast<ObjArray<T>*>(list_[obj_array_id].get())->AddT(obj);
    }
    private:
    std::vector<std::unique_ptr<IObjArray>> list_;
};

int main()
{
    ObjManager om;
    auto id_a = om.RegisterObj<CustomA>();
    auto id_b = om.RegisterObj<CustomB>();
    CustomA a{0};
    om.AddObj(id_a, a);
    om.AddObj(id_b, a); // 编译通过但存在风险，将CustomA加入CustomB类型的ObjArray
    // om.AddObj<CustomB>(id_b, a); // 此写法编译失败，因为类型不匹配
    return 0;
}

可行解决方案 #

方案一：编译期类型安全的ID（最优选择） #

给ID添加类型信息，让AddObj在编译期就能验证类型匹配，完全避免错误，且不影响效率。

实现代码

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

struct CustomA{
    int a;
};

struct CustomB{
    float b;
};

class IObjArray{
    public:
    virtual void RemoveObj(int obj_id) = 0;
    virtual ~IObjArray() = default;
};

template<typename T>
class ObjArray : public IObjArray{
    public:
    void RemoveObj(int obj_id) override {
        std::cout << "Removing object of id" << obj_id << "\n";
    }
    void AddT(T obj){
        vec_of_T_.push_back(obj);
    }
private:
    std::vector<T> vec_of_T_;
};

// 带类型信息的强类型ID
template<typename T>
struct ObjArrayId {
    size_t value;
    explicit ObjArrayId(size_t v) : value(v) {}
};

class ObjManager{
    public:
    template<typename obj>
    ObjArrayId<obj> RegisterObj(){
        list_.emplace_back(std::make_unique<ObjArray<obj>>());
        return ObjArrayId<obj>(list_.size() - 1);
    }
    
    template<typename T>
    void AddObj(ObjArrayId<T> obj_array_id, T obj){
        // 编译期已保证类型匹配，static_cast安全
        static_cast<ObjArray<T>*>(list_[obj_array_id.value].get())->AddT(obj);
    }
    private:
    std::vector<std::unique_ptr<IObjArray>> list_;
};

int main()
{
    ObjManager om;
    auto id_a = om.RegisterObj<CustomA>();
    auto id_b = om.RegisterObj<CustomB>();
    CustomA a{0};
    om.AddObj(id_a, a);
    // om.AddObj(id_b, a); // 直接编译失败：类型不匹配，拦截错误
    return 0;
}

方案二：运行时类型校验 #

如果无法修改ID的类型，可以给每个ObjArray添加唯一类型标识，在AddObj时做运行时检查，提前抛出错误避免未定义行为。

实现代码

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

struct CustomA{
    int a;
};

struct CustomB{
    float b;
};

class IObjArray{
    public:
    virtual void RemoveObj(int obj_id) = 0;
    virtual size_t GetTypeId() const = 0;
    virtual ~IObjArray() = default;
};

// 生成唯一类型ID的模板（无额外开销）
template<typename T>
struct TypeIdGenerator {
    static const size_t value;
};

template<typename T>
const size_t TypeIdGenerator<T>::value = reinterpret_cast<size_t>(&TypeIdGenerator<T>::value);

template<typename T>
class ObjArray : public IObjArray{
    public:
    void RemoveObj(int obj_id) override {
        std::cout << "Removing object of id" << obj_id << "\n";
    }
    void AddT(T obj){
        vec_of_T_.push_back(obj);
    }
    size_t GetTypeId() const override {
        return TypeIdGenerator<T>::value;
    }
private:
    std::vector<T> vec_of_T_;
};

class ObjManager{
    public:
    template<typename obj>
    size_t RegisterObj(){
        list_.emplace_back(std::make_unique<ObjArray<obj>>());
        return list_.size() - 1;
    }
    
    template<typename T>
    void AddObj(size_t obj_array_id, T obj){
        auto* arr = static_cast<ObjArray<T>*>(list_[obj_array_id].get());
        // 运行时校验类型匹配
        if (arr->GetTypeId() != TypeIdGenerator<T>::value) {
            throw std::runtime_error("类型不匹配：无法将对象加入错误类型的ObjArray");
        }
        arr->AddT(obj);
    }
    private:
    std::vector<std::unique_ptr<IObjArray>> list_;
};

int main()
{
    ObjManager om;
    auto id_a = om.RegisterObj<CustomA>();
    auto id_b = om.RegisterObj<CustomB>();
    CustomA a{0};
    om.AddObj(id_a, a);
    try {
        om.AddObj(id_b, a); // 运行时抛出异常
    } catch(const std::exception& e) {
        std::cerr << e.what() << '\n';
    }
    return 0;
}

方案三：类型安全的容器访问接口 #

封装ObjArray的获取逻辑，让调用者必须通过正确类型获取容器，再调用AddT，编译器会自动检查参数类型。

实现代码

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

struct CustomA{
    int a;
};

struct CustomB{
    float b;
};

class IObjArray{
    public:
    virtual void RemoveObj(int obj_id) = 0;
    virtual ~IObjArray() = default;
};

template<typename T>
class ObjArray : public IObjArray{
    public:
    void RemoveObj(int obj_id) override {
        std::cout << "Removing object of id" << obj_id << "\n";
    }
    void AddT(T obj){
        vec_of_T_.push_back(obj);
    }
private:
    std::vector<T> vec_of_T_;
};

class ObjManager{
    public:
    template<typename obj>
    size_t RegisterObj(){
        list_.emplace_back(std::make_unique<ObjArray<obj>>());
        return list_.size() - 1;
    }
    
    template<typename T>
    ObjArray<T>* GetObjArray(size_t obj_array_id){
        auto* arr = dynamic_cast<ObjArray<T>*>(list_[obj_array_id].get());
        if (!arr) {
            throw std::runtime_error("类型不匹配：无法获取指定类型的ObjArray");
        }
        return arr;
    }
    private:
    std::vector<std::unique_ptr<IObjArray>> list_;
};

int main()
{
    ObjManager om;
    auto id_a = om.RegisterObj<CustomA>();
    auto id_b = om.RegisterObj<CustomB>();
    CustomA a{0};
    om.GetObjArray<CustomA>(id_a)->AddT(a);
    // om.GetObjArray<CustomB>(id_b)->AddT(a); // 编译失败：AddT接受CustomB，传入CustomA类型不匹配
    return 0;
}

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