设计模式之工厂模式

一、工厂模式概述

工厂生产产品、产量大、质量保证、在程序中生产某一类对象，不用担心生产对象有问题，只要工厂类没有问题，可以生产很多种对象、但是必须是兄弟关系、都继承一个父类。

二、简单工厂模式

简单工厂模式创建步骤：

创建一个新的类，可以称之为工厂类，对于简单工厂模式来说，需要的工厂类只有一个。
在这个工厂类里面添加一个公共成员函数，通过这个函数我们可以创建需要的对象，这个函数可以称之为工厂函数。
关于使用，首先创建一个工厂类的对象，通过这个对象调用工厂函数，这样就可以生产出指定类型的实例对象（兄弟关系）。

三、简单工厂模式代码及解释

cpp 复制代码

// 定义抽象汽车类
class AbstractCar
{
public:
	virtual void engine() = 0;  // 纯虚函数，定义发动机相关操作，子类需实现
	virtual void chassis() = 0; // 纯虚函数，定义底盘相关操作，子类需实现
	virtual ~AbstractCar() {}  // 虚析构函数，确保正确释放子类对象资源
};

// 轿车类，继承自抽象汽车类
class SedanCar : public AbstractCar
{
public:
	virtual void engine() override  // 重写父类的发动机操作
	{
		cout << "轿车->小型汽油发动机" << endl;
	}
	virtual void chassis() override  // 重写父类的底盘操作
	{
		cout << "轿车->轻型底盘" << endl;
	}
};

// SUV 类，继承自抽象汽车类
class SUVCar : public AbstractCar
{
public:
	virtual void engine() override  // 重写父类的发动机操作
	{
		cout << "SUV->大型汽油发动机" << endl;
	}
	virtual void chassis() override  // 重写父类的底盘操作
	{
		cout << "SUV->坚固底盘" << endl;
	}
};

// 卡车类，继承自抽象汽车类
class TruckCar : public AbstractCar
{
public:
	virtual void engine() override  // 重写父类的发动机操作
	{
		cout << "卡车->柴油发动机" << endl;
	}
	virtual void chassis() override  // 重写父类的底盘操作
	{
		cout << "卡车->重载底盘" << endl;
	}
};

enum class Type :char { SedanCar, SUVCar, TruckCar };  // 定义一个枚举类型，表示汽车类型

class CarFactor
{
public:
	AbstractCar * createCar(Type type)  // 根据给定的汽车类型创建相应的汽车对象
	{
		AbstractCar*ptr = nullptr;  // 初始化指针为空
		switch (type)  // 根据传入的汽车类型进行选择
		{
		case Type::SedanCar:  // 如果是轿车类型
			ptr = new SedanCar;  // 创建轿车对象
			break;
		case Type::SUVCar:  // 如果是 SUV 类型
			ptr = new SUVCar;  // 创建 SUV 对象
			break;
		case Type::TruckCar:  // 如果是卡车类型
			ptr = new TruckCar;  // 创建卡车对象
			break;
		}
		return ptr;  // 返回创建的汽车对象指针
	}
};

int main()
{
	CarFactor*factory = new CarFactor;  // 创建汽车工厂对象
	AbstractCar*obj = factory->createCar(Type::SedanCar);  // 创建轿车对象
	obj->engine();  // 调用轿车的发动机操作
	obj->chassis();  // 调用轿车的底盘操作
	delete obj;  // 释放轿车对象内存
	delete factory;  // 释放工厂对象内存
	return 0;
}

大致思路：在产品类的父类中定义一些接口也就是虚函数，定义为纯虚函数子类必须要重写这个方法，给父类提供一个虚析构函数，多态避免内存泄漏，再定义几个子类继承父类，创建一个工厂类，创建公共成员函数，参数定义枚举可以进行错误检查，工厂函数内部通过switch进行判断，用父类指针指向子类对象，主函数创建工厂类的对象，听过工厂对象调用工厂方法。简单工厂模式其实是对多态的一个应用。

简单工厂模式缺点：已经开发好的不能进行修改如果只有一个工厂函数那可定会修改、工厂函数内部代码量太多不容易被维护、可读性随着代码增越来越低。

四、工厂模式

