当前位置： 首页 > news >正文

《设计模式》工厂模式

news 2025/8/22 4:42:54

《设计模式》工厂模式

工厂模式又分为简单工厂（Simple Factory）、工厂方法（Factory Method）和抽象工厂（Abstract Factory）都是常用的创建型设计模式，它们的主要区别如下：

  1. 简单工厂：由一个工厂类根据传入的参数来决定创建哪一种产品类的对象。简单工厂适用于对象的创建比较简单，且客户端只需要知道传入的参数即可获取相应的对象的场景。
  2. 工厂方法：定义一个用于创建对象的接口，让子类决定实例化哪一个类。工厂方法模式适用于需要一组相关对象的场景，客户端不需要知道它所使用的对象的具体类型，只需要知道创建对象的接口即可。
  3. 抽象工厂：提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们的具体类。抽象工厂模式适用于需要一组相关的对象，这些对象之间有相互依赖关系，客户端不需要知道创建对象的具体实现细节，只需要知道创建对象的接口即可。

这三种工厂模式的优点及使用场景如下：

  1. 简单工厂的优点：易于实现、客户端调用方便。适用于工厂类负责创建的对象比较少的场景。
  2. 工厂方法的优点：符合开闭原则、可扩展性强。适用于需要一组相关对象，并且需要灵活地增加、替换和删除对象的场景。
  3. 抽象工厂的优点：符合开闭原则、封装性好、可扩展性强。适用于需要创建一组相互依赖、相关或不同类型的对象的场景。

综上所述，选择哪种工厂模式取决于具体的需求场景。如果只需要创建一种对象，则可以使用简单工厂；如果需要创建一组相关的对象，并且需要灵活地增加、替换和删除对象，则可以使用工厂方法；如果需要创建一组相互依赖、相关或不同类型的对象，则可以使用抽象工厂。

简单工厂

首先，定义一个抽象产品类 Product，它是由简单工厂模式负责创建的对象：

class Product {
public:virtual ~Product() {}virtual void operation() = 0;
};

接下来，定义具体产品类 ConcreteProductA 和 ConcreteProductB：

class ConcreteProductA : public Product {
public:void operation() {std::cout << "ConcreteProductA::operation()" << std::endl;}
};class ConcreteProductB : public Product {
public:void operation() {std::cout << "ConcreteProductB::operation()" << std::endl;}
};

这两个类继承了抽象产品类 Product，并实现了 operation 函数。ConcreteProductA 和 ConcreteProductB 是简单工厂模式创建的具体对象。

接下来，定义一个工厂类 Factory，它负责创建具体产品的对象：

class Factory {
public:Product* create_product(int type) {switch (type) {case 0:return new ConcreteProductA();case 1:return new ConcreteProductB();default:return nullptr;}}
};

这个工厂类有一个 create_product 函数，根据传入的类型返回具体产品的对象。在这个示例中，我们使用 switch 语句根据类型选择创建哪种具体产品。

最后，我们可以在主函数中使用简单工厂模式创建具体产品的对象：

int main() {Factory factory;Product* productA = factory.create_product(0);if (productA) {productA->operation();delete productA;}Product* productB = factory.create_product(1);if (productB) {productB->operation();delete productB;}Product* productC = factory.create_product(2);if (!productC) {std::cout << "Invalid product type!" << std::endl;}return 0;
}

在主函数中，我们先创建一个工厂对象，然后分别使用它创建 ConcreteProductA 和 ConcreteProductB 的对象，并调用它们的 operation 函数进行操作。最后，我们试图使用一个不存在的类型创建产品，这时候工厂类将返回 nullptr。

以上就是用 C++ 实现简单工厂模式的示例。

工厂方法

首先，定义一个抽象产品类 Product，它是由工厂方法模式负责创建的对象：

class Product {
public:virtual ~Product() {}virtual void operation() = 0;
};

接下来，定义具体产品类 ConcreteProductA 和 ConcreteProductB：

class ConcreteProductA : public Product {
public:void operation() {std::cout << "ConcreteProductA::operation()" << std::endl;}
};class ConcreteProductB : public Product {
public:void operation() {std::cout << "ConcreteProductB::operation()" << std::endl;}
};

