[TOC]

工廠模式

簡單工廠模式

用一個單獨的類來做創造實例的過程，就是簡單工廠

#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;
}

缺點：

不符合開閉原則

工廠方法模式

工廠方法模式定義了一個用于創建對象的接口，讓子類決定實例化哪一個類

#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 AbstractFactory
{
public:
    virtual ~AbstractFactory() {}
    virtual AbstractProduct* FactoryMethod() = 0;
};

class FactoryA : public AbstractFactory
{
public:
    ~FactoryA() {}
    ProductA* FactoryMethod(){
        return new ProductA();
    }
};

class FactoryB : public AbstractFactory
{
public:
    ~FactoryB() {}
    ProductB* FactoryMethod(){
        return new ProductB();
    }
};

int main(int argc, const char** argv) {
    AbstractFactory* fa = new FactoryA();
    AbstractProduct* a = fa->FactoryMethod();
    a->Operation();

    AbstractFactory* fb = new FactoryB();
    AbstractProduct* b = fb->FactoryMethod();
    b->Operation();

    delete a;
    delete b;
    delete fa;
    delete fb;

    return 0;
}

抽象工廠模式

抽象工廠模式是工廠方法的進一步深化，在這個模式中，工廠類不單單可以創建一個對象，而是可以創建一組對象。

AbstractFactory（抽象工廠）聲明了一組用于創建對象的方法，注意是一組。
ConcreteFactory（具體工廠）：它實現了在抽象工廠中聲明的創建對象的方法，生成一組具體對象。
AbstractProduct（抽象產品）：它為每種對象聲明接口，在其中聲明了對象所具有的業務方法。
ConcreteProduct（具體產品）：它定義具體工廠生產的具體對象。

#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();
    // 具體工廠創建對應的具體產品
    AbstractProductA* apa1 = af1->CreateProductA();  // 工廠1創建產品A
    apa1->Operation();  // ProductA1

    AbstractProductB* apb1 = af1->CreateProductB();  // 工廠1創建產品B
    apb1->Operation();  // ProductB1

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

    AbstractProductB* apb2 = af2->CreateProductB();  // 工廠2創建產品B
    apb2->Operation();  // ProductB2

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

對象工廠

當系統中抽象基類中有很多具體子類，采用上述方式擴展成本極高。函數指針通過引入一個從type到函數指針的索引，使得程序實現非常優雅。

參考文章：

1. 工廠模式C++
2. 對象工廠(1)---和萬惡的 switch 說再見
3. 對象工廠(2)---一個泛化的工廠類
4. 《Modern C++ Design》(C++設計新思維)源碼下載