C++版设计模式简介 与 初识 工厂模式

已于 2024-08-18 21:27:07 修改
阅读量907 收藏 14
点赞数 8
分类专栏： 从C高级到征服C++ 文章标签： c++ 设计模式 设计规范 linux
于 2024-08-18 21:24:27 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45842280/article/details/128364024
版权

目录

前言

  关于并发编程的更多内容我会在后续的实际开发中进行总结，然后分享给大家！接下来将会和大家一起学习C++的设计模式😷

一、设计模式简介

1. 什么是设计模式

  (1)设计模式 是 软件开发人员在软件开发过程中 面临的 一般问题的解决方案。

  (2)这些解决方案是众多软件开发人员经过 相当长的一段时间的 试验 和 错误总结出来的。

  (3)使用设计模式是为了重用代码、让代码更容易被他人理解、保证代码可靠性。

2. 设计模式分类

  设计模式提供了一种标准化的方法来处理软件设计中的问题，使得代码更加灵活、可维护和可重用。它们通常是在特定的上下文中应用，并在软件开发的不同阶段（如设计、编码、测试等）起到指导作用。

  设计模式有23种左右。设计模式一般分为以下几类：

  1. 创建型模式（Creational Patterns）：这些模式关注对象的创建过程，旨在将对象的创建与使用分离。常见的创建型模式包括(常用的是前三种)：

    • 单例模式（Singleton Pattern）：确保一个类只有一个实例，并提供全局访问点。
    • 工厂方法模式（Factory Method Pattern）：定义一个用于创建对象的接口，但由子类决定要实例化的类。
    • 抽象工厂模式（Abstract Factory Pattern）：提供一个创建一系列相关或互相依赖对象的接口，而无需指定具体类。
    • 建造者模式（Builder Pattern）：通过将一个复杂对象的构建过程与它的表示分离，来构建一个复杂对象。
    • 原型模式（Prototype Pattern）：通过复制现有的实例来创建新实例，而不是通过构造函数。

  2. 结构型模式（Structural Patterns）：这些模式关注类和对象的组合，帮助确保系统中的组件可以组合成更复杂的结构。常见的结构型模式包括：

    • 适配器模式（Adapter Pattern）：将一个类的接口转换成客户端所期望的另一种接口。
    • 桥接模式（Bridge Pattern）：将抽象部分与它的实现部分分离，使它们可以独立变化。
    • 装饰器模式（Decorator Pattern）：动态地给一个对象添加一些额外的职责。
    • 外观模式（Facade Pattern）：为子系统中的一组接口提供一个一致的界面，使子系统更易使用。
    • 享元模式（Flyweight Pattern）：通过共享大量细粒度的对象来有效地支持大量的对象。
    • 组合模式（Composite Pattern）：将对象组合成树形结构以表示部分-整体层次结构。

  3. 行为型模式（Behavioral Patterns）：这些模式关注对象之间的交互和职责分配。关注对象之间的通信，譬如将行为、数据、展示拆分又互相通信的MVC架构，经典MVC模式中，M是指业务模型，V是指用户界面，C则是控制器，使用MVC的目的是将M和V的实现代码分离，从而使同一个程序可以使用不同的表现形式。其中，View的定义比较清晰，就是用户界面。
    常见的行为型模式包括：

    • 策略模式（Strategy Pattern）：定义一系列算法，将每一个算法封装起来，并使它们可以互相替换。
    • 观察者模式（Observer Pattern）：定义对象间一对多的依赖关系，以便当一个对象的状态改变时，所有依赖于它的对象都会得到通知并自动更新。
    • 迭代器模式（Iterator Pattern）：提供一种方法顺序访问一个集合对象中的各个元素，而不暴露该对象的内部表示。
    • 模板方法模式（Template Method Pattern）：定义一个操作中的算法的骨架，而将一些步骤延迟到子类中。
    • 状态模式（State Pattern）：允许一个对象在其内部状态改变时改变它的行为。
    • 命令模式（Command Pattern）：将请求封装为一个对象，从而使你可以用不同的请求对客户进行参数化、排队请求或记录请求日志。
    • 责任链模式（Chain of Responsibility Pattern）：使多个对象有机会处理请求，从而避免请求发送者和接收者之间的耦合。

  框架、设计模式这两个概念总容易被混淆，其实它们之间还是有区别的。框架通常是代码重用，而设计模式是设计重用，架构则介于两者之间，部分代码重用，部分设计重用，有时分析也可重用。

  在软件生产中有三种级别的重用：（1）内部重用，即在同一应用中能公共使用的抽象块;（2）代码重用，即将通用模块组合成库或工具集，以便在多个应用和领域都能使用；（2）应用框架的重用，即为专用领域提供通用的或现成的基础结构，以获得最高级别的重用性。

