设计模式（二）之抽象工厂模式（Abstract Factory） C++实现

作用:

提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。

解析:

Abstract Factory模式和Factory最大的差别就是抽象工厂创建的是一系列相关的对象，其中创建的实现其实采用的就是Factory模式的方法，对于某个实现的有一个派生出来的抽象工厂，另一个实现有另一个派生出来的工厂。

AbstractFactory.h

// 抽象基类AbstractProductA,代表产品A的抽象
class AbstractProductA
{
public:
    AbstractProductA() {}
    virtual ~AbstractProductA(){}
};
// 派生类ConcreateProductA1,继承自AbstractProductA,代表产品A的第一种实现
class ConcreateProductA1
    : public AbstractProductA
{
public:
    ConcreateProductA1(){}
    virtual ~ConcreateProductA1(){}
};

// 派生类ConcreateProductA2,继承自AbstractProductA,代表产品A的第二种实现
class ConcreateProductA2
    : public AbstractProductA
{
public:
    ConcreateProductA2(){}
    virtual ~ConcreateProductA2(){}
};
// 抽象基类AbstractProductB,代表产品B的抽象
class AbstractProductB
{
public:
    AbstractProductB() {}
    virtual ~AbstractProductB(){}
};
// 派生类ConcreateProductB1,继承自AbstractProductB,代表产品B的第一种实现
class ConcreateProductB1
    : public AbstractProductB
{
public:
    ConcreateProductB1(){}
    virtual ~ConcreateProductB1(){}
};
// 派生类ConcreateProductB2,继承自AbstractProductB,代表产品B的第二种实现
class ConcreateProductB2
    : public AbstractProductB
{
public:
    ConcreateProductB2(){}
    virtual ~ConcreateProductB2(){}
};
// 抽象基类AbstractFactory,工厂的抽象类,生产产品A和产品B
class AbstractFactory
{
public:
    AbstractFactory(){}
    virtual ~AbstractFactory(){}
    virtual AbstractProductA* CreateProductA() = 0;
    virtual AbstractProductB* CreateProductB() = 0;
};
// 派生类ConcreateFactory1,继承自AbstractFactory
// 生产产品A和产品B的第一种实现
class ConcreateFactory1
    : public AbstractFactory
{
public:
    ConcreateFactory1(){}
    virtual ~ConcreateFactory1(){}
    virtual AbstractProductA* CreateProductA();
    virtual AbstractProductB* CreateProductB();
};

// 派生类ConcreateFactory2,继承自AbstractFactory
// 生产产品A和产品B的第二种实现
class ConcreateFactory2
    : public AbstractFactory
{
public:
    ConcreateFactory2(){}
    virtual ~ConcreateFactory2(){}
    virtual AbstractProductA* CreateProductA();
    virtual AbstractProductB* CreateProductB();
};

AbstractFactory.cpp

#include "AbstractFactory.h"
AbstractProductA* ConcreateFactory1::CreateProductA()
{
    return new ConcreateProductA1();
}
AbstractProductB* ConcreateFactory1::CreateProductB()
{
    return new ConcreateProductB1();
}
AbstractProductA* ConcreateFactory2::CreateProductA()
{
    return new ConcreateProductA2();
}
AbstractProductB* ConcreateFactory2::CreateProductB()
{
    return new ConcreateProductB2();
}

main.cpp

#include "AbstractFactory.h"
int main(int argc, char* argv[])
{
    // 生产产品A的第一种实现
    ConcreateFactory1 *pFactory1 = new ConcreateFactory1;
    AbstractProductA *pProductA = pFactory1->CreateProductA();
    delete pFactory1;
    delete pProductA;
    // 生产产品B的第二种实现
    ConcreateFactory2 *pFactory2 = new ConcreateFactory2;
    AbstractProductB *pProductB = pFactory2->CreateProductB();
    delete pFactory2;
    delete pProductB;
    return 0;
}