設計模式C++實現——工廠模式

軟件領域中的設計模式爲開發人員提供了一種使用專家設計經驗的有效途徑。設計模式中運用了面向對象編程語言的重要特性：封裝、繼承、多態，真正領悟設計模式的精髓是可能一個漫長的過程，須要大量實踐經驗的積累。最近看設計模式的書，對於每一個模式，用C++寫了個小例子，加深一下理解。主要參考《大話設計模式》和《設計模式:可複用面向對象軟件的基礎》兩本書。本文介紹工廠模式的實現。

       工廠模式屬於建立型模式，大體能夠分爲三類，簡單工廠模式、工廠方法模式、抽象工廠模式。聽上去差很少，都是工廠模式。下面一個個介紹，首先介紹簡單工廠模式，它的主要特色是須要在工廠類中作判斷，從而創造相應的產品。當增長新的產品時，就須要修改工廠類。有點抽象，舉個例子就明白了。有一家生產處理器核的廠家，它只有一個工廠，可以生產兩種型號的處理器核。客戶須要什麼樣的處理器核，必定要顯示地告訴生產工廠。下面給出一種實現方案。

簡單工廠模式：

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 Method使一個類的實例化延遲到其子類。

       聽起來很抽象，仍是以剛纔的例子解釋。這家生產處理器核的產家賺了很多錢，因而決定再開設一個工廠專門用來生產B型號的單核，而原來的工廠專門用來生產A型號的單核。這時，客戶要作的是找好工廠，好比要A型號的核，就找A工廠要；不然找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; }    
};  

　　工廠方法模式也有缺點，每增長一種產品，就須要增長一個對象的工廠。若是這家公司發展迅速，推出了不少新的處理器核，那麼就要開設相應的新工廠。在C++實現中，就是要定義一個個的工廠類。顯然，相比簡單工廠模式，工廠方法模式須要更多的類定義。

       既然有了簡單工廠模式和工廠方法模式，爲何還要有抽象工廠模式呢？它到底有什麼做用呢？仍是舉這個例子，這家公司的技術不斷進步，不只能夠生產單核處理器，也能生產多核處理器。如今簡單工廠模式和工廠方法模式都鞭長莫及。抽象工廠模式登場了。它的定義爲提供一個建立一系列相關或相互依賴對象的接口，而無需指定它們具體的類。具體這樣應用，這家公司仍是開設兩個工廠，一個專門用來生產A型號的單核多核處理器，而另外一個工廠專門用來生產B型號的單核多核處理器，下面給出實現的代碼。

抽象工廠模式：

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