3. 设计模式的优点

  • 提高代码复用：通过模式化的解决方案，可以在不同的项目中重复使用相同的设计。
  • 提高代码灵活性：设计模式使系统具有更好的扩展性和灵活性，便于在需求变化时进行调整。
  • 促进团队合作：标准化的设计模式可以让团队成员更容易理解和维护代码，提高团队的沟通效率。
  • 简化设计过程：通过提供通用的解决方案，设计模式可以帮助开发人员解决复杂的设计问题。
  • 开发人员的共同平台：提供了一个标准的术语系统，且具体到特定的情景。例如，单例设计模式意味着使用单个对象，这样所有熟悉单例设计模式的开发人员都能使用单个对象，并且可以通过这种方式告诉对方，程序使用的是单例模式。
  • 最佳的实践：设计模式已经经历了很长一段时间的发展，它们提供了软件开发过程中面临的一般问题的最佳解决方案。学习这些模式有助于经验不足的开发人员通过一种简单快捷的方式来学习软件设计。

4. 设计模式的实践

  • 学习经典书籍：如《设计模式：可复用面向对象软件的基础》（Erich Gamma 等著），这是设计模式的经典参考书。
  • 应用到实际项目中：在实际项目中尝试应用设计模式，逐步理解其优势和适用场景。
  • 分析开源项目：阅读和分析开源项目的设计，了解如何在实际中应用设计模式。

  分享下个人的一些资料：《23种设计模式(C++完整版).pdf》，来自于网络，链接如下

链接：https://pan.baidu.com/s/1M2A9S6WKJ3_7BZipYd1SzQ 
提取码：ch3q 
--来自百度网盘超级会员V6的分享

  程杰《大话设计模式》一书，使用JAVA编写示例程序，但是会C++的话，是可以看懂这些例程的，面向对象的这些语法二者很相似，我是买了一本二手书进行学习的。安利一个买正版二手书的微信小程序《多抓鱼》，不是广告，单纯觉得好用分享给大家
在这里插入图片描述

二、单例模式

  单例模式（Singleton Pattern）是一种设计模式，其主要目的是确保一个类只有一个实例，并提供全局访问点。它通常用于需要全局唯一实例的场景，比如数据库连接池、配置管理器等。

1. 单例模式的关键点

  • 唯一性: 确保类只有一个实例。
  • 全局访问: 提供全局访问点来获取该实例。
  • 延迟初始化: （可选）在第一次使用时才创建实例。

2. 单例模式的实现方式

  单例模式有多种实现方式，下面列出了几种常见的方法。

饿汉式单例（Eager Initialization）

  特点: 类加载时即创建实例，不管是否使用。简单且线程安全，但可能导致资源浪费。

class Singleton {
public:
    static Singleton* getInstance() {
        return instance;
    }

private:
    Singleton() {}
    static Singleton* instance;
};

// 类加载时即创建实例
Singleton* Singleton::instance = new Singleton();

懒汉式单例（Lazy Initialization）

  特点: 在第一次使用时创建实例。需要注意线程安全问题。

class Singleton {
public:
    static Singleton* getInstance() {
        if (instance == nullptr) {
            instance = new Singleton();
        }
        return instance;
    }

private:
    Singleton() {}
    static Singleton* instance;
};

// 类外定义静态成员
Singleton* Singleton::instance = nullptr;

双重检查锁定（Double-Checked Locking）

  特点: 在懒汉式基础上加锁，避免了多线程环境下的同步开销。

#include <mutex>

