设计模式 - Abstract Factory

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

class AbstractProductA
{
public:
    AbstractProductA()
    {}
    virtual ~AbstractProductA()
    {}
};

class AbstractProductB
{
public:
    AbstractProductB()
    {}
    virtual ~AbstractProductB()
    {}
};

class AbstractFactory
{
public:
    AbstractFactory()
    {}
    virtual ~AbstractFactory()
    {}
    virtual AbstractProductA* CreateProductA() = 0;
    virtual AbstractProductB* CreateProductB() = 0;
};

class ProductA1: public AbstractProductA
{
public:
    ProductA1()
    {}
    ~ProductA1()
    {}
};

class ProductA2: public AbstractProductA
{
public:
    ProductA2()
    {}
    ~ProductA2()
    {}
};

class ProductB1: public AbstractProductB
{
public:
    ProductB1()
    {}
    ~ProductB1()
    {}
};

class ProductB2: public AbstractProductB
{
public:
    ProductB2()
    {}
    ~ProductB2()
    {}
};

class Factory1: public AbstractFactory
{
public:
    Factory1()
    {}
    ~Factory1()
    {}
    AbstractProductA* CreateProductA()
    {
        return new ProductA1();
    }
    AbstractProductB* CreateProductB()
    {
        return new ProductB1();
    }
};

class Factory2: public AbstractFactory
{
public:
    Factory2()
    {}
    ~Factory2()
    {}
    AbstractProductA* CreateProductA()
    {
        return new ProductA2();
    }
    AbstractProductB* CreateProductB()
    {
        return new ProductB2();
    }
};