C++模板构建反射

template<typename ClassType>
class CCreateGeneralPool
{
private:
    //类型大小
    int m_elem_size;
    //当前通过内存池分配对象个数
    int m_alloc_num;
    //内存回收链表的头
    ClassType * m_free_list_head;
public:
    CCreateGeneralPool() : m_alloc_num(0), m_free_list_head(NULL)
    {
        m_elem_size = std::max(sizeof(ClassType), sizeof(ClassType*));            //确保最小分配空间 = 指针类型长度 兼容小对象如char
    }
    ~CCreateGeneralPool()
    {
        while (NULL != m_free_list_head)
        {
            ClassType* alloc_ret = m_free_list_head;
            m_free_list_head = *(reinterpret_cast<ClassType**>(m_free_list_head));
            free(alloc_ret);
        }
    }
public:
    ClassType * Create()
    {
        ++m_alloc_num;
        if (NULL == m_free_list_head)            //没有对象回收
            return new(malloc(m_elem_size))ClassType;
        ClassType* alloc_ret = m_free_list_head;
        m_free_list_head = *(reinterpret_cast<ClassType**>(m_free_list_head));      //头指针指向下个区块
        return new(alloc_ret)ClassType;
    }

    template<typename ... TParams>
    ClassType * Create(TParams ... params)
    {
        ++m_alloc_num;
        if (NULL == m_free_list_head)
            return new(malloc(m_elem_size))ClassType(params...);
        ClassType* alloc_ret = m_free_list_head;
        m_free_list_head = *(reinterpret_cast<ClassType**>(m_free_list_head));
        return new(alloc_ret)ClassType(params...);
    }

    void Free(ClassType * obj)
    {
        obj->~ClassType();
        --m_alloc_num;
        assert(m_alloc_num >= 0);
        *(reinterpret_cast<ClassType**>(obj)) = m_free_list_head;                //对象回收 未使用内存 逻辑上可强行解释成指向下个区块的指针
        m_free_list_head = obj;
    }
};

//对上面的生成器包一层
template <typename ClassType>
class CInstanceBasicBuild
{
public:
    CInstanceBasicBuild() {}
    virtual ~CInstanceBasicBuild() {}

    virtual void Free(ClassType * obj) { }

    static std::map<ClassType *, std::string > m_instance_class_names;
    static std::string& GetClassName(ClassType * obj)
    {
        static std::string class_name;
        if (NULL != obj)
        {
            std::map<ClassType *, std::string >::iterator iter = m_instance_class_names.find(obj);
            if (iter != m_instance_class_names.end())
                return iter->second;
        }
        return class_name;
    }

    static void Remove(ClassType * obj)
    {
        if (NULL != obj)
        {
            m_instance_class_names.erase(obj);
        }
    }
};
template <typename ClassType> std::map<ClassType *, std::string > CInstanceBasicBuild<ClassType>::m_instance_class_names;

template<typename ClassType, typename BassClass>
class CInstanceBuilder : public CInstanceBasicBuild<BassClass>
{
private:
    CCreateGeneralPool<ClassType> m_instance_builder;
public:
    std::string m_class_name;
    CInstanceBuilder() { }
    CInstanceBuilder(const std::string class_name)
    {
        m_class_name = class_name;
    }
public:
    BassClass * Create()
    {
        BassClass * pInstance = m_instance_builder.Create();
        m_instance_class_names[pInstance] = m_class_name;
        return pInstance;
    }

    template<typename ... ParamType>
    BassClass * Create(const ParamType& ... params)
    {
        BassClass * pInstance = m_instance_builder.Create(params...);
        m_instance_class_names[pInstance] = m_class_name;
        return pInstance;
    }

    void FreeObj(ClassType * obj)
    {
        m_instance_builder.Free(obj);
    }

    static CInstanceBuilder * Cast(CInstanceBasicBuild<BassClass> * obj)
    {
        return (CInstanceBuilder*)obj;
    }

    void Free(BassClass * obj)
    {
        if (NULL != obj)
        {
            CInstanceBasicBuild<BassClass>::Remove(obj);
            FreeObj((ClassType*)obj);
        }
    }
};

//具体创建器
template<typename BasicClass>
class CInstanceBuildFactory
{
private:
    CInstanceBuildFactory() {}
    ~CInstanceBuildFactory() {}
    DisableCopy(CInstanceBuildFactory)

public:
    static CInstanceBuildFactory& GetInstance()
    {
        static CInstanceBuildFactory obj;
        return obj;
    }

public:
    void SetBuilder(const std::string& class_name, CInstanceBasicBuild<BasicClass>* builder)
    {
        m_builders[class_name] = builder;
    }

    CInstanceBasicBuild<BasicClass>* GetBuilder(const std::string& class_name)
    {
        std::map<std::string, CInstanceBasicBuild<BasicClass>* >::iterator iter = m_builders.find(class_name);
        if (iter != m_builders.end())
            return iter->second;
        return NULL;
    }

    //解析对象
    template<typename T>
    void Delete(T * obj)
    {
        CInstanceBasicBuild<BasicClass>* pBuilder = GetBuilder(CInstanceBasicBuild<BasicClass>::GetClassName(obj));
        if (NULL != pBuilder)
        {
            pBuilder->Free(obj);
        }
    }

private:
    //!真正的生发对象
    std::map<std::string, CInstanceBasicBuild<BasicClass>* > m_builders;
};

template<typename Class, typename BasicClass>
class CGetInstanceBuilder
{
public:
    //得到创建器基类
    static CInstanceBasicBuild<BasicClass>* GetBuilder(const std::string& class_name)
    {
        CInstanceBasicBuild<BasicClass>* pBuilder = CInstanceBuildFactory<BasicClass>::GetInstance().GetBuilder(class_name);
        if (NULL == pBuilder)
        {
            pBuilder = new CInstanceBuilder<Class, BasicClass>(class_name);
            CInstanceBuildFactory<BasicClass>::GetInstance().SetBuilder(class_name, pBuilder);
        }
        return pBuilder;
    }

    //得到具体创建器
    static CInstanceBuilder<Class, BasicClass> * GetInstanceBuilder(const std::string& class_name)
    {
        CInstanceBasicBuild<BasicClass>* pBuilder = GetBuilder(class_name);
        if (NULL != pBuilder)
        {
            CInstanceBuilder<Class, BasicClass> * pInstanceBuilder = CInstanceBuilder<Class, BasicClass>::Cast(pBuilder);
            return pInstanceBuilder;
        }
        return NULL;
    }
};

//接口宏 用宏1创建的对象 必须用宏2进行删除
//获取对象create器具
#define GETINSTANCEBUILDER(Class, BasicClass) \
CGetInstanceBuilder<Class, BasicClass>::GetInstanceBuilder(#Class)
//释放对象
#define DELETEINSTANCE(BasicClass , pInstance) \
CInstanceBuildFactory<BasicClass>::GetInstance().Delete(pInstance);