class Singleton {
public:
    static Singleton* getInstance() {
        if (instance == nullptr) {
            std::lock_guard<std::mutex> lock(mutex);
            if (instance == nullptr) {
                instance = new Singleton();
            }
        }
        return instance;
    }

private:
    Singleton() {}
    static Singleton* instance;
    static std::mutex mutex;
};

// 类外定义静态成员
Singleton* Singleton::instance = nullptr;
std::mutex Singleton::mutex;

登记式单例（Registry-based Singleton）

  特点: 使用静态成员注册实例，避免了静态初始化顺序问题，但有额外的复杂性。

#include <map>
#include <string>

class Singleton {
public:
    static Singleton* getInstance(const std::string& name) {
        if (instances.find(name) == instances.end()) {
            instances[name] = new Singleton();
        }
        return instances[name];
    }

private:
    Singleton() {}
    static std::map<std::string, Singleton*> instances;
};

// 类外定义静态成员
std::map<std::string, Singleton*> Singleton::instances;

枚举式单例（Enum-based Singleton）

  特点: 使用枚举类创建单例，线程安全且简单，但不支持延迟初始化。

#include <iostream>

class Singleton {
public:
    // 获取单例实例
    static Singleton& getInstance() {
        return instance;
    }

    // 示例方法
    void showMessage() const {
        std::cout << "Hello, Singleton!" << std::endl;
    }

private:
    // 构造函数是私有的，防止直接创建实例
    Singleton() {
        std::cout << "Singleton instance created." << std::endl;
    }

    // 析构函数是私有的，防止删除实例
    ~Singleton() {
        std::cout << "Singleton instance destroyed." << std::endl;
    }

    // 删除拷贝构造函数和赋值操作符
    Singleton(const Singleton&) = delete;
    Singleton& operator=(const Singleton&) = delete;

    // 枚举成员，强制创建单例实例
    enum { InstanceID };
    static Singleton instance;
};

// 静态成员初始化
Singleton Singleton::instance;

int main() {
    // 获取单例实例
    Singleton& singleton1 = Singleton::getInstance();
    singleton1.showMessage();

    // 尝试获取另一个单例实例
    Singleton& singleton2 = Singleton::getInstance();
    singleton2.showMessage();

    // 检查两个实例是否相同
    if (&singleton1 == &singleton2) {
        std::cout << "Both instances are the same." << std::endl;
    } else {
        std::cout << "Instances are different." << std::endl;
    }

    return 0;
}

3. 单例模式的优缺点

优点:

  1. 节省资源: 确保只有一个实例，避免了多次创建。
  2. 全局访问: 提供了全局访问点，方便管理。

缺点:

  1. 难以测试: 单例模式会使得单元测试变得复杂，因为它在多个测试中共享状态。
  2. 线程安全问题: 在多线程环境中，需要特别注意线程安全。
  3. 违背单一职责原则: 单例类同时负责创建和管理自身实例，可能导致设计上的问题。

总的来说，单例模式在适当的场景下非常有效，但需要谨慎使用，特别是在多线程和测试方面。

4. 示例程序

  单例模式（Singleton Pattern）确保一个类只有一个实例，并提供一个全局访问点。以下是一个使用 C++ 实现单例模式的完美示例代码：

#include <iostream>
#include <mutex>

class Singleton {
public:
    // 删除拷贝构造函数和赋值操作符，以防止复制
    Singleton(const Singleton&) = delete;
    Singleton& operator=(const Singleton&) = delete;

    // 获取 Singleton 实例的静态方法
    static Singleton& getInstance() {
        static Singleton instance; // 局部静态变量，保证线程安全
        return instance;
    }

    // 示例方法
    void showMessage() const {
        std::cout << "Hello, Singleton!" << std::endl;
    }

private:
    // 构造函数是私有的，防止直接创建实例
    Singleton() {
        std::cout << "Singleton instance created." << std::endl;
    }

    // 析构函数是私有的，防止删除实例
    ~Singleton() {
        std::cout << "Singleton instance destroyed." << std::endl;
    }
};

