AbstractFactory抽象工厂模式

#include <iostream>
using namespace std;

class ProductAbase
{
public:
    ProductAbase(){}
    virtual ~ProductAbase(){}
    virtual void Printf() = 0;
};
class Product1 : public ProductAbase
{
public:
    void Printf()
    {
        cout << "Product1::Printf()" << endl;
    }
};
class Product2 :public ProductAbase
{
public:
    void Printf()
    {
        cout << "Product2::Printf()" << endl;
    }
};

class ProductBbase
{
public:
    virtual void Printf() = 0;
};
class Product3 : public ProductBbase
{
public:
    void Printf()
    {
        cout << "Product3::Printf()" << endl;
    }
};
class Product4 : public ProductBbase
{
public:
    void Printf()
    {
        cout << "Product4::Printf()" << endl;
    }
};

//工厂类。
class Factory
{
public:
    Factory(){}
    virtual ~Factory(){}
    virtual ProductAbase* GetProductA() = 0;
    virtual ProductBbase* GetProductB() = 0;
};

class Factory1 : public Factory
{
public:
    ProductAbase* GetProductA()
    {
        return new Product1();
    }
    ProductBbase* GetProductB()
    {
        return new Product3();
    }
};
class Factory2 : public Factory
{
public:
    ProductAbase* GetProductA()
    {
        return new Product2();
    }
    ProductBbase* GetProductB()
    {
        return new Product4();
    }
};
int main()
{
    Factory *fa = new Factory1();
    ProductAbase *pa = fa->GetProductA();//获得ProdcutAbase的子类对象Product1。
    pa->Printf();//Product1的操作方法。
    ProductBbase *pb = fa->GetProductB();//获得ProductBbase的子类对象Product3。

    pb->Printf();//Product3的操作方法。

    fa = new Factory2();
    pa = fa->GetProductA();
    pa->Printf();//Product2的操作方法。
    pb = fa->GetProductB();
    pb->Printf();//Product3的操作方法。

    return 0;
}
//总结：抽象工厂模式无非是将单个工厂模式聚合起来，统一的用工厂函数对对象的实例化延迟。
//然后统一的对对象的构造进行管理。说的简单点就是，我将宝马停在1号车间。奔驰停在2号车间，
//奥迪停在3号车间，我须要什么车我就开几号车间门，工厂函数就是起这样一个作用，将对象的
//实例化用统一的函数进行封装。