設計模式——抽象工廠模式

*工廠模式解決了一部分問題，但還有一些缺點，所以這時抽象工廠模式應運而生。。。→_→*

在閱讀本文之前，需要了解一些知識點。。。請戳傳送門——工廠模式

1. 工廠模式與抽象工廠模式的區別

   • 工廠模式中，在工廠子類中無論多麼辛苦的製造產品子類，其實它們都同屬一個父類
   • 而在現實生活中，工廠不可能只製造一種產品。所以一個工廠子類有可能製造多種產品子類，而它們來源於不同的父類

2. 抽象工廠模式的作用

   • 將一組來自於不同父類的子類對象的創建封裝到一個類中， 維護這樣一個創建類總比維護n個相關對象的創建過程要簡單的多

3. 抽象工廠模式結構示意圖

4. 代碼實現

#include <iostream>
#include <vld.h>
using namespace std;

//產品A父類
class AbstractProductA
{
public:
    virtual ~AbstractProductA() {}
protected:
    AbstractProductA() {}
};

//產品B父類
class AbstractProductB
{
public:
    virtual ~AbstractProductB() {}
protected:
    AbstractProductB() {}
};

//產品A的子類A1
class ProductA1 : public AbstractProductA
{
public:
    ProductA1()
    {
        cout << "ProductA1..." << endl;
    }
    ~ProductA1() {}
};

//產品A的子類A2
class ProductA2 : public AbstractProductA
{
public:
    ProductA2()
    {
        cout << "ProductA2..." << endl;
    }
    ~ProductA2() {}
};

//產品B的子類B1
class ProductB1 : public AbstractProductB
{
public:
    ProductB1()
    {
        cout << "ProductB1..." << endl;
    }
    ~ProductB1() {}
};

//產品B的子類B2
class ProductB2 : public AbstractProductB
{
public:
    ProductB2()
    {
        cout << "ProductB2..." << endl;
    }
    ~ProductB2() {}
};

//抽象工廠父類
class AbstractFactory
{
public:
    virtual ~AbstractFactory() {}
    //工廠中生產有可能生產多種類型的產品，所以對應不同的調用接口
    virtual AbstractProductA* CreateProductA() = 0;
    virtual AbstractProductB* CreateProductB() = 0;
protected:
    AbstractFactory() {}
};

//抽象工廠子類CF1
class ConcreteFactory1 : public AbstractFactory
{
public:
    ConcreteFactory1() {}
    ~ConcreteFactory1() {}
    //工廠CF1針對A產品的初始化調用接口實現
    AbstractProductA* CreateProductA()
    {
        return new ProductA1();
    }
    //工廠CF1針對B產品的初始化調用接口實現
    AbstractProductB* CreateProductB()
    {
        return new ProductB1();
    }
};

//抽象工廠子類CF2
class ConcreteFactory2 : public AbstractFactory
{
public:
    ConcreteFactory2() {}
    ~ConcreteFactory2() {}
    //工廠CF2針對A產品的初始化調用接口實現
    AbstractProductA* CreateProductA()
    {
        return new ProductA2();
    }
    //工廠CF2針對B產品的初始化調用接口實現
    AbstractProductB* CreateProductB()
    {
        return new ProductB2();
    }
};

int main()
{
    AbstractFactory* cf1 = new ConcreteFactory1();//創建抽象工廠子類CF1
    AbstractProductA* pA1 = cf1->CreateProductA();//在CF1中生產產品A的子類A1
    AbstractProductB* pB1 = cf1->CreateProductB();//在CF1中生產產品B的子類B1

    AbstractFactory* cf2 = new ConcreteFactory2();//創建抽象工廠子類CF2
    AbstractProductA* pA2 = cf2->CreateProductA();//在CF2中生產產品A的子類A2
    AbstractProductB* pB2 = cf2->CreateProductB();//在CF2中生產產品B的子類B2

    delete cf1;
    delete pA1;
    delete pB1;
    delete cf2;
    delete pA2;
    delete pB2;
    return 0;
}

運行結果

*碼完。。。收工。。。→_→*