设计模式：工厂模式

最新推荐文章于 2025-07-16 02:03:14 发布
最新推荐文章于 2025-07-16 02:03:14 发布
阅读量732 收藏 17
点赞数 17
CC 4.0 BY-SA版权
分类专栏： 设计模式 文章标签： 设计模式 C++ 工厂模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/WaitingHereFor/article/details/148519674

        工厂模式（Factory Pattern）是C++中常用的设计模式之一，它属于创建型模式，提供了一种创建对象的最佳方式，而无需将对象创建的逻辑暴露给客户端。工厂模式的主要目的是定义一个用于创建对象的接口，但让子类决定实例化哪一个类。这样，工厂方法使一个类的实例化延迟到其子类。工厂模式可以进一步分为简单工厂模式、工厂方法模式和抽象工厂模式三种类型。

工厂模式的三种形式

1. 简单工厂模式（Simple Factory）

简单工厂模式并不是GoF定义的23种设计模式之一，但它是理解工厂模式的基础。

#include <iostream>
#include <memory>

// 产品接口
class Product {
public:
    virtual ~Product() = default;
    virtual void operation() = 0;
};

// 具体产品A
class ConcreteProductA : public Product {
public:
    void operation() override {
        std::cout << "ConcreteProductA operation" << std::endl;
    }
};

// 具体产品B
class ConcreteProductB : public Product {
public:
    void operation() override {
        std::cout << "ConcreteProductB operation" << std::endl;
    }
};

// 简单工厂
class SimpleFactory {
public:
    enum ProductType { A, B };
    
    static std::unique_ptr<Product> createProduct(ProductType type) {
        switch (type) {
            case A: return std::make_unique<ConcreteProductA>();
            case B: return std::make_unique<ConcreteProductB>();
            default: return nullptr;
        }
    }
};

int main() {
    auto productA = SimpleFactory::createProduct(SimpleFactory::A);
    productA->operation();  // 输出: ConcreteProductA operation
    
    auto productB = SimpleFactory::createProduct(SimpleFactory::B);
    productB->operation();  // 输出: ConcreteProductB operation
    
    return 0;
}

2. 工厂方法模式（Factory Method）

工厂方法模式定义了一个创建对象的接口，但让子类决定实例化哪一个类。

#include <iostream>
#include <memory>

// 产品接口
class Product {
public:
    virtual ~Product() = default;
    virtual void operation() = 0;
};

// 具体产品A
class ConcreteProductA : public Product {
public:
    void operation() override {
        std::cout << "ConcreteProductA operation" << std::endl;
    }
};

// 具体产品B
class ConcreteProductB : public Product {
public:
    void operation() override {
        std::cout << "ConcreteProductB operation" << std::endl;
    }
};

// 工厂接口
class Factory {
public:
    virtual ~Factory() = default;
    virtual std::unique_ptr<Product> createProduct() = 0;
};

// 具体工厂A
class ConcreteFactoryA : public Factory {
public:
    std::unique_ptr<Product> createProduct() override {
        return std::make_unique<ConcreteProductA>();
    }
};

// 具体工厂B
class ConcreteFactoryB : public Factory {
public:
    std::unique_ptr<Product> createProduct() override {
        return std::make_unique<ConcreteProductB>();
    }
};

int main() {
    std::unique_ptr<Factory> factoryA = std::make_unique<ConcreteFactoryA>();
    auto productA = factoryA->createProduct();
    productA->operation();  // 输出: ConcreteProductA operation
    
    std::unique_ptr<Factory> factoryB = std::make_unique<ConcreteFactoryB>();
    auto productB = factoryB->createProduct();
    productB->operation();  // 输出: ConcreteProductB operation
    
    return 0;
}

3. 抽象工厂模式（Abstract Factory）

抽象工厂模式提供一个接口，用于创建相关或依赖对象的家族，而不需要明确指定具体类。

#include <iostream>
#include <memory>

// 抽象产品A
class AbstractProductA {
public:
    virtual ~AbstractProductA() = default;
    virtual void operationA() = 0;
};

