設計模式之工廠模式

工廠模式大致可以分爲三類:
1、簡單工廠模式
2、工廠方法模式
3、抽象工廠模式。
這三種模式逐步抽象，並且更具有一般性。
工廠模式有一種非常形象的描述，建立對象的類就像一個工廠，而需要被建立的對象就是一個個產品，在工廠中加工產品，使用產品的人不用關心產品是如何生產出來的。在軟件中使用工廠模式的好處就是降低了模塊之間的耦合。設計模式的實現是基於C++多態來實現的。

簡單工廠模式

一、簡單工廠模式:
簡單工廠模式是工廠模式中最簡單的一種，他可以用比較簡單的方式隱藏創建對象的細節，一般只需要告訴工廠類所需要的產品類型，工廠類就會返回需要的產品對象。
例:現在有一個工廠生產A,B兩種類型的產品。使用工廠模式設計就是有一個工廠類Factory,可以根據輸入的類型(typeA,typeB)從而創建相應的A類型對象，B類型對象。

enum{ typeA, typeB };

class product{
public:
    virtual void show() = 0;
};

class productA : public product{
public:
    virtual void show(){
        cout<< "productA" << endl;
    }
};

class productB : public product{
public:
    virtual void show(){
        cout<< "productB" << endl;
    }
};

class Factory{
public:
    static product* createproduct(int type){
        switch(type){
        case typeA:
            return new productA();
            break;
        case typeB:
            return new productB();
            break;
        }
    }
};

int main()
{
    Factory f;
    product* pA = f.createproduct(typeA);
    product* pB = f.createproduct(typeB);
    pA->show();
    pB->show();
    return 0;
}

簡單工廠模式的話統一了創建對象的接口，隱藏了創建對象的細節，只要知道產品的類型就可以創建出產品對象。

但是簡單工廠模式不易對產品進行擴展，比如現在又出來了一種C類型的產品，那要修改的地方就很多了，首先要添加一個C類型的產品類，還有在工廠類中再添加一個分支，這違背了開閉原則。
所以簡單工廠模式適用於產品子類不多的場合

工廠方法模式

由於簡單工廠模式違反了開閉原則，所以工廠方法模式的出現了，工廠方法模式是在簡單工廠模式的基礎上，對”工廠”添加了一個抽象層，將工廠的動作抽象出來，作爲抽象類，而具體的行爲由工廠類的子類去實現，讓工廠類的子類決定去生產什麼類型的產品。

工廠方法模式與簡單工廠模式不同的是，簡單工廠模式是將判斷創造哪一個“產品”的邏輯交給工廠類的內部。而工廠方法模式是將要創造哪個對象交給用戶。

工廠方法模式提供了一個抽象的工廠類接口，而具體的生產則是放到工廠類的子類當中，這樣進一步抽象使得以後再增加新的產品的時候非常簡單，不必修改原有代碼，只需要增加一個新的工廠子類就可以了。

class product{
public:
    virtual void show() = 0;
};

class productA: public product{
public:
    virtual void show(){
        cout<< "productA"<<endl;
    }
};

class productB: public product{
public:
    virtual void show(){
        cout<<"productB"<<endl;
    }
};

class Factory{
public:
    virtual product* createproduct() = 0;
};

class FactoryA: public Factory{
public:
    virtual product* createproduct(){
        return new productA();
    }
};

class FactoryB: public Factory{
public:
    virtual product* createproduct(){
        return new productB();
    }
};

int main()
{
    Factory* pFA = new FactoryA();
    Factory* pFB = new FactoryB();
    pFA->createproduct()->show();
    pFB->createproduct()->show();
    return 0;
}

三、抽象工廠模式:
工廠方法模式和簡單工廠模式都適用於”產品種類結構單一”的場合，爲一類產品提供創建的接口。
例如生產鋼筆的工廠只生產鋼筆這一類產品，如果使用工廠方法模式的話，則這個工廠就不能同時生產鉛筆。
如果想讓生產鋼筆的工廠同時生產鉛筆的話，則可以使用抽象工廠模式。
抽象工廠模式使用與產品種類結構多的場合(比如A工廠裏面既有高檔鋼筆也有高檔鉛筆)，主要用於創建一組相關的產品，爲他們提供創建的接口。

class pen{
public:
    virtual void show() = 0;
};

class pen1 :public pen{
public:
    virtual void show(){
        cout<< "good pen"<<endl;
    }
};

class pen2 :public pen{
public:
    virtual void show(){
        cout<< "bad pen"<<endl;
    }
}; 

class pencil{
public:
    virtual void show() = 0;
};

class pencil1 :public pencil{
public:
    virtual void show(){
        cout<<"good pencil"<<endl;
    }
};

class pencil2 :public pencil{
public:
    virtual void show(){
        cout<<"bad pencil"<<endl;
    }
};

class Factory{
public:
    virtual pen* createpen() = 0;
    virtual pencil* createpencil() = 0;
};

class Factory1 : public Factory{
public:
    virtual pen* createpen(){
        return new pen1();
    }
    virtual pencil* createpencil(){
        return new pencil1();
    }
};

class Factory2 : public Factory{
public:
    virtual pen* createpen(){
        return new pen2();
    }
    virtual pencil* createpencil(){
        return new pencil2();
    }
};

int main()
{
    Factory* f1 = new Factory1();
    f1->createpen()->show();
    f1->createpencil()->show();

    Factory* f2 = new Factory2();
    f2->createpen()->show();
    f2->createpencil()->show();
    return 0;
}

抽象工廠模式封裝了產品的創建，只要我們知道工廠就可以創建出一組產品。但是缺點也很明顯，比如新增一個產品，要在每個工廠中再添加一種方法，違反了開閉原則。