这两个类继承了抽象产品类 Product，并实现了 operation 函数。ConcreteProductA 和 ConcreteProductB 是工厂方法模式创建的具体对象。

接下来，定义一个抽象工厂类 Factory，它声明一个工厂方法 create_product，由具体工厂类负责实现这个方法：

class Factory {
public:virtual ~Factory() {}virtual Product* create_product() = 0;
};

具体工厂类继承这个抽象工厂类，并实现 create_product 方法，用于创建具体产品的对象：

class ConcreteFactoryA : public Factory {
public:Product* create_product() {return new ConcreteProductA();}
};class ConcreteFactoryB : public Factory {
public:Product* create_product() {return new ConcreteProductB();}
};

这两个类继承了抽象工厂类 Factory，并实现了 create_product 方法。ConcreteFactoryA 和 ConcreteFactoryB 是工厂方法模式创建的具体工厂。

最后，我们可以在主函数中使用工厂方法模式创建具体产品的对象：

int main() {Factory* factoryA = new ConcreteFactoryA();Product* productA = factoryA->create_product();if (productA) {productA->operation();delete productA;}delete factoryA;Factory* factoryB = new ConcreteFactoryB();Product* productB = factoryB->create_product();if (productB) {productB->operation();delete productB;}delete factoryB;return 0;
}

在主函数中，我们先创建一个 ConcreteFactoryA 对象，然后使用它创建 ConcreteProductA 的对象，并调用它的 operation 函数进行操作。然后我们创建一个 ConcreteFactoryB 对象，使用它创建 ConcreteProductB 的对象，并调用它的 operation 函数进行操作。最后，我们删除创建的对象并销毁工厂对象。

以上就是用 C++ 实现工厂方法模式的示例。

抽象工厂

首先，定义一个抽象产品类 AbstractProductA 和 AbstractProductB，它们是由抽象工厂模式负责创建的对象：

class AbstractProductA {
public:virtual ~AbstractProductA() {}virtual void operationA() = 0;
};class AbstractProductB {
public:virtual ~AbstractProductB() {}virtual void operationB() = 0;
};

接下来，定义具体产品类 ConcreteProductA1、ConcreteProductA2、ConcreteProductB1 和 ConcreteProductB2：

class ConcreteProductA1 : public AbstractProductA {
public:void operationA() {std::cout << "ConcreteProductA1::operationA()" << std::endl;}
};class ConcreteProductA2 : public AbstractProductA {
public:void operationA() {std::cout << "ConcreteProductA2::operationA()" << std::endl;}
};class ConcreteProductB1 : public AbstractProductB {
public:void operationB() {std::cout << "ConcreteProductB1::operationB()" << std::endl;}
};class ConcreteProductB2 : public AbstractProductB {
public:void operationB() {std::cout << "ConcreteProductB2::operationB()" << std::endl;}
};

这四个类继承了抽象产品类 AbstractProductA 和 AbstractProductB，并实现了 operationA 和 operationB 函数。ConcreteProductA1、ConcreteProductA2、ConcreteProductB1 和 ConcreteProductB2 是抽象工厂模式创建的具体对象。

接下来，定义一个抽象工厂类 AbstractFactory，它声明一组工厂方法 createProductA 和 createProductB，由具体工厂类负责实现这些方法：

class AbstractFactory {
public:virtual ~AbstractFactory() {}virtual AbstractProductA* createProductA() = 0;virtual AbstractProductB* createProductB() = 0;
};

具体工厂类继承这个抽象工厂类，并实现 createProductA 和 createProductB 方法，用于创建具体产品的对象：

class ConcreteFactory1 : public AbstractFactory {
public:AbstractProductA* createProductA() {return new ConcreteProductA1();}AbstractProductB* createProductB() {return new ConcreteProductB1();}
};class ConcreteFactory2 : public AbstractFactory {
public:AbstractProductA* createProductA() {return new ConcreteProductA2();}AbstractProductB* createProductB() {return new ConcreteProductB2();}
};