// 具体产品A1
class ProductA1 : public AbstractProductA {
public:
    void operationA() override {
        std::cout << "ProductA1 operationA" << std::endl;
    }
};

// 具体产品A2
class ProductA2 : public AbstractProductA {
public:
    void operationA() override {
        std::cout << "ProductA2 operationA" << std::endl;
    }
};

// 抽象产品B
class AbstractProductB {
public:
    virtual ~AbstractProductB() = default;
    virtual void operationB() = 0;
};

// 具体产品B1
class ProductB1 : public AbstractProductB {
public:
    void operationB() override {
        std::cout << "ProductB1 operationB" << std::endl;
    }
};

// 具体产品B2
class ProductB2 : public AbstractProductB {
public:
    void operationB() override {
        std::cout << "ProductB2 operationB" << std::endl;
    }
};

// 抽象工厂
class AbstractFactory {
public:
    virtual ~AbstractFactory() = default;
    virtual std::unique_ptr<AbstractProductA> createProductA() = 0;
    virtual std::unique_ptr<AbstractProductB> createProductB() = 0;
};

// 具体工厂1
class ConcreteFactory1 : public AbstractFactory {
public:
    std::unique_ptr<AbstractProductA> createProductA() override {
        return std::make_unique<ProductA1>();
    }
    
    std::unique_ptr<AbstractProductB> createProductB() override {
        return std::make_unique<ProductB1>();
    }
};

// 具体工厂2
class ConcreteFactory2 : public AbstractFactory {
public:
    std::unique_ptr<AbstractProductA> createProductA() override {
        return std::make_unique<ProductA2>();
    }
    
    std::unique_ptr<AbstractProductB> createProductB() override {
        return std::make_unique<ProductB2>();
    }
};

int main() {
    std::unique_ptr<AbstractFactory> factory1 = std::make_unique<ConcreteFactory1>();
    auto productA1 = factory1->createProductA();
    auto productB1 = factory1->createProductB();
    productA1->operationA();  // 输出: ProductA1 operationA
    productB1->operationB();  // 输出: ProductB1 operationB
    
    std::unique_ptr<AbstractFactory> factory2 = std::make_unique<ConcreteFactory2>();
    auto productA2 = factory2->createProductA();
    auto productB2 = factory2->createProductB();
    productA2->operationA();  // 输出: ProductA2 operationA
    productB2->operationB();  // 输出: ProductB2 operationB
    
    return 0;
}

实际案例：数据库连接管理

通过数据库连接这个实际场景，详细分析三种模式的实现和区别。假设我们需要开发一个支持多种数据库（MySQL、PostgreSQL、SQLite）的连接管理系统。

1. 简单工厂模式实现

#include <iostream>
#include <memory>
#include <string>

// 数据库连接接口
class DatabaseConnection {
public:
    virtual ~DatabaseConnection() = default;
    virtual void connect() = 0;
    virtual void executeQuery(const std::string& query) = 0;
};

// MySQL连接
class MySQLConnection : public DatabaseConnection {
public:
    void connect() override {
        std::cout << "Connected to MySQL database" << std::endl;
    }
    void executeQuery(const std::string& query) override {
        std::cout << "Executing MySQL query: " << query << std::endl;
    }
};

// PostgreSQL连接
class PostgreSQLConnection : public DatabaseConnection {
public:
    void connect() override {
        std::cout << "Connected to PostgreSQL database" << std::endl;
    }
    void executeQuery(const std::string& query) override {
        std::cout << "Executing PostgreSQL query: " << query << std::endl;
    }
};

// 简单数据库工厂
class DatabaseFactory {
public:
    enum DBType { MYSQL, POSTGRESQL };
    
    static std::unique_ptr<DatabaseConnection> createConnection(DBType type) {
        switch (type) {
            case MYSQL: return std::make_unique<MySQLConnection>();
            case POSTGRESQL: return std::make_unique<PostgreSQLConnection>();
            default: throw std::invalid_argument("Unknown database type");
        }
    }
};

