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