设计模式-工厂方法模式

学C++的小白王某

949人浏览 · 2025-01-15 03:05:39

学C++的小白王某 · 2025-01-15 03:05:39 发布

设计模式——“工厂方法模式”学习记录

工厂方法主要有以下几种:

简单工厂方法模式
工厂方法模式
抽象工厂方法模式

前两个模式都是面对单一的产品设计，第三个则是一个产品族，更加抽象一些。

简单工厂模式

定义：简单工厂方法模式通过一个工厂类来创建不同类型的对象，客户端只需传入参数，工厂类根据参数决定创建哪种对象。

结构

工厂类：负责创建对象。
产品接口/抽象类：定义产品的通用接口。
具体产品类：实现产品接口的具体类。

优点：

简单易用：客户端只需与工厂类交互，无需关心对象的创建细节。
代码集中：对象的创建逻辑集中在工厂类中，便于维护。

缺点：

违反开闭原则：新增产品类型时，需要修改工厂类的代码。
职责过重：工厂类负责所有产品的创建，职责过于集中。

适用场景：

产品类型较少且不频繁变化。
客户端不关心对象的创建过程。

实现成代码如下:

// 产品接口
class Shape 
{
public:
	virtual ~Shape() {}
	virtual void darw() = 0;
};

// 具体产品
class CircleShape : public Shape 
{
public:
	void darw() override {
		std::cout << "绘制圆形----CircleShape\n";
	}
};

// 当我们后续需要添加其他的产品时也是类似的方式
class SquareShape : public Shape 
{
public:
	void darw() override {
		std::cout << "绘制正方形----SquareShape\n";
	}
};

// 工厂方法
class ShapeFactory {
public:
	ShapeFactory() {}
	~ShapeFactory() {}

	Shape* createShape(const std::string& type) {

		if (type == std::string("CIRCLE")) {
			return new CircleShape();
		}
		if (type == std::string("SQUARE")) {
			return new SquareShape();
		}
		return nullptr;
	}
};


int main()
{
	// 实例化工厂
	std::shared_ptr<ShapeFactory> shapeFactory = std::make_shared<ShapeFactory>();

	// 从工厂中获取一个绘制圆形的产品
	Shape* circle = shapeFactory->createShape("CIRCLE");
	circle->darw();
	delete circle;

	Shape* square = shapeFactory->createShape("SQUARE");
	square->darw();
	delete square;

	return 0;
}

小结

上面是一个简单的工厂方法实现, 当我们创建的产品类型不是很频繁的时, 简单的工厂模式可以简洁明了的将框架展现出来。

但同时也存在问题，就是我们需要频繁的修改工厂类的代码，这一行为违反了开闭原则，同时所有类型的产品都集中在一个工厂类中，会导致工厂类过于的臃肿。

工厂方法模式

定义：工厂方法模式定义一个创建对象的接口，但由子类决定实例化哪个类。工厂方法模式将对象的创建延迟到子类。

结构

抽象工厂类：定义创建对象的接口。
具体工厂类：实现抽象工厂接口，负责创建具体产品。
产品接口/抽象类：定义产品的通用接口。
具体产品类：实现产品接口的具体类。

优点：

符合开闭原则：新增产品类型时，只需增加新的工厂类，无需修改现有代码。
职责分离：每个工厂类只负责一种产品的创建，职责更清晰。

缺点：

类数量增加：每增加一个产品，就需要增加一个对应的工厂类，导致类数量增多。（在C++中可以使用模板来解决这一问题）
复杂度增加：相比简单工厂方法模式，工厂方法模式的实现更为复杂。

适用场景：

产品类型较多且可能频繁变化。
客户端需要扩展新的产品类型。

实现代码如下：

// 游戏角色的职业
class GameProfession {
public:
	virtual ~GameProfession(){}
	// 给一个行为比如说攻击方式
	virtual void attackPattern() = 0;
};

// 战士职业
class WarriorProfession : public GameProfession 
{
public:
	void attackPattern() override {
		std::cout << "战士用大剑近战攻击\n" << std::endl;
	}
};

// 法师
class MagicianProfession : public GameProfession 
{
public:
	void attackPattern() override {
		std::cout << "法师用使用法杖发动法球攻击\n" << std::endl;
	}
};