// 客户端代码
int main() {
    auto mysqlConn = DatabaseFactory::createConnection(DatabaseFactory::MYSQL);
    mysqlConn->connect();
    mysqlConn->executeQuery("SELECT * FROM users");
    
    auto pgConn = DatabaseFactory::createConnection(DatabaseFactory::POSTGRESQL);
    pgConn->connect();
    pgConn->executeQuery("SELECT * FROM customers");
    
    return 0;
}

简单工厂特点分析：

  • 一个工厂类负责所有产品的创建

  • 通过参数判断创建哪种产品

  • 新增数据库类型需要修改工厂类（违反开闭原则）

  • 适用于产品较少且不常变化的场景

2. 工厂方法模式实现

// 前面DatabaseConnection及其子类定义不变...

// 抽象工厂接口
class DatabaseFactory {
public:
    virtual ~DatabaseFactory() = default;
    virtual std::unique_ptr<DatabaseConnection> createConnection() = 0;
};

// MySQL工厂
class MySQLFactory : public DatabaseFactory {
public:
    std::unique_ptr<DatabaseConnection> createConnection() override {
        return std::make_unique<MySQLConnection>();
    }
};

// PostgreSQL工厂
class PostgreSQLFactory : public DatabaseFactory {
public:
    std::unique_ptr<DatabaseConnection> createConnection() override {
        return std::make_unique<PostgreSQLConnection>();
    }
};

// 新增SQLite支持不需要修改已有代码
class SQLiteConnection : public DatabaseConnection {
public:
    void connect() override {
        std::cout << "Connected to SQLite database" << std::endl;
    }
    void executeQuery(const std::string& query) override {
        std::cout << "Executing SQLite query: " << query << std::endl;
    }
};

class SQLiteFactory : public DatabaseFactory {
public:
    std::unique_ptr<DatabaseConnection> createConnection() override {
        return std::make_unique<SQLiteConnection>();
    }
};

// 客户端代码
void clientCode(DatabaseFactory& factory) {
    auto conn = factory.createConnection();
    conn->connect();
    conn->executeQuery("SELECT * FROM products");
}

int main() {
    MySQLFactory mysqlFactory;
    clientCode(mysqlFactory);
    
    PostgreSQLFactory pgFactory;
    clientCode(pgFactory);
    
    SQLiteFactory sqliteFactory;
    clientCode(sqliteFactory);
    
    return 0;
}

工厂方法特点分析：

  • 每个产品对应一个具体工厂类

  • 新增数据库类型只需添加新工厂类（符合开闭原则）

  • 客户端依赖抽象工厂接口，不依赖具体类

  • 适合产品类型可能扩展的场景

3. 抽象工厂模式实现

现在需求升级：除了数据库连接，还需要支持不同数据库的数据迁移工具。

// 数据库连接接口及实现同上...

// 数据迁移工具接口
class DataMigrationTool {
public:
    virtual ~DataMigrationTool() = default;
    virtual void migrate(const std::string& table) = 0;
};

// MySQL迁移工具
class MySQLMigrationTool : public DataMigrationTool {
public:
    void migrate(const std::string& table) override {
        std::cout << "Migrating MySQL table: " << table << std::endl;
    }
};

// PostgreSQL迁移工具
class PostgreSQLMigrationTool : public DataMigrationTool {
public:
    void migrate(const std::string& table) override {
        std::cout << "Migrating PostgreSQL table: " << table << std::endl;
    }
};

// 抽象工厂接口
class DatabaseFactory {
public:
    virtual ~DatabaseFactory() = default;
    virtual std::unique_ptr<DatabaseConnection> createConnection() = 0;
    virtual std::unique_ptr<DataMigrationTool> createMigrationTool() = 0;
};

// MySQL产品族工厂
class MySQLFactory : public DatabaseFactory {
public:
    std::unique_ptr<DatabaseConnection> createConnection() override {
        return std::make_unique<MySQLConnection>();
    }
    std::unique_ptr<DataMigrationTool> createMigrationTool() override {
        return std::make_unique<MySQLMigrationTool>();
    }
};

