1. 目的：定義一個創(chuàng)建對象的接口，讓其子類自己決定實例化哪一個工廠類，工廠模式使其創(chuàng)建過程延遲到子類進(jìn)行，主要用于創(chuàng)建復(fù)雜對象

• 主要解決接口選擇的問題
• 想創(chuàng)建一個對象，只要知道其名稱就可以
• 擴(kuò)展性高，如果想增加一個產(chǎn)品，只要擴(kuò)展一個工廠類就可以
• 屏蔽產(chǎn)品的具體實現(xiàn)，調(diào)用者只關(guān)心產(chǎn)品的接口

2. 簡單工廠模式

#include <iostream>
using namespace std;

class AbstractProduct {
public:
    virtual ~AbstractProduct() {} 
    virtual void Operation() = 0;
};

class ProductA : public AbstractProduct {
public:
    void Operation() { cout << "ProductA" << endl; }
};

class ProductB : public AbstractProduct {
public:
    void Operation() { cout << "ProductB" << endl; }
};

class Factory {
public:
    AbstractProduct* createProduct(char product) {
        AbstractProduct* ap = NULL;
        switch(product) {
            case 'A': ap = new ProductA(); break;
            case 'B': ap = new ProductB(); break;
        }
        return ap;
    }
};

int main() {
    Factory* f = new Factory();
    AbstractProduct* apa = f->createProduct('A');
    apa->Operation();  // ProductA

    AbstractProduct* apb = f->createProduct('B');
    apb->Operation();  // ProductB

    delete apa;
    delete apb;
    delete f;

    return 0;
}

3. 工廠方法模式：工廠方法模式定義了一個用于創(chuàng)建對象的接口，讓子類決定實例化哪一個類，工廠方法使一個類的實例化延遲到子類。

把簡單工廠模式中的工廠類抽象出一個接口，這個接口只有一個方法，就是創(chuàng)建抽象產(chǎn)品的工廠方法。然后所有的要生產(chǎn)具體類的工廠，就去實現(xiàn)這個接口，這樣，一個簡單工廠模式的工廠類，就變成了一個工廠抽象接口和多個具體生成對象的工廠。

#include <iostream>
using namespace std;

class Product {
public:
    virtual ~Product(){}
    virtual void Operation() = 0;
};

class ConcreteProductA : public Product {
public:
    void Operation() { cout << "ConcreteProductA" << endl; }
};

class ConcreteProductB : public Product {
public:
    void Operation() { cout << "ConcreteProductB" << endl; }
};

class Creator{
public:
    virtual Product* FactoryMethod() = 0;
    virtual ~Creator(){}
};

class ConcreteCreatorA : public Creator {
public:
    Product* FactoryMethod() { return new ConcreteProductA(); }
};

class ConcreteCreatorB : public Creator {
public:
    Product* FactoryMethod() { return new ConcreteProductB(); }
};

int main() {
    Creator* ca = new ConcreteCreatorA();
    Product* pa = ca->FactoryMethod();
    pa->Operation(); // ConcreteProductA

    Creator* cb = new ConcreteCreatorB();
    Product* pb = cb->FactoryMethod();
    pb->Operation(); // ConcreteProductB

    delete ca;
    delete pa;
    delete cb;
    delete pb;

    return 0;
}

4. 抽象工廠模式：抽象工廠模式是提供一個創(chuàng)建一系列相關(guān)或相互依賴對象的接口，而無需指定它們具體的類

• 易于交換產(chǎn)品系列，由于具體工廠類在一個應(yīng)用中只需要在初始化的時候出現(xiàn)一次，這樣就使得改變一個應(yīng)用的具體工廠變得非常容易，只需要改變具體工廠即可使用不同的產(chǎn)品配置。
• 讓具體的創(chuàng)建實例過程與客戶端分離，客戶端是通過它們的抽象接口操縱實例，產(chǎn)品的具體類名也被具體工廠實現(xiàn)分離，不會出現(xiàn)在客戶代碼中。

缺點：增加新的產(chǎn)品時需要改動多處代碼。

#include <iostream>
using namespace std;

class AbstractProductA {
public:
    virtual ~AbstractProductA(){}
    virtual void Operation() = 0;
};

class ProductA1 : public AbstractProductA {
public:
    void Operation() {
        cout << "ProductA1" << endl;
    }
};

class ProductA2 : public AbstractProductA {
public:
    void Operation() {
        cout << "ProductA2" << endl;
    }
};

class AbstractProductB {
public:
    virtual ~AbstractProductB(){}
    virtual void Operation() = 0;
};

class ProductB1 : public AbstractProductB {
public:
    void Operation() {
        cout << "ProductB1" << endl;
    }
};

class ProductB2 : public AbstractProductB {
public:
    void Operation() {
        cout << "ProductB2" << endl;
    }
};


class AbstractFactory {
public:
    virtual AbstractProductA* CreateProductA() = 0;
    virtual AbstractProductB* CreateProductB() = 0;
    virtual ~AbstractFactory(){}
};

class ConcreteFactory1 : public AbstractFactory {
public:
    ProductA1* CreateProductA() {
        return new ProductA1();
    }
    ProductB1* CreateProductB() {
        return new ProductB1();
    }
};

class ConcreteFactory2 : public AbstractFactory {
public:
    ProductA2* CreateProductA() {
        return new ProductA2();
    }
    ProductB2* CreateProductB() {
        return new ProductB2();
    }
};

int main() {
    AbstractFactory* af1 = new ConcreteFactory1();
    // 具體工廠創(chuàng)建對應(yīng)的具體產(chǎn)品
    AbstractProductA* apa1 = af1->CreateProductA();  // 工廠1創(chuàng)建產(chǎn)品A
    apa1->Operation();  // ProductA1

    AbstractProductB* apb1 = af1->CreateProductB();  // 工廠1創(chuàng)建產(chǎn)品B
    apb1->Operation();  // ProductB1

    AbstractFactory* af2 = new ConcreteFactory2();
    AbstractProductA* apa2 = af2->CreateProductA();  // 工廠2創(chuàng)建產(chǎn)品A
    apa2->Operation();  // ProductA2

    AbstractProductB* apb2 = af2->CreateProductB();  // 工廠2創(chuàng)建產(chǎn)品B
    apb2->Operation();  // ProductB2

    delete apa1;
    delete apa2;
    delete af1;
    delete apb1;
    delete apb2;
    delete af2;
    return 0;
}