c++设计模式--抽象工厂(abstract factory)

一、原理讲解

为创建一组相关或相互依赖的对象提供一个接口，而且无需指定他们的具体类。

1.1意图

定义一个创建对象的接口，让子类决定实例化哪个类。该模式使类对象的创建延迟到子类。

1.2应用场景

一个系统要独立于它的产品的创建、组合和表示时;

一个系统要由多个产品系列中的一个来配置时;

当你要强调一系列相关的产品对象的设计以便进行联合使用时;

当你提供一个产品类库，而只想显示他们的接口而不是实现时;

1.3结构图（UML图）

1.4代码实现步骤

a1 定义一个抽象产品接口类IProduct，并且定义一个接口函数show()用于子类继承；（抽象产品类）

a2 定义两个实现接口类IProductA和IProductB，都重写接口函数show()；（具体产品类）

a3 定义一个抽象接口工厂类IFactory，并且定义两个对象创建函数createProduct1,createProduct2，唯一目的是被子类继承重写；（抽象工厂类）

a4 定义两个具体工厂类FactoryA和FactoryB，重写接口函数createProduct并且返回对应的产品类对象。（具体产品类）

二、实现代码

AbstractFactory.cpp

#include<iostream>

using namespace std;

#define DELETE(pointer) delete pointer; pointer=nullptr

class IProduct //抽象产品
{
public:
	IProduct() {}
	virtual ~IProduct() {}

	virtual void show() = 0;
};

class ProductA1 : public IProduct //具体产品A
{
public:
	ProductA1() {}
	~ProductA1() {}

	virtual void show() { cout << "ProductA1" << endl; }
};

class ProductA2 : public IProduct //具体产品A
{
public:
	ProductA2() {}
	~ProductA2() {}

	virtual void show() { cout << "ProductA2" << endl; }
};

class ProductB1 : public IProduct //具体产品B
{
public:
	ProductB1() {}
	~ProductB1() {}

	virtual void show() { cout << "ProductB1" << endl; }
};

class ProductB2 : public IProduct //具体产品B
{
public:
	ProductB2() {}
	~ProductB2() {}

	virtual void show() { cout << "ProductB2" << endl; }
};

class IFactory //抽象工厂
{
public:
	IFactory() {}
	virtual ~IFactory() {}

	virtual IProduct* createProduct1() = 0;
	virtual IProduct* createProduct2() = 0;
};

class FactoryA : public IFactory //具体工厂A
{
public:
	FactoryA() {}
	virtual ~FactoryA() {}

	IProduct* createProduct1() override { return new ProductA1; }
	IProduct* createProduct2() override { return new ProductA2; }
};

class FactoryB : public IFactory //具体工厂B
{
public:
	FactoryB() {}
	virtual ~FactoryB() {}

	IProduct* createProduct1() override { return new ProductB1; }
	IProduct* createProduct2() override { return new ProductB2; }
};

void doAbstractFactory()
{
	//生产产品A系列（A1,A2）
	IFactory *factory = new FactoryA();
	IProduct *product1 = factory->createProduct1();
	IProduct *product2 = factory->createProduct1();
	product1->show();
	product2->show();
	DELETE(product1);
	DELETE(product2);
	DELETE(factory);

	//生产产品B系列（B1,B2）
	factory = new FactoryB();
	product1 = factory->createProduct1();
	product2 = factory->createProduct2();
	product1->show();
	product2->show();
	DELETE(product1);
	DELETE(product2);
	DELETE(factory);
}
           

main.cpp

#include <iostream>

extern void doAbstractFactory();

int main()
{
	 doAbstractFactory();

	system("pause");
	return 1;
}
           

三、总结

3.1原理总结（跟工厂方法对比）

抽象工厂可以说是工厂方法的改进或者集合。抽象工厂可以生产一种产品的一个系列，也就是如果有要生产多个产品，则每个产品都有对应的系列产品。比如上面代码的要生产产品A和产品B，然后产品A有系列A1和系列A2，产品B有系列B1和B2，这时就可以用抽象工厂方法了。

3.2代码总结（跟工厂方法对比）

抽象工厂实现代码主要是在工厂方法的基础上进行改进，修改核心是在抽象工厂IFactory里增加一个产品创建接口void createProduct2()=0即可，接着对应产品A 和产品B分别拥有自己的系列产品类A1、A2，B1、B2，然后跟工厂方法一样用具体工厂来创建产品对象。

四、参考内容：

抽象工厂代码（参考：代码实现）

陈建忠设计模式（参考：哔哩哔哩C++设计模式！！！）

Erich Gamma,Richard Helm.《设计模式 可复用面向对象软件的基础》[M].机械工业出版社,2019: