抽象工厂模式

抽象工厂模式就是在工厂方法模式、简单工厂模式上的进一步抽象，以前的工厂方法模式中每个工厂只能生产单一的产品，抽象工厂中的工厂（该工厂相当于简单工厂模式中的工厂，可以生产一系列产品）可以生产一系列的产品。

#include <iostream>
using namespace std;

//产品A基类
class ProductA
{
public:
    virtual void create() = 0;
    virtual ~ProductA() {}
};

//产品A1
class ProductA1 : public ProductA
{
public:
    void create() { cout << "A1 create()" << endl; }
};

//产品A2
class ProductA2 : public ProductA
{
public:
    void create() { cout << "A2 create()" << endl; }
};

//产品B基类    
class ProductB
{
public:
    virtual void create() = 0;
    virtual ~ProductB() {}
};

//产品B1
class ProductB1 : public ProductB
{
public:
    void create() { cout << "B1 create()" << endl; }
};

//产品B2
class ProductB2 : public ProductB
{
public:
    void create() { cout << "B2 create()" << endl; }
};

//工厂基类
class Factory
{
public:
    virtual ProductA* createProductA() = 0;
    virtual ProductB* createProductB() = 0;
    virtual ~Factory() {}
};

//工厂A
class FactoryA :public Factory
{
public:
    ProductA* createProductA()
    {
        return new ProductA1();
    }

    ProductB* createProductB()
    {
        return new ProductB1();
    }
};


//工厂B
class FactoryB : public Factory
{
public:
    ProductA* createProductA()
    {
        return new ProductA2();
    }

    ProductB* createProductB()
    {
        return new ProductB2();
    }
};

int main()
{
    Factory* fa = new FactoryA();
    ProductA* paa = fa->createProductA();
    ProductB* pba = fa->createProductB();
    paa->create();
    pba->create();
    delete fa;
    fa = nullptr;
    delete paa;
    paa = nullptr;
    delete pba;
    pba = nullptr;

    Factory* fb = new FactoryB();
    ProductA* pab = fb->createProductA();
    ProductB* pbb = fb->createProductB();
    pab->create();
    pbb->create();
    delete fb;
    fb = nullptr;
    delete pab;
    pab = nullptr;
    delete pbb;
    pbb = nullptr;
}