抽象工厂

昨天说到工厂只能创建一类类，而真正处理多种类型的类时，则需要用到抽象工厂模式，比如创建数据库类，ok有各类数据库，这时候都放在一个类中处理，显然是不合适的，就需要针对不同的数据库，创建不同的数据库类。、

Uml图

代码（C++）

//抽象产品A
class AbstractProductA
{
public:
	virtual ~AbstractProductA() = 0{}
protected:
	AbstractProductA(){}
};
//抽象产品B
class AbstractProductB
{
public:
	virtual ~AbstractProductB() = 0{}
protected:
	AbstractProductB(){}
};
//具体的产品A1，A2
class ConcreteProductA1 : public AbstractProductA
{
public:
	ConcreteProductA1(){}
	~ConcreteProductA1(){}
};
class ConcreteProductA2 : public AbstractProductA
{
public:
	ConcreteProductA2(){}
	~ConcreteProductA2(){}
};
//具体产品B1，B2
class ConcreteProductB1 : public AbstractProductB
{
public:
	ConcreteProductB1(){}
	~ConcreteProductB1(){}
};
class ConcreteProductB2 : public AbstractProductB
{
public:
	ConcreteProductB2(){}
	~ConcreteProductB2(){}
};
//抽象工厂
class AbstractFactory
{
public:
	virtual ~AbstractFactory() = 0{}
	//包含所有产品的创建
	virtual AbstractProductA* CreateProductA() = 0;
	virtual AbstractProductB* CreateProductB() = 0;
protected:
	AbstractFactory(){}
};
//抽象工厂1
class ConcreteFactory1 : public AbstractFactory
{
public:
	ConcreteFactory1(){}
	~ConcreteFactory1(){}
	AbstractProductA* CreateProductA()
	{
		return new ConcreteProductA1();
	}
	AbstractProductB* CreateProductB()
	{
		return new ConcreteProductB1();
	}
};
//抽象工厂2
class ConcreteFactory2 : public AbstractFactory
{
public:
	ConcreteFactory2(){}
	~ConcreteFactory2(){}
	AbstractProductA* CreateProductA()
	{
		return new ConcreteProductA2();
	}
	AbstractProductB* CreateProductB()
	{
		return new ConcreteProductB2();
	}
};
int _tmain(int argc, _TCHAR* argv[])
{
	AbstractFactory* fac1 = new ConcreteFactory1;
	AbstractFactory* fac2 = new ConcreteFactory2;
	pA1 = fac1->CreateProductA();
	pB1 = fac1->CreateProductB();
	pA2 = fac2->CreateProductA();
	pB2 = fac2->CreateProductB();
	//同时别忘记删除指针，同样关于产品的删除最好在工厂中销毁
	return 0;
}

工厂模式和抽象模式都是基础的设计模式，在实际应用中被广泛用到。下节将讲述创建全局唯一对象，C++全局对象就可以实现，下节会讲解单例模式和定义全局变量的优缺点。