int main() {
    // 获取单例实例
    Singleton& singleton1 = Singleton::getInstance();
    singleton1.showMessage();

    // 尝试获取另一个单例实例
    Singleton& singleton2 = Singleton::getInstance();
    singleton2.showMessage();

    // 检查两个实例是否相同
    if (&singleton1 == &singleton2) {
        std::cout << "Both instances are the same." << std::endl;
    } else {
        std::cout << "Instances are different." << std::endl;
    }

    return 0;
}
  • 构造函数和析构函数：构造函数和析构函数是私有的，这样可以防止外部直接创建或销毁实例。
  • 静态方法 getInstance：这是获取单例实例的唯一方法。静态局部变量 instance 确保在程序生命周期内只有一个 Singleton 实例。这个静态变量会在第一次调用 getInstance时创建，并在程序结束时自动销毁。
  • 删除拷贝构造函数和赋值操作符：为了防止拷贝和赋值操作，我们将拷贝构造函数和赋值操作符声明为 delete。
  • 线程安全：在 C++11 及以后的版本中，局部静态变量的初始化是线程安全的，因此我们不需要额外的同步机制。对于旧版本的 C++，可以使用互斥量来确保线程安全。

示例程序运行结果：

Singleton instance created.
Hello, Singleton!
Hello, Singleton!
Both instances are the same.

  这个示例展示了单例模式的核心要点，并确保了代码的线程安全性和实例唯一性。

三、工厂模式

  工厂模式是一种创建对象的设计模式，旨在通过提供一个创建对象的接口，使得子类可以决定实例化的类。工厂模式可以分为几个主要类型：简单工厂模式、工厂方法模式和抽象工厂模式。以下是对这些模式的详细介绍：

1. 简单工厂模式

  简单工厂模式通过一个工厂类负责创建不同类型的对象，客户端只需调用工厂方法，而不需要知道具体类的实现。

特点：

  • 封装对象创建：客户端只需了解工厂接口，而不需要了解具体的类。
  • 降低系统耦合度：客户端与具体产品解耦，便于维护和扩展。

示例代码：

  假设我们要创建一个简单的文档管理系统，其中有两种类型的文档：PDFDocument 和 WordDocument。我们可以使用简单工厂模式来创建这些文档。

#include <iostream>
#include <string>

//定义产品接口->定义工厂类->使用工厂类

//1、首先，我们定义一个文档接口 `Document`，以及两个具体的文档类 `PDFDocument` 和 `WordDocument`
// 产品接口
class Document {
public:
    virtual void open() const = 0; // 打开文档
    virtual ~Document() = default;
};

// 具体产品：PDF 文档
class PDFDocument : public Document {
public:
    void open() const override {
        std::cout << "Opening PDF document" << std::endl;
    }
};

// 具体产品：Word 文档
class WordDocument : public Document {
public:
    void open() const override {
        std::cout << "Opening Word document" << std::endl;
    }
};

//2、接着，我们定义一个工厂类 `DocumentFactory`，它负责根据类型创建不同的文档实例。
// 工厂类
class DocumentFactory {
public:
    // 工厂方法：根据文档类型创建相应的文档对象
    static Document* createDocument(const std::string& type) {
        if (type == "PDF") {
            return new PDFDocument();
        } else if (type == "Word") {
            return new WordDocument();
        } else {
            std::cerr << "Error: Unsupported document type" << std::endl;
            return nullptr;
        }
    }
};

//最后，我们在客户端代码中使用 `DocumentFactory` 来创建和操作文档对象。
int main() {
    // 创建 PDF 文档
    Document* pdfDoc = DocumentFactory::createDocument("PDF");
    if (pdfDoc) {
        pdfDoc->open();
        delete pdfDoc; // 记得释放内存
    }

    // 创建 Word 文档
    Document* wordDoc = DocumentFactory::createDocument("Word");
    if (wordDoc) {
        wordDoc->open();
        delete wordDoc; // 记得释放内存
    }

    // 尝试创建不支持的文档类型
    Document* unknownDoc = DocumentFactory::createDocument("Unknown");
    if (unknownDoc) {
        unknownDoc->open();
        delete unknownDoc; // 不会被调用，因为创建失败
    }

    return 0;
}
  • 产品接口 (Document): 定义了文档的基本操作 open()，确保所有具体产品都实现这个接口。
  • 具体产品 (PDFDocument 和 WordDocument): 实现了 Document 接口的具体文档类型。
  • 工厂类 (DocumentFactory): 提供静态方法 createDocument 来创建不同类型的文档实例，并根据类型选择具体的产品。
  • 客户端代码: 通过调用 DocumentFactory::createDocument 来获取所需的文档实例，并调用其方法。注意，客户端代码负责释放创建的文档对象以防内存泄漏。

  这个示例展示了如何使用简单工厂模式来管理对象的创建，隐藏了具体的类实现细节，使得客户端代码与具体的产品解耦。

