C++设计模式之工厂模式（1）

关于设计模式的作用：

“帮助我们将应用组织成容易了解，容易维护，具有弹性的架构，建立可维护的OO系统，要诀在于随时想到系统以后可能需要的变化以及应付变化的原则。”

具体可参考：https://www.cnblogs.com/linkstar/p/7859980.html

由于Caffe中的solver产生一系列的solver子类以及建立一系列layer类时就用到了工厂模式（参考：https://blog.csdn.net/fangjin_kl/article/details/54019066）。所以这里首先介绍一下第一种设计模式-----工厂模式

参考博客：https://blog.csdn.net/wuzhekai1985/article/details/6660462

工厂模式有三种：

（1）简单工厂模式；

（2）工厂方法模式；

（3）抽象工厂模式；

1、简单工厂模式

这么描述：现在有一个工厂Factory类，专门生成核core，现在要生产两种产品core_A 和 core_B，代码如下：

enum CTYPE {COREA, COREB};     
class SingleCore    
{    
public:    
    virtual void Show() = 0;  
};    
//单核A    
class SingleCoreA: public SingleCore    
{    
public:    
    void Show() { cout<<"SingleCore A"<<endl; }    
};    
//单核B    
class SingleCoreB: public SingleCore    
{    
public:    
    void Show() { cout<<"SingleCore B"<<endl; }    
};    
//唯一的工厂，可以生产两种型号的处理器核，在内部判断    
class Factory    
{    
public:     
    SingleCore* CreateSingleCore(enum CTYPE ctype)    
    {    
        if(ctype == COREA) //工厂内部判断    
            return new SingleCoreA(); //生产核A    
        else if(ctype == COREB)    
            return new SingleCoreB(); //生产核B    
        else    
            return NULL;    
    }    
};    

当然这么做也有一个缺点：当Factory要生产一个新的产品时，就要修改factory类，然而这样就违背了开放封闭原则，即软件实体（类、函数、模块）不可修改，只能扩展；所以为了通过扩展来实现可以生产新的产品，引入了工厂方法模式；

2、工厂方法模式

这么来描述：通过类的继承来实现扩展功能，即从父类factory中派生出factory_A类专门用来生产core_A 产品 ， 派生出favtory_B类从来生产core_B产品。这样子如果味蕾要生产新的产品时，只需要派生出新的工厂子类就行了。代码如下：

class SingleCore    
{    
public:    
    virtual void Show() = 0;  
};    
//单核A    
class SingleCoreA: public SingleCore    
{    
public:    
    void Show() { cout<<"SingleCore A"<<endl; }    
};    
//单核B    
class SingleCoreB: public SingleCore    
{    
public:    
    void Show() { cout<<"SingleCore B"<<endl; }    
};    
class Factory    
{    
public:    
    virtual SingleCore* CreateSingleCore() = 0;  
};    
//生产A核的工厂    
class FactoryA: public Factory    
{    
public:    
    SingleCoreA* CreateSingleCore() { return new SingleCoreA; }    
};    
//生产B核的工厂    
class FactoryB: public Factory    
{    
public:    
    SingleCoreB* CreateSingleCore() { return new SingleCoreB; }    
};    

当然上面这么做也有一个缺点，就是每生产一种新的类别时就需要建立一个新的工厂，那么就存在这样一种情况，依然core_A类，可能我们要对A生产一系列产品，比如单核的A和多核的A，如果还是用工厂方法模式就太繁琐了，所以引入了抽象工厂模式；

3、抽象工厂模式

这么描述：它提供了一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类，就是说父类factory只指定要生产单核类和多核类，而不需要指定A、B、C类等等。

代码如下：

//单核    
class SingleCore     
{    
public:    
    virtual void Show() = 0;  
};    
class SingleCoreA: public SingleCore      
{    
public:    
    void Show() { cout<<"Single Core A"<<endl; }    
};    
class SingleCoreB :public SingleCore    
{    
public:    
    void Show() { cout<<"Single Core B"<<endl; }    
};    
//多核    
class MultiCore      
{    
public:    
    virtual void Show() = 0;  
};    
class MultiCoreA : public MultiCore      
{    
public:    
    void Show() { cout<<"Multi Core A"<<endl; }    
    
};    
class MultiCoreB : public MultiCore      
{    
public:    
    void Show() { cout<<"Multi Core B"<<endl; }    
};    
//工厂    
class CoreFactory      
{    
public:    
    virtual SingleCore* CreateSingleCore() = 0;  //只指定要生产单核类和多核类，而不需要指定要生产A还是b类等等
    virtual MultiCore* CreateMultiCore() = 0;  
};    
//工厂A，专门用来生产A型号的处理器    
class FactoryA :public CoreFactory    
{    
public:    
    SingleCore* CreateSingleCore() { return new SingleCoreA(); }    
    MultiCore* CreateMultiCore() { return new MultiCoreA(); }    
};    
//工厂B，专门用来生产B型号的处理器    
class FactoryB : public CoreFactory    
{    
public:    
    SingleCore* CreateSingleCore() { return new SingleCoreB(); }    
    MultiCore* CreateMultiCore() { return new MultiCoreB(); }    
};