如何在无需静态清理的场景下处理C++模板类静态成员与存储

针对你遇到的静态容器销毁晚于内存泄漏检查导致的假阳性问题，以下几个方案可以在不牺牲事件系统易用性和灵活性的前提下解决问题：

方案1：单例模式+手动生命周期管理 #

将事件系统改为单例，在内部维护所有模板容器的清理函数列表，在引擎内存泄漏检查前手动触发清理。

#include <vector>
#include <functional>
#include <eastl/unordered_map>
#include <eastl/tuple>

// 假设引擎指定的分配器类型为EngineAllocator
using EngineAllocator = eastl::allocator;

template <typename ListenerType, typename Type>
using FPtr = void(ListenerType::*)(Type);

template<typename ListenerType, typename Type>
using Tuple = eastl::tuple<ListenerType*, FPtr<ListenerType, Type>>;

template <typename ListenerType, typename Type>
using ListenerMap = eastl::unordered_map<uint32_t, Tuple<ListenerType, Type>, eastl::hash<uint32_t>, eastl::equal_to<uint32_t>, EngineAllocator>;

class EventSystem
{
private:
    std::vector<std::function<void()>> m_cleanupFuncs;

    template<typename ListenerType, typename Type>
    ListenerMap<ListenerType, Type>& getListenerMap()
    {
        // 使用引擎指定分配器初始化容器
        static ListenerMap<ListenerType, Type> s_listenerMap(EngineAllocator{});
        static bool s_cleanupRegistered = false;

        if (!s_cleanupRegistered)
        {
            // 注册清理函数：清空容器并重置，释放所有分配的内存
            m_cleanupFuncs.emplace_back([]() {
                s_listenerMap.clear();
                s_listenerMap = ListenerMap<ListenerType, Type>(EngineAllocator{});
            });
            s_cleanupRegistered = true;
        }
        return s_listenerMap;
    }

public:
    // 原有connect方法示例
    template<typename ListenerType, typename Type>
    void connect(ListenerType* listener, FPtr<ListenerType, Type> func)
    {
        auto& map = getListenerMap<ListenerType, Type>();
        // 假设用某种哈希方式生成key，这里简化处理
        uint32_t key = reinterpret_cast<uint32_t>(listener);
        map[key] = eastl::make_tuple(listener, func);
    }

    // 原有fire方法示例
    template<typename Type>
    void fire(const Type& event)
    {
        // 保留原有事件分发逻辑框架
        // ...
    }

    // 在引擎内存泄漏检查前调用此方法
    void shutdown()
    {
        // 逆序执行清理，避免依赖问题
        for (auto it = m_cleanupFuncs.rbegin(); it != m_cleanupFuncs.rend(); ++it)
        {
            (*it)();
        }
        m_cleanupFuncs.clear();
    }
};

// 全局单例，引擎初始化时创建，shutdown阶段调用shutdown()
inline EventSystem g_eventSystem;

优势：完全保留原有API的使用方式，只需在引擎 shutdown 流程中添加g_eventSystem.shutdown()调用即可，清理逻辑自动注册，无需手动维护事件类型列表。

方案2：利用atexit控制静态容器销毁时机 #

给每个静态容器注册std::atexit清理函数，让容器在程序退出前（内存泄漏检查前）完成清理。

template<typename ListenerType, typename Type>
ListenerMap<ListenerType, Type>& listenerMap()
{
    static ListenerMap<ListenerType, Type> s_listenerMap(EngineAllocator{});
    static bool s_cleanupRegistered = false;

    if (!s_cleanupRegistered)
    {
        // 注册清理函数，在程序退出时执行
        std::atexit([]() {
            s_listenerMap.clear();
            // 显式调用析构函数确保内存释放
            s_listenerMap.~ListenerMap();
        });
        s_cleanupRegistered = true;
    }
    return s_listenerMap;
}

注意：std::atexit的执行顺序是反向注册的，如果引擎的内存泄漏检查是在main函数结束后执行，此方案有效；若检查在main内的引擎shutdown流程中，需确保清理函数在检查前触发。

方案3：类型擦除的容器注册表 #

通过基类抽象所有模板容器，将实例统一存入全局注册表，shutdown时遍历清理。

#include <vector>

class BaseListenerMap
{
public:
    virtual ~BaseListenerMap() = default;
    virtual void clear() = 0;
};

template<typename ListenerType, typename Type>
class ConcreteListenerMap : public BaseListenerMap, public ListenerMap<ListenerType, Type>
{
public:
    using ListenerMap<ListenerType, Type>::ListenerMap;

    void clear() override
    {
        this->ListenerMap<ListenerType, Type>::clear();
    }
};

class EventSystem
{
private:
    static std::vector<BaseListenerMap*> s_allListenerMaps;

public:
    template<typename ListenerType, typename Type>
    ListenerMap<ListenerType, Type>& listenerMap()
    {
        static auto* pMap = new ConcreteListenerMap<ListenerType, Type>(EngineAllocator{});
        static bool s_addedToRegistry = false;

        if (!s_addedToRegistry)
        {
            s_allListenerMaps.push_back(pMap);
            s_addedToRegistry = true;
        }
        return *pMap;
    }

    static void shutdown()
    {
        for (auto* pMap : s_allListenerMaps)
        {
            pMap->clear();
            delete pMap;
        }
        s_allListenerMaps.clear();
    }
};

// 初始化静态注册表
std::vector<BaseListenerMap*> EventSystem::s_allListenerMaps;

优势：统一管理所有容器的生命周期，清理逻辑集中，适合复杂场景；缺点是容器采用动态分配，比方案1多一次内存分配。

方案4：使用未追踪分配器（备选） #

如果引擎允许，可以给静态容器使用不被内存管理器追踪的分配器，避免假泄漏报告：

// 假设引擎提供未追踪分配器UntrackedAllocator
template<typename ListenerType, typename Type>
ListenerMap<ListenerType, Type>& listenerMap()
{
    static ListenerMap<ListenerType, Type> s_listenerMap(UntrackedAllocator{});
    return s_listenerMap;
}

注意：此方案需引擎支持，且可能不符合内存追踪的要求，仅作为应急备选。

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