缺点：

  • 违反开放-关闭原则：新增产品时需要修改工厂类。
  • 产品等级过多：工厂类可能变得庞大复杂。

2. 工厂方法模式

  工厂方法模式通过定义一个接口来创建对象，而将具体的创建过程延迟到子类中。每个子类负责自己的产品创建。

特点：

  • 遵循开放-关闭原则：可以通过增加新的工厂子类来支持新的产品，而不需修改现有代码。
  • 增加灵活性和扩展性：各个具体工厂之间的依赖较小。

示例代码：

  假设我们仍然使用文档管理系统的例子，但这次我们将使用工厂方法模式来创建文档。我们会定义一个工厂接口，每个具体的工厂子类负责创建特定类型的文档。

#include <iostream>
#include <string>

//定义产品接口->定义工厂接口->定义具体工厂->使用工厂方法模式

//1、首先，我们定义一个文档接口 Document，以及两个具体的文档类 PDFDocument 和 WordDocument。
// 产品接口
class Document {
public:
    virtual void open() const = 0; // 打开文档
    virtual ~Document() = default;
};

// 具体产品：PDF 文档
class PDFDocument : public Document {
public:
    void open() const override {
        std::cout << "Opening PDF document" << std::endl;
    }
};

// 具体产品：Word 文档
class WordDocument : public Document {
public:
    void open() const override {
        std::cout << "Opening Word document" << std::endl;
    }
};

//2、定义一个抽象的工厂接口 `DocumentFactory`，声明一个工厂方法 `createDocument`，用于创建
// `Document` 对象。
// 工厂接口
class DocumentFactory {
public:
    virtual Document* createDocument() const = 0; // 工厂方法
    virtual ~DocumentFactory() = default;
};

//3、实现具体的工厂类，每个工厂负责创建特定类型的文档。
// 具体工厂：PDF 文档工厂
class PDFDocumentFactory : public DocumentFactory {
public:
    Document* createDocument() const override {
        return new PDFDocument();
    }
};

// 具体工厂：Word 文档工厂
class WordDocumentFactory : public DocumentFactory {
public:
    Document* createDocument() const override {
        return new WordDocument();
    }
};

//4、在客户端代码中，使用不同的工厂来创建和操作不同类型的文档。
int main() {
    // 创建 PDF 文档的工厂
    DocumentFactory* pdfFactory = new PDFDocumentFactory();
    Document* pdfDoc = pdfFactory->createDocument();
    if (pdfDoc) {
        pdfDoc->open();
        delete pdfDoc; // 记得释放内存
    }
    delete pdfFactory; // 释放工厂对象

    // 创建 Word 文档的工厂
    DocumentFactory* wordFactory = new WordDocumentFactory();
    Document* wordDoc = wordFactory->createDocument();
    if (wordDoc) {
        wordDoc->open();
        delete wordDoc; // 记得释放内存
    }
    delete wordFactory; // 释放工厂对象

    return 0;
}
  • 产品接口 (Document): 定义了文档的基本操作 open()。
  • 具体产品 (PDFDocument 和 WordDocument): 实现了 Document 接口的具体文档类型。
  • 工厂接口 (DocumentFactory): 声明了一个工厂方法 createDocument，用于创建 Document 对象。
  • 具体工厂 (PDFDocumentFactory 和 WordDocumentFactory): 实现了工厂接口，提供具体的产品实例。
  • 客户端代码: 使用具体的工厂来创建文档对象，并调用其方法。客户端代码只依赖于工厂接口，而不关心具体的文档类型，实现了高度的解耦。

  通过工厂方法模式，你可以轻松扩展支持更多类型的文档，只需要增加新的产品和对应的工厂类，而不需要修改客户端代码。这种方式提高了系统的可扩展性和灵活性。