// PostgreSQL产品族工厂
class PostgreSQLFactory : public DatabaseFactory {
public:
    std::unique_ptr<DatabaseConnection> createConnection() override {
        return std::make_unique<PostgreSQLConnection>();
    }
    std::unique_ptr<DataMigrationTool> createMigrationTool() override {
        return std::make_unique<PostgreSQLMigrationTool>();
    }
};

// 客户端代码
void clientCode(DatabaseFactory& factory) {
    auto conn = factory.createConnection();
    auto tool = factory.createMigrationTool();
    
    conn->connect();
    conn->executeQuery("SELECT * FROM products");
    tool->migrate("users");
}

int main() {
    MySQLFactory mysqlFactory;
    clientCode(mysqlFactory);
    
    PostgreSQLFactory pgFactory;
    clientCode(pgFactory);
    
    return 0;
}

抽象工厂特点分析：

  • 创建的是产品族（多个相关产品）

  • 每个具体工厂负责创建一组相关产品

  • 保证产品之间的兼容性

  • 适合需要创建多个相关对象的复杂系统

三者的核心区别总结

特性简单工厂模式工厂方法模式抽象工厂模式
工厂角色一个具体工厂类多个具体工厂类多个具体工厂类（产品族工厂）
扩展性修改工厂类（违反开闭原则）新增工厂类（符合开闭原则）新增产品族工厂（符合开闭原则）
创建目标单一产品单一产品产品族（多个相关产品）
适用场景产品类型固定的小型系统需要灵活扩展产品的系统需要保证产品兼容性的复杂系统
复杂度简单中等较高
产品间约束无无有（保证产品族兼容性）

选择建议

  1. 如果产品类型固定不变且数量少 → 简单工厂

  2. 如果产品类型可能扩展 → 工厂方法

  3. 如果需要创建多个相关产品对象（产品族）→ 抽象工厂

  4. 在大型系统中，三种模式可能组合使用

工厂方法模式是抽象工厂模式的基础，而抽象工厂模式通常包含多个工厂方法。理解这些差异可以帮助你在实际开发中选择最合适的模式。

工厂模式的应用场景

  1. 简单工厂模式：

    • 当对象的创建逻辑比较简单时

    • 客户端不需要知道具体的产品类名

  2. 工厂方法模式：

    • 当一个类不知道它所需要的对象的类时

    • 当一个类希望由它的子类来指定它所创建的对象时

    • 当将创建对象的职责委托给多个帮助子类中的某一个，并且你希望将哪一个帮助子类是代理者这一信息局部化时

  3. 抽象工厂模式：

    • 系统需要独立于它的产品的创建、组合和表示时

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

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

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

工厂模式的优点

  1. 封装性好：客户端不需要知道具体产品类的类名，只需要知道工厂类即可

  2. 扩展性好：增加新的产品时，只需要扩展一个工厂类即可

  3. 解耦：工厂模式将对象的创建与使用分离

  4. 符合开闭原则：对扩展开放，对修改关闭

工厂模式的缺点

  1. 增加复杂度：每增加一个产品，就需要增加一个具体产品类和工厂类

  2. 抽象性增加：引入了抽象层，增加了系统的抽象性和理解难度

  3. 具体产品与工厂耦合：工厂方法模式中，具体产品与具体工厂一一对应

工厂模式是C++中非常常用的设计模式，特别是在需要灵活创建对象的场景中。理解并合理运用工厂模式，可以大大提高代码的可维护性和扩展性。