工厂模式是对简单工厂的解耦、一对一的关系创建n个工厂类、削弱了工厂类的功能尽可能让工厂类的功能单一、遵循单一原则。遵循设计模式三原则、增加新的可以直接添加子工厂类不需要修改。

工厂模式对简单工厂的解耦合：

在简单工厂模式中，工厂类通常包含了创建所有产品对象的逻辑，这导致工厂类的职责过于复杂和庞大。而工厂模式通过将每个产品的创建逻辑分离到各自对应的工厂类中，实现了工厂类与产品类之间的解耦合。

例如，在汽车制造的例子中，简单工厂可能在一个类中处理轿车、SUV 和卡车的创建，而工厂模式则为轿车、SUV 和卡车分别创建独立的工厂类。

一对一的关系创建 n 个工厂类：

每个具体的产品都有一个对应的工厂类，建立了明确的一对一映射关系。这种明确的关系使得系统的结构更加清晰和易于理解。

比如，有轿车产品就有轿车工厂类，有 SUV 产品就有 SUV 工厂类，不会出现一个工厂类负责多种差异较大的产品创建。

削弱工厂类的功能，让其功能单一：

每个工厂类只专注于创建一种特定类型的产品，功能变得单一而明确。这符合单一职责原则，即一个类应该只有一个引起它变化的原因。

以汽车工厂为例，轿车工厂只关心如何创建轿车，不需要了解 SUV 或卡车的创建细节，降低了工厂类内部的复杂性。

五、工厂模式代码及解释

cpp 复制代码

// 定义抽象汽车类
class AbstractCar
{
public:
	virtual void engine() = 0;  // 发动机
	virtual void chassis() = 0; // 底盘
	virtual ~AbstractCar() {}
};

// 轿车类，继承自抽象汽车类
class SedanCar : public AbstractCar
{
public:
	virtual void engine() override
	{
		cout << "轿车->小型汽油发动机" << endl;
	}
	virtual void chassis() override
	{
		cout << "轿车->轻型底盘" << endl;
	}
};

// SUV 类，继承自抽象汽车类
class SUVCar : public AbstractCar
{
public:
	virtual void engine() override
	{
		cout << "SUV->大型汽油发动机" << endl;
	}
	virtual void chassis() override
	{
		cout << "SUV->坚固底盘" << endl;
	}
};

// 卡车类，继承自抽象汽车类
class TruckCar : public AbstractCar
{
public:
	virtual void engine() override
	{
		cout << "卡车->柴油发动机" << endl;
	}
	virtual void chassis() override
	{
		cout << "卡车->重载底盘" << endl;
	}
};

// 定义工厂类（父类）
class CarFactory
{
public:
	virtual AbstractCar* createCar() = 0;
	virtual ~CarFactory() {}
};

// 轿车工厂类，继承自工厂类
class SedanCarFactory : public CarFactory
{
public:
	AbstractCar* createCar()
	{
		return new SedanCar;
	}
	~SedanCarFactory()
	{
		cout << "SedanCarFactory 被析构掉了" << endl;
	}
};

// SUV 工厂类，继承自工厂类
class SUVCarFactory : public CarFactory
{
public:
	AbstractCar* createCar()
	{
		return new SUVCar;
	}
	~SUVCarFactory()
	{
		cout << "SUVCarFactory 被析构掉了" << endl;
	}
};

// 卡车工厂类，继承自工厂类
class TruckCarFactory : public CarFactory
{
public:
	AbstractCar* createCar()
	{
		return new TruckCar;
	}
	~TruckCarFactory()
	{
		cout << "TruckCarFactory 被析构掉了" << endl;
	}
};

int main()
{
	CarFactory* factory = new SedanCarFactory;
	AbstractCar* obj = factory->createCar();
	obj->engine();
	obj->chassis();
	delete obj;
	delete factory;
	return 0;
}

总的来说，工厂模式通过解耦合、功能单一化和遵循设计原则，使得软件系统在面对产品种类的变化和扩展时，能够更加灵活、易于维护和扩展，减少了因为修改现有代码而引入新错误的风险。

本篇文章主要通过制造汽车这个场景介绍了简单工厂模式 和工厂模式，希望您可以对工厂模式有一个初步理解！看完点赞哟（爱心）！