3. 抽象工厂模式

  抽象工厂模式提供一个接口，用于创建相关或依赖的对象，而无需指定具体类。它一般用于创建一系列相关联的产品。

特点：

  • 可以创建一组相关的产品：产品之间有一定的关系，如同一个系列的 GUI 组件。
  • 遵循开放-关闭原则：可以添加新的产品系列，而无需修改现有代码。

示例代码1：

// 产品接口
class Button {
public:
    virtual void render() = 0;
};

class WinButton : public Button {
public:
    void render() override {
        // Windows 风格按钮
    }
};

class MacButton : public Button {
public:
    void render() override {
        // Mac 风格按钮
    }
};

class Checkbox {
public:
    virtual void paint() = 0;
};

class WinCheckbox : public Checkbox {
public:
    void paint() override {
        // Windows 风格复选框
    }
};

class MacCheckbox : public Checkbox {
public:
    void paint() override {
        // Mac 风格复选框
    }
};

// 抽象工厂
class GUIFactory {
public:
    virtual Button* createButton() = 0;
    virtual Checkbox* createCheckbox() = 0;
};

// 具体工厂
class WinFactory : public GUIFactory {
public:
    Button* createButton() override {
        return new WinButton();
    }

    Checkbox* createCheckbox() override {
        return new WinCheckbox();
    }
};

class MacFactory : public GUIFactory {
public:
    Button* createButton() override {
        return new MacButton();
    }

    Checkbox* createCheckbox() override {
        return new MacCheckbox();
    }
};

// 使用
GUIFactory* factory = new WinFactory();
Button* button = factory->createButton();
button->render();

示例代码2：

#include <iostream>
#include <string>

//定义产品接口->定义抽象工厂接口->定义具体工厂->使用抽象工厂模式

//1、首先，我们定义两个产品接口：`Document` 和 `DocumentView`，以及它们的具体实现。
// 文档接口
class Document {
public:
    virtual void open() const = 0; // 打开文档
    virtual ~Document() = default;
};

// 视图接口
class DocumentView {
public:
    virtual void render() const = 0; // 渲染视图
    virtual ~DocumentView() = default;
};

// 具体产品：PDF 文档
class PDFDocument : public Document {
public:
    void open() const override {
        std::cout << "Opening PDF document" << std::endl;
    }
};

// 具体产品：Word 文档
class WordDocument : public Document {
public:
    void open() const override {
        std::cout << "Opening Word document" << std::endl;
    }
};

// 具体视图：PDF 视图
class PDFDocumentView : public DocumentView {
public:
    void render() const override {
        std::cout << "Rendering PDF view" << std::endl;
    }
};

// 具体视图：Word 视图
class WordDocumentView : public DocumentView {
public:
    void render() const override {
        std::cout << "Rendering Word view" << std::endl;
    }
};

//2、接着，我们定义一个抽象工厂接口 `DocumentFactory`，用于创建一系列相关的文档和视图对象。
// 抽象工厂接口
class DocumentFactory {
public:
    virtual Document* createDocument() const = 0; // 创建文档
    virtual DocumentView* createView() const = 0;  // 创建视图
    virtual ~DocumentFactory() = default;
};

//3、实现具体的工厂类，每个工厂负责创建特定类型的文档和视图对象。
// 具体工厂：PDF 工厂
class PDFFactory : public DocumentFactory {
public:
    Document* createDocument() const override {
        return new PDFDocument();
    }
    
    DocumentView* createView() const override {
        return new PDFDocumentView();
    }
};

// 具体工厂：Word 工厂
class WordFactory : public DocumentFactory {
public:
    Document* createDocument() const override {
        return new WordDocument();
    }
    
    DocumentView* createView() const override {
        return new WordDocumentView();
    }
};

