C++实现反射机制

最近，做项目遇到需要使用反射机制和工厂模式，于是便总结一下。

• 工厂模式

工厂模式算是一种很常用的设计模式了，应该都不陌生。假如需要运输货物，交通工具有汽车，火车，飞机，那么可以为每种交通工具都设计一个类，具体使用哪种交通工具时，只要实例化一个它的对象就可以。但是这样会产生很多冗余代码，也不方便代码可扩展。若是新增一个交通工具轮船，则又要新设计一个轮船类；如果交通工具模块与其他模块有交互，那么新增类别代码修改的地方会很多，也容易出错，牵一发动全身。而工厂模式可以解决这个问题。可以将创建实例和使用实例的工作分开，定义一个创建交通工具的接口，让子类自己决定实例哪一个交通工具。

class Transportation
{
public:
    Transportation() {}
    ~Transportation() {}
    virtual void run() = 0;
};
class Plane :public Transportation
{
public:
    Plane() {}
    ~Plane() {}
    virtual void run()
    {
        cout << "I am plane" << endl;
    }
};
class Train :public Transportation
{
public:
    Train(){}
    ~Train() {}
    virtual void run()
    {
        cout << "I am train" << endl;
    }
};
class TransportationFactory
{
public:
    static Transportation* createTransportation(const string& name)
    {
        if (name == "火车")
            return new Train;
        else if (name == "飞机")
            return new Plane;
    }
};

如上面代码所示，我们可以通过调用createTransportation方法传入不同的参数来获取不同的交通工具对象。

int main()
{
    TransportationFactory t;
    Transportation* obj = (Transportation*)t.createTransportation("飞机");
    obj->run();
    return 0;
}

上面就是一个简单的工厂模式。但是如果新增类别，仍然需要修改createTransportation函数中的if-else语句来新增接口；并且每次调用都新建一个实例返回。如果可以根据传入的字符串直接获取对应类的实例就非常方便。反射机制就是用来实现这一需求的。

• 反射机制

c++本身并不支持反射机制，但是可以实现一些简单的功能。

首先，需要设计一个保存类的信息以及创建类的实例的函数的数据结构，所以可以使用map，键名为类名，键值为创建对应类实例的函数名。

typedef void* (*register_func)();

class Store
{
public:
    static Store* getInstance();
    void* findInstance(const string& class_name);
    void registerStore(const string& class_name, register_func func);
private:
    static Store* instance;
    map<string, register_func> m_register;
};

Store* Store::instance = nullptr;

Store* Store::getInstance()
{
    if (!instance) instance = new Store;
    return instance;
}

void* Store::findInstance(const string& class_name)
{
    map < string, register_func>::iterator it = m_register.find(class_name);
    if (it == m_register.end())
        return nullptr;
    else
        return it->second();
}

void Store::registerInstance(const string& class_name, register_func func)
{
    m_register[class_name] = func;
}

这里使用单例模式创建Store类，用于存储类名和类的创建实例的函数。没新增一个类别，就使用registerInstance函数存储类名和创建实例的函数地址存入 map对象中；需要获取时，通过findInstance查找。

然后再定义一个注册类Register，通过构造函数调用Store类的registerInstance函数。

class Register
{
public:
    Register(string class_name, register_func func);
    ~Register();
};

Register::Register(string class_name, register_func func)
{
    Store::getInstance()->registerInstance(class_name, func);
}

Register::~Register() {}

最后，每创建一个新类别的时候，通过宏定义创建一个Register实例，实现新类别的注册。

#define REGISTER_CLASS(class_name) \
    class class_name##Register \
    { \
    public: \
        static void* newInstance() \
        { \
            return new class_name; \
        } \
    private: \
        static const Register reg; \
    }; \
const Register class_name##Register::reg(#class_name, class_name##Register::newInstance);

这里，在新增的交通工具类，比如Plane后面，使用REGISTER_CLASS(Plane)即可完成Plane类的实例注册。再修改TransportationFactory类的createTransportation函数如下：

class TransportationFactory
{
public:
    static Transportation* createTransportation(const string& name)
    {
        return (Transportation*)Store::getInstance()->findInstance(name);
    }
};

在主函数中调用Plane的实例的时候，只需要传入字符串就可以。

int main()
{
    Transportation* plane = (Plane*)TransportationFactory::createTransportation("Plane");
    if (plane == nullptr) cout << "failed" << endl;
    else plane->run();
    system("pause");
    return 0;
}

到此，一个简单的反射机制+工厂模式的功能模块就实现了。