C++反射机制：可变参数模板实现C++反射（二）

1. 概要

??2018年Bwar发布了，文章非常实用，Bwar也见过好几个看了那篇文章后以同样方法实现反射的项目，也见过不少从我的文章抄过去连代码风格类名函数变量名什么都没改或者只是简单改一下重新发表的。被抄说明有价值，分享出来就不在意被抄，觉得文章有用就star Nebula吧，谢谢。那些用了可变参数模板实现反射的项目或文章大都是通过这种方法实现无参数版本的类对象构建，无参版本不能充分体现可变参数模板实现反射的真正价值。上篇文章中关于Targ...模板参数的说明不够详细且有些描述有问题，这次再写一篇这种反射实现的补充，重点说明容易出错的可变参数部分并纠正上篇的错误。毕竟在Nebula高性能网络框架中所有actor对象的创建都必须以反射方式创建，驾驭这种反射方式创建对象让Nebula的使用更轻松。

2. 引用折叠与类型推导

??可变参数模板主要通过T&&引用折叠及其类型推导实现的。关于引用折叠及类型推导的说明，网上可以找到大量资料，这里就不再赘述，推荐一篇言简意赅清晰明了的文章。

3. 回顾一下Nebula网络框架中的C++反射机制实现

??Nebula的Actor为事件（消息）处理者，所有业务逻辑均抽象成事件和事件处理，反射机制正是应用在Actor的动态创建上。Actor分为Cmd、Module、Step、Session四种不同类型。业务逻辑代码均通过从这四种不同类型时间处理者派生子类来实现，专注于业务逻辑实现，而无须关注业务逻辑之外的内容。Cmd和Module都是消息处理入库，业务开发人员定义了什么样的Cmd和Module对框架而言是未知的，因此这些Cmd和Module都配置在配置文件里，Nebula通过配置文件中的Cmd和Module的名称（字符串）完成它们的实例创建。通过反射机制动态创建Actor的关键代码如下：

Actor的类声明：

class Actor: public std::enable_shared_from_this

Actor创建工厂：

template
class ActorFactory
{
public:
    static ActorFactory* Instance()
    {
        if (nullptr == m_pActorFactory)
        {
            m_pActorFactory = new ActorFactory();
        }
        return(m_pActorFactory);
    }

    virtual ~ActorFactory(){};

    // 将“实例创建方法（DynamicCreator的CreateObject方法）”注册到ActorFactory，注册的同时赋予这个方法一个名字“类名”，后续可以通过“类名”获得该类的“实例创建方法”。这个实例创建方法实质上是个函数指针，在C++11里std::function的可读性比函数指针更好，所以用了std::function。
    bool Regist(const std::string& strTypeName, std::function pFunc);

    // 传入“类名”和参数创建类实例，方法内部通过“类名”从m_mapCreateFunction获得了对应的“实例创建方法（DynamicCreator的CreateObject方法）”完成实例创建操作。
    Actor* Create(const std::string& strTypeName, Targs&&... args);

private:
    ActorFactory(){};
    static ActorFactory* m_pActorFactory;
    std::unordered_map > m_mapCreateFunction;
};

template
ActorFactory* ActorFactory::m_pActorFactory = nullptr;

template
bool ActorFactory::Regist(const std::string& strTypeName, std::function pFunc)
{
    if (nullptr == pFunc)
    {
        return (false);
    }
    bool bReg = m_mapCreateFunction.insert(
                    std::make_pair(strTypeName, pFunc)).second;
    return (bReg);
}

template
Actor* ActorFactory::Create(const std::string& strTypeName, Targs&&... args)
{
    auto iter = m_mapCreateFunction.find(strTypeName);
    if (iter == m_mapCreateFunction.end())
    {
        return (nullptr);
    }
    else
    {
        return (iter->second(std::forward(args)...));
    }
}

动态创建类：

template
class DynamicCreator
{
public:
    struct Register
    {
        Register()
        {
            char* szDemangleName = nullptr;
            std::string strTypeName;
#ifdef __GNUC__
            szDemangleName = abi::__cxa_demangle(typeid(T).name(), nullptr, nullptr, nullptr);
#else
            // 注意：这里不同编译器typeid(T).name()返回的字符串不一样，需要针对编译器写对应的实现
            //in this format?:     szDemangleName =  typeid(T).name();
            szDemangleName = abi::__cxa_demangle(typeid(T).name(), nullptr, nullptr, nullptr);
#endif
            if (nullptr != szDemangleName)
            {
                strTypeName = szDemangleName;
                free(szDemangleName);
            }
            ActorFactory::Instance()->Regist(strTypeName, CreateObject);
        }
        inline void do_nothing()const { };
    };

    DynamicCreator()
    {
        m_oRegister.do_nothing();   // 这里的函数调用虽无实际内容，却是在调用动态创建函数前完成m_oRegister实例创建的关键
    }
    virtual ~DynamicCreator(){};

    // 动态创建实例的方法，所有Actor实例均通过此方法创建。这是个模板方法，实际上每个Actor的派生类都对应了自己的CreateObject方法。
    static T* CreateObject(Targs&&... args)
    {
        T* pT = nullptr;
        try
        {
            pT = new T(std::forward(args)...);
        }
        catch(std::bad_alloc& e)
        {
            return(nullptr);
        }
        return(pT);
    }

private:
    static Register m_oRegister;
};

template
typename DynamicCreator::Register DynamicCreator::m_oRegister;

??上面ActorFactory和DynamicCreator就是C++反射机制的全部实现。要完成实例的动态创建还需要类定义必须满足（模板）要求。下面看一个可以动态创建实例的CmdHelloNebula吧，谢谢。