//4、在客户端代码中，使用不同的工厂来创建和操作不同类型的文档和视图。
int main() {
    // 创建 PDF 工厂
    DocumentFactory* pdfFactory = new PDFFactory();
    Document* pdfDoc = pdfFactory->createDocument();
    DocumentView* pdfView = pdfFactory->createView();
    if (pdfDoc) {
        pdfDoc->open();
        delete pdfDoc; // 记得释放内存
    }
    if (pdfView) {
        pdfView->render();
        delete pdfView; // 记得释放内存
    }
    delete pdfFactory; // 释放工厂对象

    // 创建 Word 工厂
    DocumentFactory* wordFactory = new WordFactory();
    Document* wordDoc = wordFactory->createDocument();
    DocumentView* wordView = wordFactory->createView();
    if (wordDoc) {
        wordDoc->open();
        delete wordDoc; // 记得释放内存
    }
    if (wordView) {
        wordView->render();
        delete wordView; // 记得释放内存
    }
    delete wordFactory; // 释放工厂对象

    return 0;
}
  • 产品接口 (Document 和 DocumentView): 定义了文档和视图的基本操作。
  • 具体产品 (PDFDocument、WordDocument、PDFDocumentView 和 WordDocumentView): 实现了这些接口的具体类。
  • 抽象工厂接口 (DocumentFactory): 定义了创建相关产品的方法 createDocument 和 createView。
  • 具体工厂 (PDFFactory 和 WordFactory): 实现了抽象工厂接口，负责创建特定类型的文档和视图。
  • 客户端代码: 通过工厂接口创建不同类型的文档和视图，确保了产品之间的兼容性和一致性。

  通过抽象工厂模式，客户端代码可以在不改变现有代码的情况下，灵活地添加新的文档和视图类型，同时保持了创建过程的一致性。这种模式提高了系统的可扩展性和灵活性。

4. 使用场景

  • 简单工厂模式：适用于产品类型有限、变化较小的场合。
  • 工厂方法模式：适合于产品种类较多，经常需要扩展的情况，支持可扩展设计。
  • 抽象工厂模式：适用于需要创建一系列相关产品的场景，如跨平台 GUI 系统等。

工厂方法模式 vs. 抽象工厂模式关键差异：

  1. 单一 vs. 多重产品:

    • 工厂方法模式: 主要用于创建单个产品类型的实例，适用于需要灵活地引入新的产品类型的场景。
    • 抽象工厂模式: 用于创建多个相关的产品实例，适用于需要管理一系列产品（例如，多个产品族）的场景。

  2. 工厂层次:

    • 工厂方法模式: 每个工厂方法只能创建一个产品，客户端代码依赖于具体工厂来获得不同的产品实例。
    • 抽象工厂模式: 工厂接口提供了创建一系列相关产品的方法，客户端可以使用不同的抽象工厂来创建一系列产品，保证产品的兼容性。

  3. 扩展性:

    • 工厂方法模式: 适合扩展单个产品的不同变体。
    • 抽象工厂模式: 适合扩展多个产品族，确保各个产品之间的一致性。

  总的来说，抽象工厂模式确实可以被看作是工厂方法模式的一个扩展，它在工厂方法模式的基础上增加了处理多个产品族的能力，使得系统能够更好地处理复杂的产品创建需求。

5. 总结

  工厂模式通过将对象创建的逻辑与使用逻辑分离，提高了代码的可维护性和灵活性。根据需求的复杂性，可以选择不同类型的工厂模式来实现创造性和解耦设计。适当使用工厂模式可以极大地减少代码的耦合度和复杂度。

注：水平有限，欢迎各位在评论区指导交流！！！😁😁😁

