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号车间，我须要什么车我就开几号车间门，工厂函数就是起这样一个作用，将对象的
//实例化用统一的函数进行封装。