C++中按子类类型存储对象并实现类型安全的集合访问方案问询

问题1：不拷贝集合的前提下向下转型访问元素 #

你遇到的编译错误本质是：std::set<Status*> 和 std::set<Burn*> 是完全独立的类型，无法隐式转换，且编译器不会自动把Status*转成Burn*。但因为你已经通过std::type_index确保了这个集合里的所有元素都是Burn子类的指针，所以可以用**显式的static_cast**安全完成转换，完全不需要拷贝集合：

auto burn_set_it = statuses.find(typeid(Burn));
if (burn_set_it != statuses.end()) {
    // 遍历每个Status*，显式转成Burn*
    for (Status* status_ptr : burn_set_it->second) {
        const Burn* burn_ptr = static_cast<const Burn*>(status_ptr);
        // 这里直接使用burn_ptr即可
    }
}

为什么用static_cast而非dynamic_cast？因为你通过typeid严格匹配了类型，集合内的元素必然是Burn*的基类指针，static_cast性能更好且完全安全。如果担心后续有人错误插入其他类型的Status子类，可以在插入时做校验：

template <typename T>
void add_status(T* status) {
    static_assert(std::is_base_of_v<Status, T>, "T must be a subclass of Status");
    // 确保插入的实例类型和map的key完全匹配
    auto key = typeid(T);
    statuses[key].insert(status);
}

这样能从源头保证集合内元素的类型一致性，让static_cast的使用更可靠。

另外，如果你想让遍历代码更简洁，也可以写一个迭代器适配器/视图类，把std::set<Status*>包装成可以直接迭代Burn*的视图，避免每次手动转换：

template <typename Derived, typename Base>
class DowncastSetView {
private:
    std::set<Base*>& underlying_set_;

public:
    explicit DowncastSetView(std::set<Base*>& set) : underlying_set_(set) {}

    // 自定义迭代器，自动完成向下转型
    class Iterator {
    private:
        typename std::set<Base*>::iterator it_;
    public:
        explicit Iterator(typename std::set<Base*>::iterator it) : it_(it) {}

        Derived* operator*() const {
            return static_cast<Derived*>(*it_);
        }

        Iterator& operator++() {
            ++it_;
            return *this;
        }

        bool operator!=(const Iterator& other) const {
            return it_ != other.it_;
        }
    };

    Iterator begin() { return Iterator(underlying_set_.begin()); }
    Iterator end() { return Iterator(underlying_set_.end()); }
};

使用时就像这样：

auto burn_set_it = statuses.find(typeid(Burn));
if (burn_set_it != statuses.end()) {
    DowncastSetView<Burn, Status> burn_view(burn_set_it->second);
    for (const Burn* b : burn_view) {
        // 直接使用b，无需手动转换
    }
}

这个视图完全不拷贝原集合，只是在迭代时做类型转换，性能开销可以忽略。

问题2：更优雅的同类型子类集中存储方案 #

你的核心需求是：自动为每个Status子类维护独立集合，无需手动声明，且避免dynamic_cast的性能开销。可以用模板驱动的类型安全存储方案，通过std::map<std::type_index, void*>存储不同类型的std::set，再用模板方法封装访问逻辑，让调用方完全感知不到底层的类型擦除：

#include <map>
#include <set>
#include <memory>
#include <typeindex>
#include <type_traits>

class Status {
public:
    virtual ~Status() = default;
    // 你的基类逻辑
};

class Burn : public Status {};
class Stun : public Status {};

class StatusManager {
private:
    // 用void*存储任意类型的std::set，通过type_index索引
    std::map<std::type_index, std::unique_ptr<void>> storage_;

    // 内部模板方法：获取对应子类的集合，不存在则创建
    template <typename T>
    std::set<std::shared_ptr<T>>& get_or_create_set() {
        static_assert(std::is_base_of_v<Status, T>, "T must inherit from Status");
        const auto type_key = typeid(T);
        
        auto it = storage_.find(type_key);
        if (it == storage_.end()) {
            // 创建新的std::set<std::shared_ptr<T>>并存储
            auto new_set = std::make_unique<std::set<std::shared_ptr<T>>>();
            it = storage_.emplace(type_key, std::move(new_set)).first;
        }

        // 把void*转成对应类型的set指针
        return *static_cast<std::set<std::shared_ptr<T>>*>(it->second.get());
    }

public:
    // 添加状态：自动存入对应子类的集合
    template <typename T>
    void add_status(std::shared_ptr<T> status) {
        get_or_create_set<T>().insert(std::move(status));
    }

    // 获取对应子类的所有状态：直接返回子类指针的集合
    template <typename T>
    std::set<std::shared_ptr<T>>& get_statuses() {
        return get_or_create_set<T>();
    }

    // 移除状态
    template <typename T>
    void remove_status(std::shared_ptr<T> status) {
        auto& target_set = get_or_create_set<T>();
        target_set.erase(status);
    }
};

使用这个管理器的代码会非常简洁直观：

int main() {
    StatusManager manager;

    // 添加不同类型的状态
    auto burn1 = std::make_shared<Burn>();
    auto burn2 = std::make_shared<Burn>();
    auto stun1 = std::make_shared<Stun>();
    
    manager.add_status(burn1);
    manager.add_status(burn2);
    manager.add_status(stun1);

    // 直接获取所有Burn状态，无需任何转换
    auto& all_burns = manager.get_statuses<Burn>();
    for (const auto& burn : all_burns) {
        // burn的类型是std::shared_ptr<Burn>，直接使用
    }

    // 获取所有Stun状态同理
    auto& all_stuns = manager.get_statuses<Stun>();
}

这个方案的优势：

1. 完全自动维护集合：新增Status子类时，不需要手动声明对应的集合，直接用add_status和get_statuses<T>即可。
2. 类型安全：编译期通过static_assert确保T是Status的子类，运行期通过type_index保证集合类型匹配。
3. 无额外性能开销：不需要dynamic_cast，所有类型转换都是编译期确定的static_cast。
4. 内存安全：用std::shared_ptr管理状态实例的生命周期，避免内存泄漏（你也可以根据需求换成std::unique_ptr）。

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