// 抽象产品工厂类
class GameFactory 
{
public:
	virtual  ~GameFactory() {}
	virtual GameProfession* createProfession() = 0;
};

// 战士角色工厂创建和战士有关的属性
class WarriorProfessionFactory : public GameFactory
{
public:
	GameProfession* createProfession() {
		return new WarriorProfession();
	}
};

// 法师角色工厂创建和法师有关的属性
class MagicianProfessionFactory : public GameFactory 
{
public:
	GameProfession* createProfession() {
		return new MagicianProfession();
	}
};


int main()
{
	// 职业工厂
	std::shared_ptr<GameFactory> warriorFactory = std::make_shared<WarriorProfessionFactory>();
	std::shared_ptr<GameFactory> magicianFactory = std::make_shared<MagicianProfessionFactory>();
	// 获取职业
	GameProfession* warrior = warriorFactory->createProfession();
	GameProfession* magician = magicianFactory->createProfession();
	warrior->attackPattern();
	magician->attackPattern();
	delete warrior;
	delete magician;
	return 0;
}

下面的C++代码是通过 C++模板 来解决为了一个产品类需要创建一个工厂类的问题：

// 游戏角色的职业
class GameProfession {
public:
	virtual ~GameProfession(){}
	// 给一个行为比如说攻击方式
	virtual void attackPattern() = 0;
};

// 战士职业
class WarriorProfession : public GameProfession 
{
public:
	void attackPattern() override {
		std::cout << "战士用大剑近战攻击\n" << std::endl;
	}
};

// 法师
class MagicianProfession : public GameProfession 
{
public:
	void attackPattern() override {
		std::cout << "法师用使用法杖发动法球攻击\n" << std::endl;
	}
};


// 抽象产品工厂类
class GameFactory 
{
public:
	virtual  ~GameFactory() {}
	virtual GameProfession* createProfession() = 0;
};

// 使用模板类来实现一个通用的创建工厂
template <typename T_Profession>
class ProfessionFactory : public GameFactory
{
public:
	GameProfession* createProfession();
};

template<typename T_Profession>
GameProfession* ProfessionFactory<T_Profession>::createProfession()
{
	return new T_Profession;
}

int main()
{
	// 职业工厂
	ProfessionFactory<WarriorProfession> warriorFactory2;
	ProfessionFactory<MagicianProfession> magicianFactory2;
	// 获取职业实例化
	GameProfession* warrior2 = warriorFactory2.createProfession();
	GameProfession* magician2 = magicianFactory2.createProfession();
	warrior2->attackPattern();
	magician2->attackPattern();
	return 0;
}

可以看到通过使用语言特性可以解决一些工厂模式带来的潜在问题, 通过模板具体工厂类, 就可以不需要根据一个具体产品来创建一个具体工厂, 当然这也是有弊端的, 可能不同的工厂可能需要的参数不太一样或者创建的方法也有所不同, 导致模板工厂类会变的有些复杂，所以这些取舍都是开发的经验之谈了。

小结

工厂方法模式的优势凸显就在于一个产品对应一个工厂，这样的好处在于单个类的维护，但同时也存在一个弊端就是如果产品不断的增加就会导致类创建的非常多的问题，虽然模板能够解决，但随着系统迭代复杂很难让人不担心对模板类维护的问题。毕竟模板这东西跟魔法一样越复杂越难以理解。

对比与总结

特性	简单工厂方法模式	工厂方法模式
创建对象的方式	通过一个工厂类创建所有对象	通过子类工厂创建特定对象
开闭原则	违反（新增产品需修改工厂类）	符合（新增产品只需增加新工厂类）
职责集中度	职责集中在一个工厂类	职责分散到多个工厂类
类数量	较少	较多（每个产品对应一个工厂类）
适用场景	产品类型少且不频繁变化	产品类型多且可能频繁变化

选择建议

如果产品类型较少且不频繁变化，可以选择简单工厂方法模式，因为它更简单易用。
如果产品类型较多且可能频繁变化，建议选择工厂方法模式，因为它更符合开闭原则，便于扩展。

完整代码


/*****************************************************************//**
 * \file   FactoryMethod.cpp
 * \brief  设计模式------工厂方法模式
 *         意图: 定义一个用于创建对象的接口, 让子类来决定实例化哪一个类, 工厂方法使一个类的实例化延迟到子类.
 *********************************************************************/

#include <iostream>
#include <memory>

