C++抽象工厂模式Abstract Factory Pattern

抽象工厂模式（Abstract Factory Pattern）是围绕一个超级工厂创建其他工厂。该超级工厂又称为其他工厂的工厂。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。在抽象工厂模式中，接口是负责创建一个相关对象的工厂，不需要显式指定它们的类。每个生成的工厂都能按照工厂模式提供对象。

意图：提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。

主要解决：主要解决接口选择的问题。

何时使用：系统的产品有多于一个的产品族，而系统只消费其中某一族的产品。

如何解决：在一个产品族里面，定义多个产品。

关键代码：在一个工厂里聚合多个同类产品。

抽象工厂模式图片

AbstractFactory声明一个创建抽象产品对象的操作接口。

ConcreteFactory实现创建具体产品对象的操作。

AbstractProduct为类产品对象声明一个接口。

ConcreteProduct定义一个将被相应的具体工厂创建的产品对象，实现AbstractProduct接口。

Client仅使用由AbstractFactory和AbstractProduct类声明的接口。

适用性：

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

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

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

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

，，，

UML图

AbstractFactoryUML

Factory（抽象工厂）：声明一个用于创建抽象产品的接口
ConcreteFactory（具体工厂）：用于创建具体的产品
Product（抽象产品）：声明一个产品对象类型的接口
ConcreteProduct（具体产品）：由具体工厂创建的具体产品
优缺点

优点：

封装了产品的创建，使得不需要知道具体是哪种产品，只需要知道是哪个工厂即可。
可以支持不同类型的产品，使得模式灵活性更强。
可以非常方便的使用一族中的不同类型的产品。
缺点：

结构过于臃肿，如果产品类型较多或产品族较多，会非常难于管理。
每次如果添加一组产品，那么所有的工厂类都必须添加一个方法，这样违背了开放-封闭原则。所以一般适用于产品组合产品族变化不大的情况。
创建抽象产品

#pragma once

//product.h创建抽象产品

#ifndef PRODUCT_H
#define PRODUCT_H

#include <string>

using namespace std;

class Car
{
public:
	virtual string Name() = 0;//汽车名字
};

class Bike
{
public:
	virtual string Name() = 0;//自行车名称
};
#endif // PRODUCT_H

创建具体产品

#pragma once

//concrete_product.h创建具体产品
#ifndef CONCRETE_PRODUCT
#define CONCRETE_PRODUCT

#include "product.h"

//汽车
//奔驰
class BenzCar :public Car
{
public:
	string Name() { return "Benz Car"; }
};

//宝马
class BmwCar :public Car
{
public:
	string Name() { return "Bmw Car"; }
};

//奥迪
class AudiCar :public Car
{
public:
	string Name() { return "Audi Car"; }
};

//自行车
//奔驰
class BenzBike :public Bike
{
public:
	string Name() { return "Benz Bike"; }
};

//宝马
class BmwBike :public Bike
{
public:
	string Name() { return "Bmw Bike"; }
};

//奥迪
class AudiBike :public Bike
{
public:
	string Name() { return "Audi Bike"; }
};

#endif // CONCRETE_PRODUCT

创建抽象工厂

#pragma once

//factory.h创建抽象工厂
#ifndef FACTORY_H
#define FACTORY_H

#include "product.h"

//抽象工厂
class Factory
{
public:
	enum FACTORY_TYPE
	{
		BENZ_FACTORY,  //奔驰厂
		BMW_FACTORY,   //宝马厂
		AUDI_FACTORY   //奥迪厂
	};

	virtual Car* CreateCar() = 0;  //生产汽车
	virtual Bike* CreateBike() = 0;//生产自行车
	static Factory* CreateFactory(FACTORY_TYPE factory);//创建工厂
};

#endif // FACTORY_H

//factory.cpp

#include "factory.h"
#include "concrete_factory.h"

//创建工厂
Factory * Factory::CreateFactory(FACTORY_TYPE factory)
{
	Factory *pFactory = NULL;
	switch (factory)
	{
	case FACTORY_TYPE::BENZ_FACTORY:
		pFactory = new BenzFactory();
		break;
	case FACTORY_TYPE::BMW_FACTORY:
		pFactory = new BmwFactory();
		break;
	case FACTORY_TYPE::AUDI_FACTORY:
		pFactory = new AudiFactory();
		break;
	default:
		break;
	}
	return pFactory;
}

创建具体工厂

#pragma once
//concrete_factory.h创建具体的工厂
#ifndef CONCRETE_FACTORY_H
#define CONCRETE_FACTORY_H

#include "factory.h"
#include "concrete_product.h"

//奔驰厂
class BenzFactory :public Factory
{
public:
	Car* CreateCar() 
	{
		return new BenzCar();
	}
	Bike* CreateBike()
	{
		return new BenzBike();
	}
};

//宝马厂
class BmwFactory :public Factory
{
public:
	Car* CreateCar()
	{
		return new BmwCar();
	}
	Bike* CreateBike()
	{
		return new BmwBike();
	}
};

//奥迪厂
class AudiFactory :public Factory
{
public:
	Car* CreateCar() 
	{
		return new AudiCar();
	}
	Bike* CreateBike()
	{
		return new AudiBike();
	}
};


#endif // !CONCRETE_FACTORY_H

主函数调用

//main.cpp创建客户端

#include "factory.h"
//#include "product.h"//这个头文件可以省略
#include <iostream>

using namespace std;
#ifndef SAFE_DELETE
#define SAFE_DELETE(p){if(p){delete(p);(p)=NULL;}}
#endif // !SAFE_DELETE

int main()
{
	//制造奔驰
	Factory* pFactory = Factory::CreateFactory(Factory::FACTORY_TYPE::BENZ_FACTORY);
	Car*pCar = pFactory->CreateCar();
	Bike*pBike = pFactory->CreateBike();
	cout << "Benz factory-car;" << pCar->Name() << endl;
	cout << "Benz factory-bike" << pBike->Name()<<endl;
	SAFE_DELETE(pCar);
	SAFE_DELETE(pBike);
	SAFE_DELETE(pFactory);

	//制造宝马
	pFactory = Factory::CreateFactory(Factory::FACTORY_TYPE::BMW_FACTORY);
	pCar = pFactory->CreateCar();
	pBike = pFactory->CreateBike();
	cout << "Bmw factory-car;" << pCar->Name() << endl;
	cout << "Bmw factory-bike" << pBike->Name() << endl;
	SAFE_DELETE(pCar);
	SAFE_DELETE(pBike);
	SAFE_DELETE(pFactory);

	//制造奔驰
	pFactory = Factory::CreateFactory(Factory::FACTORY_TYPE::AUDI_FACTORY);
	pCar = pFactory->CreateCar();
	pBike = pFactory->CreateBike();
	cout << "Audi factory-car;" << pCar->Name() << endl;
	cout << "Audi factory-bike" << pBike->Name() << endl;
	SAFE_DELETE(pCar);
	SAFE_DELETE(pBike);
	SAFE_DELETE(pFactory);

	system("pause");
	return 0;
}

运行结果

参考资料：

代码实现曾参考；https://blog.csdn.net/u011012932/article/details/70653800

（本文章只是做知识积累与总结，无任何盈利目的。）

C++抽象工厂模式Abstract Factory Pattern

猜你喜欢