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() = ;
};
//单核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() = ;
};
//单核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() = ;
};
//生产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() = ;
};
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() = ;
};
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() = ;  //只指定要生产单核类和多核类，而不需要指定要生产A还是b类等等
    virtual MultiCore* CreateMultiCore() = ;
};
//工厂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(); }
};