设计模式：工厂模式和抽象工厂模式的区别
liu_rockefeller的博客
04-04 3184
工厂模式（Factory Pattern）通常指的是工厂方法模式（Factory Method Pattern），它定义了一个创建对象的方法，由子类决定要实例化的类。工厂方法让类的实例化推迟到子类。抽象工厂模式（Abstract Factory Pattern）提供了一个接口，用于创建相关或依赖对象的家族，而不需要明确指定具体类。抽象工厂允许客户端使用抽象的接口来创建一组相关的产品，而不需要知道（或关心）实际生产的具体产品是什么。
Java设计模式：工厂模式图文代码示例详解
07-07
工厂模式主要分为三种类型：简单工厂模式、工厂方法模式和抽象工厂模式。 首先介绍简单工厂模式，也称为静态工厂模式。以购买手机为例，消费者无需关心手机的生产过程或内部零件的制造细节，这些复杂的生产流程都由...
python设计模式：工厂模式
夏末蝉未鸣的博客
04-06 3742
在面向对象编程中，术语“工厂”表示一个负责创建其他类型对象的类。通常情况下，作为一个工厂的类有一个对象以及与它关联的多个方法。客户端使用某些参数调用此方法，之后，工厂会据此创建所需类型的对象，然后将它们返回给客户端。
Java设计模式：工厂模式详解
国家专精特新小巨人、资深消防行业企业、国家高新技术企业、智慧消防技术实验室、准独角兽企业、浙江省电流AI技术研发中心
10-18 4996
工厂模式是一种创建型设计模式，它提供了一个创建对象的接口，但允许子类决定实例化哪一个类。工厂方法让类的实例化推迟到子类。工厂模式是一种非常实用的设计模式，它可以提高代码的可维护性和扩展性。通过将对象的创建过程封装在工厂类中，客户端可以更加灵活地使用对象，而不必关心具体的创建细节。
设计模式：工厂方法模式（Factory Method）
ProgramNovice的博客
04-19 1772
设计模式：工厂方法模式（Factory Method）
Java设计模式：工厂模式之简单工厂、工厂方法、抽象工厂（三）
码到三十五
02-28 5799
在软件设计中，工厂模式是一种常见的设计模式，它提供了一种创建对象的最佳方式。通过工厂模式，我们可以将对象的创建逻辑与使用逻辑分离，降低代码的耦合度，提高系统的可扩展性和可维护性。Java作为一种面向对象的编程语言，自然也支持工厂模式的实现。接下来，我们将详细介绍Java中工厂模式的多种实现方式。
详解设计模式：工厂方法模式
栗筝i的博客
11-26 4176
工厂方法模式，又称工厂模式、多态工厂模式和虚拟构造器模式，通过工厂父类定义负责创建产品的公共接口，子类负责生产具体对象。可以理解为简单工程模式的升级，解决简单工厂模式的弊端。 本篇内容包括：关于 工厂方法模式、工厂方法模式 Demo。
设计模式——工厂模式
热门推荐
XHY的博客
10-12 3万+
1. 工厂模式定义 工厂模式（Factory Pattern）是 Java 中最常用的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。 在工厂模式中，我们在创建对象时不会对客户端暴露创建逻辑，并且是通过使用一个共同的接口来指向新创建的对象。 2. 作用 通过工厂模式，将创建产品实例的权利移交工厂，我们不再通过new来创建我们所需的对象，而是通过工厂来获取我们需要的产品。降低了产品使用者与使用者之间的耦合关系 3. 类图 这里的工厂与产品为一对一的关系，属于简单工厂 .
软件设计模式: 抽象工厂
言之。
07-20 1万+
抽象工厂模式（Abstract Factory Pattern）属于创建型设计模式。它提供了一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。抽象工厂模式的主要优点是：易于交换产品系列，由于具体工厂类在一个应用中只需要在初始化的时候出现一次，这使得改变一个应用的具体工厂变得非常容易；它让具体的创建实例过程与客户端分离，客户端是通过抽象工厂和抽象产品来操纵实例，产品的具体类名也被具体工厂的实现分离，不会出现在客户代码中。
Python设计模式：工厂模式
生活屁颠过的博客
12-26 2万+
设计模式一：工厂模式 什么是工厂模式 根据提供的信息，在工厂的处理下，返回给想要的结果。 比如，甲方给工厂提供一个外形要求，及外形是鸭子。工厂里有许许多多的模具，有鸭子，小狗，小猫等等。工厂在接到要求后，根据要求选择出鸭子的模具返回给了甲方。 使用特点 1.请求一个对象，而无需知道这个对象来自哪里，简化对象的创建 2.可以通过工厂模式来对相似的对象创建进行分组 3.可以创建多个工厂，每个工厂负责一...
详解设计模式：简单工厂模式
栗筝i的博客
11-25 4041
简单工厂模式（Smiple Factory Pattern）：定义一个工厂类，他可以根据参数的不同返回不同类的实例，被创建的实例通常都具有共同的父类，简单工厂模式也被称为静态工厂模式。 本篇内容包括：工厂模式 概述、关于 简单工厂模式、简单工厂模式 Demo。
探索Java设计模式：工厂模式与抽象工厂模式的比较
08-14
工厂模式和抽象工厂模式是两种常用的创建型设计模式，它们在Java中有着广泛的应用。本文将详细探讨这两种模式的区别，并提供代码示例来加深理解。 工厂模式和抽象工厂模式都是创建型设计模式，它们提供了代码解耦和...
深入理解Python设计模式：工厂模式实践与应用
11-05
工厂模式是一种在软件工程中广泛使用的创建型设计模式，它提供了创建对象的最佳方式。工厂模式的核心思想是将对象的创建与使用分离，通过专门的工厂类来创建对象。这种模式的目的在于解耦对象的创建和调用代码之间的...
Java设计模式：工厂模式——图文+代码示例（通俗易懂）
12-21
Java设计模式中的工厂模式是一种创建型设计模式，其主要目的是为了解耦对象的创建与使用。工厂模式通过提供一个统一的接口或类来创建对象，使得客户端代码无需直接实例化对象，而是通过调用工厂方法来获取所需的对象...
面向对象的设计模式
2502_90360884的博客
07-14 369
针对反复出现的问题所总结归纳出的通用解决方设计模式是指在软件开发过程中案。这些方案是众多软件开发人员经过大量实践总结出来的，具有高效性、可维护性和可扩展性等优点。使用设计模式可以帮助开发者更高效地构建软件系统，提高代码的复用性、可维护性和可扩展性，同时也能降低系统的耦合度。
深入理解设计模式之桥接模式：解耦抽象与实现的艺术
vvilkin的学习备忘
07-14 730
在软件开发中，我们经常会遇到需要处理多个变化维度的情况。传统的继承方式虽然简单直接，但当系统需要支持多种变化时，会导致类数量爆炸式增长，系统变得难以维护。桥接模式（Bridge Pattern）正是为解决这类问题而生的经典设计模式。本文将深入探讨桥接模式的核心思想、实现原理、应用场景以及在实际项目中的最佳实践。
设计模式-观察者模式
weixin_65550740的博客
07-13 348
就是定义对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并自动更新。1. 观察者模式核心是让事件的发布者去观察消息。接收到新的天气信息的函数。
UML建模和设计模式——常考点整理
John Lee 的专栏
07-14 753
本文概述了UML建模语言、设计模式和面向对象编程的核心内容。UML部分介绍了9种基本图（包括类图、用例图、序列图等）的分类及作用；设计模式分为创建型、结构型和行为型三大类，列举了23种经典模式的定义；面向对象部分涵盖了基本概念（封装、继承、多态等）、分析设计方法、设计原则（SOLID等）及测试层次。全文系统地整理了软件设计领域的核心知识框架，为开发人员提供了全面的技术参考。
深入理解设计模式之代理模式：原理、实现与应用
最新发布
vvilkin的学习备忘
07-16 809
在软件开发中，我们经常需要控制对某些对象的访问——可能是为了延迟加载、添加额外功能或保护敏感资源。这正是代理模式大显身手的地方。作为结构型设计模式的重要成员，代理模式在众多知名框架和系统中扮演着关键角色。本文将全面剖析代理模式的方方面面，带你领略这一模式的精妙之处。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值