c++模板实现抽象工厂

相似于rime的rime::Class<factory type, product type>实现方式。

 

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

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();
    }
};

 

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

 

ConcreteCreator<Product, ConcreteProduct> concreteCreator;
Product* p = concreteCreator.createProduct();

 

 

只须要这样写：

 

Product* p = ConcreteCreator<Product, ConcreteProduct>::createProduct();

 

   下面是Creator的实现

 

// 抽象工厂
// Product为抽象产品
template<typename Product>
class Creator
{
    // 单例实现
public:
    static Creator& Instance()
    {
        static Creator<Product> instance;
        return instance;
    }
private:
    Creator() {}
    ~Creator() {}
    Creator(Creator&);
    // 对外接口
public:
    typedef Product* (*CreateProductDelegate)( ); // 生产产品的产品
    typedef std::map<std::string, CreateProductDelegate> MapRegisterCreatorItem;
    // 根据具体产品生成具体工厂
    // 并将具体产品注册进抽象工厂
    // ConcreteProduct为具体产品
    template<typename ConcreteProduct>
    void registerCreator(const std::string& _type)
    {
        mConcreteCreators[_type] = ConcreteCreator<Product, ConcreteProduct>::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<Person> PersonCreator;
PersonCreator& factory = PersonCreator::Instance();
factory.registerCreator<Person>("Person");
factory.registerCreator<Hero>("Hero");
factory.registerCreator<NPC>("NPC");

 

这样即完成了注册过程，你能够继续为其余类型注册具体工厂。

要建立一个NPC，能够这样写

 

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

 

3.优缺点

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

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

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