小嵌同学
关注
专栏目录
《C++ 设计模式》
青春不老，奋斗不止！
02-09 9万+
设计模式代表了最佳的实践，在面向对象的编程中被很多老鸟们反复使用。使用设计模式有很多好处：可重用代码、保证代码可靠性、使代码更易被他人理解 ......
Python程序设计 第1章：初识Python
惊鸿若梦一书生
01-11 6243
Python是当今主流的编程语言，无论是Web开发、科学计算、数据分析、游戏开发、机器学习、爬虫、计算机视觉等等很多领域都在用这个编程语言。（1）Web开发。Python是Web开发的主流语言，与JS、PHP等广泛使用的语言相比，Python的类库丰富、使用方便，能够为一个需求提供多种方案；此外Python支持最新的XML技术，具有强大的数据处理能力，因此Python在Web开发中占有一席之地。Python为Web开发领域提供的框架有django、flask、tornado、web2py等。（2）
设计模式-工厂模式 C++
ymhdt的博客
03-31 514
工厂模式属于一种创建型模式，它提供一种创建对象的最佳方式，对外不暴露对象的创建模式，并且通过一个共同的接口获取对象指针。
C++：23种设计模式
最新发布
weixin_53442127的博客
08-05 2362
设计模式是软件设计中常用的解决方案，分为三大类：创建型模式、结构型模式和行为型模式。以下是23种设计模式的简要介绍和C++代码示例。提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。public:public:public:public:public:public:设计模式是软件工程中的一种最佳实践，它们提供了在特定情境下解决常见设计问题的模板。设计模式分为三大类：创建型模式、结构型模式和行为型模式。
设计模式-C++
09-01
创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。 结构型模式，共七种：适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。 行为型模式，共十一种：策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。
设计模式c++
sun007700的专栏
11-01 154
https://www.cnblogs.com/chengjundu/p/8473564.html
初识C语言
qq_44140010的博客
06-10 3668
初识C语言
Primer c++ 第5版pdf
qq_43679402的博客
11-14 1717
Primer c++ 第5版pdf
开发知识点-C++入门到入土知识手册
aming小老弟
10-18 939
指针经典笔试题练习题讲解typedef笔试题多个源文件-理论多个源文件-实践PBC++简述C++标准C++的应用场景第一个C++程序const修饰普通变量const修饰成员变量const修饰成员函数const修饰对象const修饰引用onst修饰函数返回值为普通变量和对象const修饰函数返回值为const的指针const修饰函数返回值为const的引用extern c的使用_cplusplus的使用string对象的构造方法string对象的赋值。
初识JMS 与 activeMq
weixin_40210774的博客
03-08 179
一、JMS概念 JMS即Java消息服务（Java Message Service）应用程序接口，是一个Java平台中关于面向消息中间件（MOM）的API，用于在两个应用程序之间，或分布式系统中发送消息，进行异步通信。Java消息服务是一个与具体平台无关的API，绝大多数MOM提供商都对JMS提供支持。 JMS是一种与厂商无关的 API，用来访问收发系统消息，它类似于 JDBC(J...
设计模式（C++）
pzs0221的专栏
12-19 1134
23种设计模式：
设计模式（c++）
weixin_42952928的博客
06-25 183
prototype（原型）——对象创建型模式意图新的改变功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 意图 用原型实例指定创建对象的种类，并通过拷贝这些原型创建新的对象 新的改变 我们对Markdown编辑器进行了一些功能拓展与
C++ 常用设计模式(学习笔记)
duchengjun的博客
06-11 1421
设计模式 1、工厂模式 在工厂模式中，我们在创建对象时不会对客户端暴露创建逻辑，并且是通过使用一个共同的接口来指向新创建的对象。工厂模式作为一种创建模式，一般在创建复杂对象时，考虑使用；在创建简单对象时，建议直接new完成一个实例对象的创建。 1.1、简单工厂模式 主要特点是需要在工厂类中做判断，从而创造相应的产品，当增加新产品时，需要修改工厂类。使用简单工厂模式，我们只需要知道具体的产品型号就可...
设计模式C++
Overvautious的博客
03-23 108
装饰者模式 装饰者模式，类比生活中的例子：人感觉到冷的时候，会穿衣服，觉得热的时候，就会脱掉衣服。所以可以拥有多件衣服达到一个组合的效果，装饰者就是类似 参考：装饰器模式(Decorator) C++ 装饰器模式的优点： 1、可以轻松对已存在的对象进行修改和包装，在被装饰者的前面或者后面添加自己的行为，而无需修改原对象。 2、可以动态、不限量地进行装饰，可以更灵活地扩展功能。 相对地，装饰器模式有很明显的缺点： 1、会加入大量的小类，即使只添加一个功能，也要额外创建一个类，使得程序更复杂。 2、增加代码复杂
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

小嵌同学

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值