* 工厂模式解决了一部分问题，但还有一些缺点，所以这时抽象工厂模式应运而生。。。→_→ *

在阅读本文之前，需要了解一些知识点。。。请戳传送门——工厂模式

1. 工厂模式与抽象工厂模式的区别

   • 工厂模式中，在工厂子类中无论多么辛苦的制造产品子类，其实它们都同属一个父类
   • 而在现实生活中，工厂不可能只制造一种产品。所以一个工厂子类有可能制造多种产品子类，而它们来源于不同的父类

2. 抽象工厂模式的作用

   • 将一组来自于不同父类的子类对象的创建封装到一个类中， 维护这样一个创建类总比维护n个相关对象的创建过程要简单的多

3. 抽象工厂模式结构示意图

   • 

4. 代码实现

#include <iostream>
#include <vld.h>
using namespace std;

//产品A父类
class AbstractProductA
{
public:
	virtual ~AbstractProductA() {}
protected:
	AbstractProductA() {}
};

//产品B父类
class AbstractProductB
{
public:
	virtual ~AbstractProductB() {}
protected:
	AbstractProductB() {}
};

//产品A的子类A1
class ProductA1 : public AbstractProductA
{
public:
	ProductA1()
	{
		cout << "ProductA1..." << endl;
	}
	~ProductA1() {}
};

//产品A的子类A2
class ProductA2 : public AbstractProductA
{
public:
	ProductA2()
	{
		cout << "ProductA2..." << endl;
	}
	~ProductA2() {}
};

//产品B的子类B1
class ProductB1 : public AbstractProductB
{
public:
	ProductB1()
	{
		cout << "ProductB1..." << endl;
	}
	~ProductB1() {}
};

//产品B的子类B2
class ProductB2 : public AbstractProductB
{
public:
	ProductB2()
	{
		cout << "ProductB2..." << endl;
	}
	~ProductB2() {}
};

//抽象工厂父类
class AbstractFactory
{
public:
	virtual ~AbstractFactory() {}
	//工厂中生产有可能生产多种类型的产品，所以对应不同的调用接口
	virtual AbstractProductA* CreateProductA() = 0;
	virtual AbstractProductB* CreateProductB() = 0;
protected:
	AbstractFactory() {}
};

//抽象工厂子类CF1
class ConcreteFactory1 : public AbstractFactory
{
public:
	ConcreteFactory1() {}
	~ConcreteFactory1() {}
	//工厂CF1针对A产品的初始化调用接口实现
	AbstractProductA* CreateProductA()
	{
		return new ProductA1();
	}
	//工厂CF1针对B产品的初始化调用接口实现
	AbstractProductB* CreateProductB()
	{
		return new ProductB1();
	}
};

//抽象工厂子类CF2
class ConcreteFactory2 : public AbstractFactory
{
public:
	ConcreteFactory2() {}
	~ConcreteFactory2() {}
	//工厂CF2针对A产品的初始化调用接口实现
	AbstractProductA* CreateProductA()
	{
		return new ProductA2();
	}
	//工厂CF2针对B产品的初始化调用接口实现
	AbstractProductB* CreateProductB()
	{
		return new ProductB2();
	}
};

int main()
{
	AbstractFactory* cf1 = new ConcreteFactory1();//创建抽象工厂子类CF1
	AbstractProductA* pA1 = cf1->CreateProductA();//在CF1中生产产品A的子类A1
	AbstractProductB* pB1 = cf1->CreateProductB();//在CF1中生产产品B的子类B1

	AbstractFactory* cf2 = new ConcreteFactory2();//创建抽象工厂子类CF2
	AbstractProductA* pA2 = cf2->CreateProductA();//在CF2中生产产品A的子类A2
	AbstractProductB* pB2 = cf2->CreateProductB();//在CF2中生产产品B的子类B2

	delete cf1;
	delete pA1;
	delete pB1;
	delete cf2;
	delete pA2;
	delete pB2;
	return 0;
}

运行结果

* 码完。。。收工。。。→_→ *