// 产品接口
class Shape 
{
public:
	virtual ~Shape() {}
	virtual void darw() = 0;
};

// 具体产品
class CircleShape : public Shape 
{
public:
	void darw() override {
		std::cout << "绘制圆形----CircleShape\n";
	}
};

// 当我们后续需要添加其他的产品时也是类似的方式
class SquareShape : public Shape 
{
public:

	void darw() override {
		std::cout << "绘制正方形----SquareShape\n";
	}
};

// 工厂方法
class ShapeFactory {
public:
	ShapeFactory() {}
	~ShapeFactory() {}

	Shape* createShape(const std::string& type) {

		if (type == std::string("CIRCLE")) {
			return new CircleShape();
		}
		if (type == std::string("SQUARE")) {
			return new SquareShape();
		}
		return nullptr;
	}
};


// 上面属于简单工厂还算不算上完整的工厂方法模式, 
// 简单工厂方法模式是通过标识符号来创建用户想要的产品
// 完整的工厂模式应该具有两部分的抽象
// 一部分就是上面类似的, 产品抽象类(接口类)
// 另一部分就是抽象的工厂, 根据产品类型抽象出一类工厂,该工程只生产对应类型的产品

// 例如下面的例子
// 现在有一个角色, 他有很多的职业 战士 法师 刺客 等, 
// 这一模块我们可否考虑使用工厂模式呢

// 游戏角色的职业
class GameProfession {
public:
	virtual ~GameProfession(){}
	// 给一个行为比如说攻击方式
	virtual void attackPattern() = 0;
};

// 战士职业
class WarriorProfession : public GameProfession 
{
public:
	void attackPattern() override {
		std::cout << "战士用大剑近战攻击\n" << std::endl;
	}
};

// 法师
class MagicianProfession : public GameProfession 
{
public:
	void attackPattern() override {
		std::cout << "法师用使用法杖发动法球攻击\n" << std::endl;
	}
};


// 抽象产品工厂类
class GameFactory 
{
public:
	virtual  ~GameFactory() {}
	virtual GameProfession* createProfession() = 0;
};

// 战士角色工厂创建和战士有关的属性
class WarriorProfessionFactory : public GameFactory
{
public:
	GameProfession* createProfession() {
		return new WarriorProfession();
	}
};

// 法师角色工厂创建和法师有关的属性
class MagicianProfessionFactory : public GameFactory 
{
public:
	GameProfession* createProfession() {
		return new MagicianProfession();
	}
};

// 使用模板类来实现一个通用的创建工厂
template <typename T_Profession>
class ProfessionFactory : public GameFactory
{
public:
	GameProfession* createProfession();
};

template<typename T_Profession>
GameProfession* ProfessionFactory<T_Profession>::createProfession()
{
	return new T_Profession;
}



int main()
{
	// 实例化工厂
	std::shared_ptr<ShapeFactory> shapeFactory = std::make_shared<ShapeFactory>();

	// 从工厂中获取一个绘制圆形的产品
	Shape* circle = shapeFactory->createShape("CIRCLE");
	circle->darw();
	delete circle;

	Shape* square = shapeFactory->createShape("SQUARE");
	square->darw();
	delete square;
	std::cout << "===========================================\n";
	std::cout << "下面是完整的工厂方法\n";
	// 职业工厂
	std::shared_ptr<GameFactory> warriorFactory1 = std::make_shared<WarriorProfessionFactory>();
	std::shared_ptr<GameFactory> magicianFactory1 = std::make_shared<MagicianProfessionFactory>();

	// 获取职业
	GameProfession* warrior1 = warriorFactory1->createProfession();
	GameProfession* magician1 = magicianFactory1->createProfession();

	warrior1->attackPattern();
	magician1->attackPattern();

	delete warrior1;
	delete magician1;

	std::cout << "===========================================\n";
	std::cout << "下面是通过模板解决工厂方法的一个潜在问题\n";
	// 职业工厂
	ProfessionFactory<WarriorProfession> warriorFactory2;
	ProfessionFactory<MagicianProfession> magicianFactory2;

	// 获取职业实例化
	GameProfession* warrior2 = warriorFactory2.createProfession();
	GameProfession* magician2 = magicianFactory2.createProfession();

	warrior2->attackPattern();
	magician2->attackPattern();


	return 0;
}