C++实现反射并应用于简单工厂模式

简单工厂模式

简单工厂模式（simple factory）是类的创建模式，又叫静态工厂方法（static factory method）模式。简单工厂模式就是由一个工厂类根据传入的参数决定创建哪一种的产品类。

简单工厂模式实例：

// Animal.h
class Animal
{
public:
    Animal() {}
    virtual void speak() = 0;
};

// Dog.h
class Dog : public Animal
{
public:
    Dog() {}
    void speak()
    {
        printf("我是小狗不会说话：汪汪汪！！！\n");
    }
};

// Man.h
class Man : public Animal
{
public:
    Man() {}
    void speak()
    {
        printf("我是人我会说话：哈哈哈！！！\n");
    }
};

// AnimalFactory.h
class AnimalFactory
{
public:
    static Animal * createAnimal(std::string name)
    {
        if (name == "Man")
        {
            return new Man();
        }
        else
        {
            return new Dog();
        }
    }
};

// main.cpp
int main()
{
    Animal * man = AnimalFactory::createAnimal("Man");
    man->speak();
    Animal * dog = AnimalFactory::createAnimal("Dog");
    dog->speak();
}

输出结果：

我是人我会说话：哈哈哈！！！
我是小狗不会说话：汪汪汪！！！

上面代码中，定义了一个动物（Animal）接口，接着分别定义了人（Man）和狗（Dog）实现类，实现了speak()说话的方法。

如果不用工厂模式，在调用人的说话方法时需要new一个人（Man）的对象，使用狗的说话方式时，需要new一个狗（Dog）类的对象。这样在new对象时依赖了子类的实现方式，增加了代码的耦合度。在代码中使用new操作其实也是一种硬编码方式。

使用简单工厂模式解决这个问题（上面的代码），封装一个工厂类，把new对象的操作放在这个工厂类中，这样我们在调用子类里面的方法时，并不需要考虑子类的实现方式，只需要调用工厂类，让工厂类给我们实现new对象的过程，使子类与外界操作没有联系，降低代码耦合性。

但是简单工厂模式有个很大的弊端，就是现在要实现很多动物的speak()方法，那么工厂类里面就要不断的添加new对象的操作，修改里面的代码，很显然这样并没有正在的解耦。

采用反射机制优化简单工厂模式

反射在java中使用的比较多，而且用起来非常方便。C++本身并不支持，但可以模拟一些简单的特性。

上述工厂模式的实例需要一种能根据字符串动态获取对应动物子类实例的方法。这样在工厂类的createAnimal方法中就可以根据字符串直接获取对应动物子类的实例，而不需要每次通过新增else if 子句来新增一个动物子类接口。也就是说，利用反射和简单工厂模式，下次当我们需要新增一个动物子类的时候只需要新增一个动物子类即可，不需要修改原来的任何代码，实现了正在的解耦。

如何在C++中实现反射：

• 需要一个全局的map用于存储类的信息以及创建实例的函数

• 需要反射的类提供一个用于创建自身实例的函数

• 利用类的静态变量在程序启动的时候初始化过程将类名及创建实例的函数存入map中

相关代码如下：

template<typename T> void * createT() { return new T; }

class InstanceFactory
{
public:
    typedef std::map<std::string, void*(*)()> map_type;

    static void * createInstance(std::string const& s) 
    {
        map_type::iterator it = getMap().find(s);
        if (it == getMap().end())
            return NULL;
        return it->second();
    }

protected:
    static map_type & getMap();
};

template<typename T>
class InstanceRegister : InstanceFactory
{
public:
    InstanceRegister(std::string const& s)
    {
        getMap()[s] = &createT<T>;
    }
};

#define  REGISTER_TYPE(ClassName) \
class ClassName##Register {\
    static const InstanceRegister<ClassName> reg;\
};\
const InstanceRegister<ClassName> ClassName##Register::reg(#ClassName)

// InstanceFactory.cpp
InstanceFactory::map_type & InstanceFactory::getMap()
{
    static InstanceFactory::map_type registerMap;
    return registerMap;
}

还需要修改工厂类的createAnimal函数，利用InstanceFactory的newInstance函数来创建实例：

class AnimalFactory
{
public:
    static Animal * createAnimal(std::string name)
    {
        return (Animal *)InstanceFactory::createInstance(name);
    }
};

getMap函数的registerMap变量是static类型的map，在getMap第一次调用时完成registerMap变量的初始化。确保后续注册时registerMap变量先初始化。

newInstance函数，传入类名，查找map，调用回调函数，返回一个对应类的实例。

InstanceRegister类继承InstanceFactory，只有一个构造函数，传入类名和用于创建实例的函数并将信息存入全局的map中。

利用宏定义，在每一个需要反射的类后面额外增加一个类，其中有一个InstanceRegister类型的static const变量，这样在程序启动的时候就会完成初始化调用InstanceRegister类的构造函数完成注册。

之后在需要反射的类，例如在Man 后面加上一条宏定义：REGISTER_CLASS(Man) 就可以通过工厂类传入”Man”字符串获得Man的实例。

参考

C++利用反射和简单工厂模式实现业务模块解耦

Java反射机制在工厂模式中的应用