C++設計模式-AbstractFactory抽象工廠模式

AbstractFactory

要創建一組相關或者相互依賴的對象

作用：提供一個創建一系列相關或相互依賴對象的接口，而無需指定它們具體的類。

UML結構圖：

抽象基類：

1）AbstractProductA、AbstractProductB：分別代表兩種不同類型的產品，由具體的產品派生類對其實現

2）AbstractFactory：抽象工廠類，提供創建兩種產品的接口CreateProductA和CreateProductB，由派生的各個具體工廠類對其實現

說明：

AbstractFactory模式關鍵就是將這一組對象的創建封裝到一個用於創建對象的類（ConcreteFactory）中

Abstract Factory模式和Factory最大的差別就是抽象工廠創建的是一系列相關的對象,其中創建的實現其實采用的就是Factory模式的方法,對於某個實現的有一個派生出來的抽象工廠,另一個實現有另一個派生出來的工廠

抽象工廠需要特別注意的地方就是區分不同類型的產品和這些產品的不同實現.顯而易見的,如果有n種產品同時有m中不同的實現,那么根據乘法原理可知有n*m個Factory模式的使用

AbstractFactory模式是為創建一組（有多類）相關或依賴的對象提供創建接口，而Factory模式是為一類對象提供創建接口或延遲對象的創建到子類中實現。並且可以看到，AbstractFactory模式通常都是使用Factory模式實現（ConcreteFactory1）。

代碼如下：

Product.h

#ifndef _PRODUCT_H_
#define _PRODUCT_H_

//抽象基類AbstractProductA，代表A類產品的抽象
class AbstractProductA
{
public:
    virtual ~AbstractProductA()=0;
    virtual void operation()=0;
protected:
    AbstractProductA();//屏蔽構造函數
};

//派生類ProductA1，繼承自AbstractProductA，A類產品的一種實現
class ProductA1 : public AbstractProductA
{
public:
    ProductA1();
    virtual void operation();
    virtual ~ProductA1();
};

//派生類ProductA2，繼承自AbstractProductA，A類產品的另一種實現
class ProductA2:public AbstractProductA
{
public:
    ProductA2();
    virtual void operation();
    virtual ~ProductA2();
};

//抽象基類AbstractProductB，代表B類產品的抽象
class AbstractProductB
{
public:
    virtual ~AbstractProductB()=0;
    virtual void operation()=0;
protected:
    AbstractProductB();//屏蔽構造函數
};

//派生類ProductB1，繼承自AbstractProductB，B類產品的一種實現
class ProductB1:public AbstractProductB
{
public:
    ProductB1();
    virtual void operation();
    virtual ~ProductB1();
};

//派生類ProductB2，繼承自AbstractProductB，B類產品的另一種實現
class ProductB2:public AbstractProductB
{
public:
    ProductB2();
    virtual void operation();
    virtual ~ProductB2();
};


#endif

Factory.h

#ifndef _FACTORY_H_
#define _FACTORY_H_

//AbstractFactory，工廠抽象基類，定義生產A類與B類產品的接口
class AbstractProductA;
class AbstractProductB;
class AbstractFactory
{
public:
    virtual ~AbstractFactory()=0;
    virtual AbstractProductA* CreateProductA()=0;
    virtual AbstractProductB* CreateProductB()=0;
protected:
    AbstractFactory();
};

//ConcreteFactory1，派生類，繼承自AbstractFactory
//實現繼承的接口，生產產品A和B的一種實現
class ConcreteFactory1:public AbstractFactory
{
public:
    ConcreteFactory1();
    ~ConcreteFactory1();
    virtual AbstractProductA* CreateProductA();
    virtual AbstractProductB* CreateProductB();
};

//ConcreteFactory2，派生類，繼承自AbstractFactory
//實現繼承的接口，生產產品A和B的另一種實現
class ConcreteFactory2:public AbstractFactory
{
public:
    ConcreteFactory2();
    ~ConcreteFactory2();
    virtual AbstractProductA* CreateProductA();
    virtual AbstractProductB* CreateProductB();
};

#endif

Product.cpp

#include "Product.h"
#include <iostream>

using namespace std;

//AbstractProductA
AbstractProductA::AbstractProductA()
{
    cout << "AbstractProductA..." << endl;
}

AbstractProductA::~AbstractProductA()
{
    cout << "~AbstractProductA..." << endl;
}

//ProductA1
ProductA1::ProductA1()
{
    cout << "ProductA1..." << endl;
}

ProductA1::~ProductA1()
{
    cout << "~ProductA1..." << endl;
}

void ProductA1::operation()
{}

//ProductA2
ProductA2::ProductA2()
{
    cout << "ProductA2..." << endl;
}

ProductA2::~ProductA2()
{
    cout << "~ProductA2..." << endl;
}

void ProductA2::operation()
{}

//AbstractProductB
AbstractProductB::AbstractProductB()
{
    cout << "AbstractProductB..." << endl;
}

AbstractProductB::~AbstractProductB()
{
    cout << "~AbstractProductB..." << endl;
}

//ProductB1
ProductB1::ProductB1()
{
    cout << "ProductB1..." << endl;
}

ProductB1::~ProductB1()
{
    cout << "~ProductB1..." << endl;
}

void ProductB1::operation()
{}

//ProductB2
ProductB2::ProductB2()
{
    cout << "ProductB2..." << endl;
}

ProductB2::~ProductB2()
{
    cout << "~ProductB2..." << endl;
}

void ProductB2::operation()
{}

Factory.cpp

#include "Factory.h"
#include "Product.h"
#include <iostream>

using namespace std;

AbstractFactory::AbstractFactory()
{
    cout << "AbstractFactory..." << endl;
}

AbstractFactory::~AbstractFactory()
{
    cout << "~AbstractFactory..." << endl;
}

ConcreteFactory1::ConcreteFactory1()
{
    cout << "ConcreteFactory1..." << endl;
}

ConcreteFactory1::~ConcreteFactory1()
{
    cout << "~ConcreteFactory1..." << endl;
}

AbstractProductA* ConcreteFactory1::CreateProductA()
{
    return new ProductA1();
}

AbstractProductB* ConcreteFactory1::CreateProductB()
{
    return new ProductB1();
}

ConcreteFactory2::ConcreteFactory2()
{
    cout << "ConcreteFactory2..." << endl;
}

ConcreteFactory2::~ConcreteFactory2()
{
    cout << "~ConcreteFactory2..." << endl;
}

AbstractProductA* ConcreteFactory2::CreateProductA()
{
    return new ProductA2();
}

AbstractProductB* ConcreteFactory2::CreateProductB()
{
    return new ProductB2();
}

main.cpp

#include <iostream>
#include "Factory.h"
#include "Product.h"

using namespace std;

int main()
{
    AbstractFactory* fa1 = new ConcreteFactory1();
    AbstractProductA* a1 = fa1->CreateProductA();
    AbstractProductB* b1 = fa1->CreateProductB();

    cout << endl;
    AbstractFactory* fa2 = new ConcreteFactory2();
    AbstractProductA* a2 = fa2->CreateProductA();
    AbstractProductB* b2 = fa2->CreateProductB();

    cout << endl;
    delete fa1;
    delete a1;
    delete b1;

    cout << endl;
    delete fa2;
    delete a2;
    delete b2;

    return 0;
}