C++模板实现的通用工厂方法模式

http://blog.csdn.net/gouki04/article/details/7026055

1.工厂方法(Factory Method)模式

工厂方法模式的意义是定义一个创建产品对象的工厂接口，将实际创建工作推迟到子类当中。核心工厂类不再负责产品的创建，这样核心类成为一个抽象工厂角色，仅负责具体工厂子类必须实现的接口，这样进一步抽象化的好处是使得工厂方法模式可以使系统在不修改具体工厂角色的情况下引进新的产品。

工厂方法模式结构示意图

工厂方法模式是简单工厂模式的衍生，解决了许多简单工厂模式的问题。首先完全实现‘开－闭 原则’，实现了可扩展。其次更复杂的层次结构，可以应用于产品结果复杂的场合。

工厂方法模式很好用，但在代码层面上，为每一个产品都编写一个对应的工厂，这无疑很麻烦，而且不同的Product要写不同Creator。想想你在写一个GUI库，基本控件为Widget类，由其派生下了TextBox，Button，Label等几十个控件，那你需要为这几十个控件分别编写对应的ConcreteCreator。天，这太麻烦了吧！而如果你还要写一个RPG小游戏，需要从Person类派生下如NPC，Hero，Emeny，Ally等又是十几个类，而且还要编写一个对应于Person的Creator....

2.模板实现工厂方法模式

   面对这种类型造成的多态，C++模板就要出场了。现在情况是这样的，Product和ConcreteProduct都已经写好，我们要为其编写对应的工厂类。可以看出来，Product对应对Creator，ConcreteProduct对应于ConcreteCreator。也就是说，如果想编写通用的ConcreteCreator，就得将ConcreteProduct抽象，想编写通用的Creator，就得将Product抽象。而我们最后会将这2者都抽象了。

   首先编写通用的ConcreteCreator

// 具体工厂类
// Product为抽象产品，ConcreteProduct为具体产品
template<typename Product, typename ConcreteProduct>
class ConcreteCreator
{
public:
    // 生产一个具体产品
    static Product* createProduct()
    {
        return new ConcreteProduct();
    }
};

// 具体工厂类
// Product为抽象产品，ConcreteProduct为具体产品
template
class ConcreteCreator
{
public:
    // 生产一个具体产品
    static Product* createProduct()
    {
        return new ConcreteProduct();
    }
};

注意createProduct()是静态的，是因为该函数要被保存起来的，静态函数只需保存其函数指针即可，而普通的成员函数还要额外保存一个对象指针，这无疑更麻烦了。 也就是我们不需要这样用： 

ConcreteCreator concreteCreator;
Product* p = concreteCreator.createProduct();

ConcreteCreator concreteCreator;   
Product* p = concreteCreator.createProduct();

只需要这样写：

Product* p = ConcreteCreator::createProduct();

Product* p = ConcreteCreator::createProduct();

   下面是Creator的实现

// 抽象工厂
// Product为抽象产品
template<typename Product>
class Creator
{
    // 单例实现
public:
    static Creator& Instance()
    {
        static Creator instance;
        return instance;
    }
private:
    Creator() {}
    ~Creator() {}
    Creator(Creator&);
    // 对外接口
public:
    typedef Product* (*CreateProductDelegate)( ); // 生产产品的函数委托
    typedef std::map MapRegisterCreatorItem;
    // 根据具体产品生成具体工厂
    // 并将其注册进抽象工厂
    // ConcreteProduct为具体产品
    template<typename ConcreteProduct>
    void registerCreator(const std::string& _type)
    {
        mConcreteCreators[_type] = ConcreteCreator::createProduct;
    }
    // 删除所有具体工厂
    void unregisterAllCreators()
    {
        mConcreteCreators.clear();
    }
    // 生产类型为_type的产品
    // 失败返回0
    Product* createProduct(const std::string& _type)
    {
        MapRegisterCreatorItem::iterator type = mConcreteCreators.find(_type);
        if (type != mConcreteCreators.end())
        {
            CreateProductDelegate create = type->second;
            if (create != 0)
                return create();
        }
        return 0;
    }
private:
    MapRegisterCreatorItem mConcreteCreators; // 保存所有注册过的具体工厂
};

// 抽象工厂
// Product为抽象产品
template
class Creator
{
    // 单例实现
public:
    static Creator& Instance()
    {
        static Creator instance;
        return instance;
    }
private:
    Creator() {}
    ~Creator() {}
    Creator(Creator&);
    // 对外接口
public:
    typedef Product* (*CreateProductDelegate)( ); // 生产产品的函数委托
    typedef std::map MapRegisterCreatorItem;
    // 根据具体产品生成具体工厂
    // 并将其注册进抽象工厂
    // ConcreteProduct为具体产品
    template
    void registerCreator(const std::string& _type)
    {
        mConcreteCreators[_type] = ConcreteCreator::createProduct;
    }
    // 删除所有具体工厂
    void unregisterAllCreators()
    {
        mConcreteCreators.clear();
    }
    // 生产类型为_type的产品
    // 失败返回0
    Product* createProduct(const std::string& _type)
    {
        MapRegisterCreatorItem::iterator type = mConcreteCreators.find(_type);
        if (type != mConcreteCreators.end())
        {
            CreateProductDelegate create = type->second;
            if (create != 0)
                return create();
        }
        return 0;
    }
private:
    MapRegisterCreatorItem mConcreteCreators; // 保存所有注册过的具体工厂
};

下面来简单解释一下上面的代码。

首先Creator实现了单例模式，这只是为了方便使用，你也可以不实现为单例。

Creator里面保存了所有注册过的具体工厂，具体工厂在注册时被构建，每个具体工厂对应一个名字（string类型）。

createProduct即为工厂方法，外部通过此接口创建产品，创建时仅需提供具体工厂的名字即可。

我们以RPG游戏那个作为例子。要创建一个Person的Creator，可以这样写

typedef Creator PersonCreator;
PersonCreator& factory = PersonCreator::Instance();
factory.registerCreator("Person");
factory.registerCreator("Hero");
factory.registerCreator("NPC");

typedef Creator PersonCreator;
PersonCreator& factory = PersonCreator::Instance();
factory.registerCreator("Person");
factory.registerCreator("Hero");
factory.registerCreator("NPC");

这样即完成了注册过程，你可以继续为其他类型注册具体工厂。

要创建一个NPC，可以这样写

Person* npc = factory.createProduct("NPC");

Person* npc = factory.createProduct("NPC");

3.优缺点

此方法的优点很明显，就是用起来很方便。由于Creator支持不同类型，你不要为不同的产品编写不同的Creator。而且其提供了注册具体工厂的方法，你仅需要写一行代码即可为具体产品生成具体的工厂，而不需要编写专门的类。

而且其注册过程是可以在运行时修改的，也就是说你可以在运行时动态地注册或反注册具体工厂，这样灵活性就很大了。

缺点的话就是不支持构造函数参数，也就是说在创建产品时不支持参数。当然可以为不同数量参数编写具体的模板Creator。但其实个人并不提倡提供无参构造函数。我认为像这类产品类，都应该提供一个无参的构造函数版本，然后提供get，set函数来修改内部成员变量。