这两个类继承了抽象工厂类 AbstractFactory，并实现了 createProductA 和 createProductB 方法。ConcreteFactory1 和 ConcreteFactory2 是抽象工厂模式创建的具体工厂。

最后，我们可以在主函数中使用抽象工厂模式创建具体产品的对象：

int main() {// 使用具体工厂1创建产品AbstractFactory* factory1 = new ConcreteFactory1();AbstractProductA* productA1 = factory1->createProductA();AbstractProductB* productB1 = factory1->createProductB();productA1->operationA();productB1->operationB();// 使用具体工厂2创建产品AbstractFactory* factory2 = new ConcreteFactory2();AbstractProductA* productA2 = factory2->createProductA();AbstractProductB* productB2 = factory2->createProductB();productA2->operationA();productB2->operationB();// 释放内存delete productA1;delete productB1;delete factory1;delete productA2;delete productB2;delete factory2;return 0;
}

运行结果如下：

ConcreteProductA1::operationA()
ConcreteProductB1::operationB()
ConcreteProductA2::operationA()
ConcreteProductB2::operationB()

这个示例实现了一个抽象工厂模式，其中抽象工厂类 AbstractFactory 声明了一组工厂方法，具体工厂类 ConcreteFactory1 和 ConcreteFactory2 实现了这些方法，用于创建具体产品的对象。而具体产品类 ConcreteProductA1、ConcreteProductA2、ConcreteProductB1 和 ConcreteProductB2 继承了抽象产品类 AbstractProductA 和 AbstractProductB，并实现了 operationA 和 operationB 函数，表示具体产品的操作。

以上就是用 C++ 实现抽象工厂模式的示例。

抽象工厂模式适用于需要一次性创建一系列相关或相互依赖的对象时，它能够提供一个简单的接口，用于创建这些对象，同时保证这些对象是相互兼容的。由于该模式要求所有具体产品都必须实现相同的接口，因此它提供了更好的灵活性和可扩展性。

http://www.lryc.cn/news/17445.html

相关文章：

  • JS - 原型对象、原型链是什么
  • STM32f103 CubeMX封装 led程序
  • 智慧教室系统--温湿度控制系统
  • 只要一直向前定能到达远方，社科院与杜兰大学金融管理硕士项目为你注入动力
  • Java性能-回收算法-Throughout回收算法
  • 立项近7年，索尼产品经理分享PS VR2开发背后的故事
  • Kubernetes 如何通过ingress-nginx实现应用灰度发布？
  • 华为OD机试 - 密室逃生游戏（Java） | 机试题+算法思路+考点+代码解析 【2023】
  • redis的主从复制细节
  • SparkSQL
  • Python|每日一练|栈|数组|字典树|数组|树|广度优先搜索|单选记录：逆波兰表达式求值|回文对|二叉树的层序遍历
  • 慧教室系统--远程控制系统
  • OSCP-课外1（http万能密码、hydra密码暴力破解http、代码审计、Win缓存区溢出）
  • ELK日志分析--Logstash
  • Mysql插入数据从指定选项中随机选择、插入时间从指定范围随机生成、Navicat使用存储过程模拟插入测试数据
  • 【基础算法】关于高精度计算的问题【很高位数数据的加减乘除(相关代码用C++实现)】
  • 事理知识图谱
  • 多綫程之python爬蟲構建
  • 【干货】Redis在Java开发中的基本使用和巧妙用法
  • 历时半年，我终于阿里上岸了，附面经和Java非科班学习心得
  • ArkUI实战，自定义饼状图组件PieChart
  • 工作实战之系统交互api调用认证设计
  • 学习系统编程No.5【虚拟地址空间】
  • Linux常用指令（未完待续。。。）
  • 用D写裸机
  • (二十五)、实现评论功能（5）【uniapp+uinicloud多用户社区博客实战项目(完整开发文档-从零到完整项目)】
  • 【概念辨析】二维数组传参的几种可能性
  • python和C++代码实现图片九宫格切图程序（附VS2015配置Opencv教程）
  • 【深度学习】优化器
  • SpringBoot使用validator进行参数校验