C++中的设计模式：掌握编程思想与实践的高级技巧

# 1. 设计模式概述

设计模式是软件工程领域中一种被广泛接受的解决特定问题的最佳实践。它们不仅提供了通用的术语和模板，而且帮助开发者在项目中构建出更可维护和可扩展的系统。

设计模式可以分为三类：创建型模式、结构型模式和行为型模式。创建型模式涉及到对象的创建过程，隐藏创建逻辑，而不仅仅提供创建对象的接口。结构型模式关注类和对象的组合，旨在构建复杂的结构，同时保持系统的灵活性和效率。行为型模式关注对象间的职责分配和通信。

设计模式的采用有助于提高代码的复用性，降低系统的复杂度，并让代码易于理解和维护。本章旨在为读者提供设计模式的理论基础，为后续章节中对各种模式的深入探讨打下坚实的基础。

# 2. 创建型模式的理论与实践

## 2.1 单例模式

### 2.1.1 单例模式的原理

单例模式是一种创建型设计模式，旨在确保一个类只有一个实例，并提供一个全局访问点。这种模式在需要确保全局只有一个访问点时非常有用，比如日志记录器、线程池、配置管理器等。

单例模式的实现通常包括以下几个要素：

- 私有的构造函数，确保不能从外部通过new来创建类的实例。
- 一个指向唯一实例的私有静态引用。
- 一个公有的静态方法，当被调用时，返回这个唯一实例。

单例模式的实现必须考虑线程安全问题，以确保多线程环境下不会创建多个实例。

### 2.1.2 单例模式的应用案例

例如，考虑一个数据库连接池类，我们不希望创建多个连接池实例，因为这会导致资源的浪费和潜在的连接冲突。通过单例模式，我们可以确保整个应用程序只有一个数据库连接池实例在运行。

class DatabaseConnectionPool {
private:
    static DatabaseConnectionPool* instance;
    static std::mutex mtx;

    DatabaseConnectionPool() = default; // 私有构造函数
    ~DatabaseConnectionPool() = default; // 私有析构函数

public:
    DatabaseConnectionPool(DatabaseConnectionPool const&) = delete; // 禁止拷贝
    DatabaseConnectionPool& operator=(DatabaseConnectionPool const&) = delete; // 禁止赋值

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

    void connect() {
        // 连接数据库的逻辑
    }

    void disconnect() {
        // 断开数据库连接的逻辑
    }
};

// 初始化
DatabaseConnectionPool* DatabaseConnectionPool::instance = nullptr;
std::mutex DatabaseConnectionPool::mtx;

在上述代码中，我们定义了一个`DatabaseConnectionPool`类，并将其构造函数设为私有，以防止在类的外部被实例化。我们使用一个静态私有指针`instance`来存储唯一的实例，并通过静态方法`getInstance()`来获取这个实例。为了处理多线程的情况，我们在创建实例之前使用了互斥锁`mtx`，确保在多线程环境下只有一个实例被创建。

## 2.2 工厂方法模式

### 2.2.1 工厂方法模式的定义与结构

工厂方法模式是一种创建型设计模式，它定义了一个创建对象的接口，但由子类决定实例化哪一个类。工厂方法将创建对象的工作委托给子类，这样可以解耦产品类和工厂类。

工厂方法模式通常包含以下角色：

- 抽象工厂（Creator）：声明工厂方法，返回一个产品。
- 具体工厂（Concrete Creator）：实现工厂方法以创建具体产品的对象。
- 抽象产品（Product）：为一类产品对象声明一个接口。
- 具体产品（Concrete Product）：是抽象产品的具体实现。

### 2.2.2 工厂方法模式的实际应用

例如，一个GUI应用中需要创建不同类型的按钮，如WindowsButton和MacButton，工厂方法模式可以帮助我们根据不同的操作系统来创建相应的按钮实例。

class Button {
public:
    virtual void render() = 0; // 纯虚函数，确保派生类重写
    virtual ~Button() {} // 虚析构函数
};

class WindowsButton : public Button {
public:
    void render() override {
        std::cout << "Rendering a Windows button." << std::endl;
    }
};

class MacButton : public Button {
public:
    void render() override {
        std::cout << "Rendering a Mac button." << std::endl;
    }
};

class ButtonFactory {
public:
    virtual Button* createButton() = 0;
    virtual ~ButtonFactory() {}
};

class WindowsButtonFactory : public ButtonFactory {
public:
    Button* createButton() override {
        return new WindowsButton();
    }
};

class MacButtonFactory : public ButtonFactory {
public:
    Button* createButton() override {
        return new MacButton();
    }
};

在上述示例中，我们创建了一个抽象的`Button`基类和两个具体的产品类`WindowsButton`和`MacButton`。对应的，我们还有抽象工厂类`ButtonFactory`和两个具体工厂类`WindowsButtonFactory`和`MacButtonFactory`。客户端代码通过调用具体工厂类的`createButton`方法来获取按钮实例，从而实现具体产品的创建。

## 2.3 抽象工厂模式

### 2.3.1 抽象工厂模式的特点与组成

抽象工厂模式是一种创建型设计模式，它提供了一种方式，可以创建一系列相关或相互依赖的对象，而无需指定它们具体的类。抽象工厂模式允许客户端使用抽象的接口来创建一组相关的产品族中的对象，而不需要关心这些对象的具体类。

抽象工厂模式通常包含以下角色：

- 抽象工厂（Abstract Factory）：声明创建一系列产品的接口。
- 具体工厂（Concrete Factory）：实现创建具体产品的方法。
- 抽象产品（Abstract Product）：为产品族中的每种产品声明接口。
- 具体产品（Concrete Product）：为具体的产品族实现接口。

### 2.3.2 抽象工厂模式在项目中的应用

例如，考虑一个图形用户界面库，该库需要支持多种外观风格，比如“暗色模式”和“亮色模式”。使用抽象工厂模式，我们可以为每种风格创建一个具体的工厂，用于生产对应的按钮、文本框等界面元素。

class Button {
public:
    virtual void render() = 0; // 渲染按钮
    virtual ~Button() {}
};

class TextField {
public:
    virtual void render() = 0; // 渲染文本框
    virtual ~TextField() {}
};

class DarkThemeFactory : public AbstractFactory {
public:
    Button* createButton() override {
        return new DarkButton();
    }
    TextField* createTextField() override {
        return new DarkTextField();
    }
};

class LightThemeFactory : public AbstractFactory {
public:
    Button* createButton() override {
        return new LightButton();
    }
    TextField* createTextField() override {
        return new LightTextField();
    }
};

// 客户端代码
int main() {
    AbstractFactory* factory = nullptr;

    // 根据用户偏好选择具体的工厂
    bool darkTheme = true; // 示例条件
    if (darkTheme) {
        factory = new DarkThemeFactory();
    } else {
        factory = new LightThemeFactory();
    }

    // 使用工厂创建产品
    Button* button = factory->createButton();
    TextField* textField = factory->createTextField();

    // 渲染产品
    button->render();
    textField->render();

    // 清理资源
    delete button;
    delete textField;
    delete factory;

    return 0;
}

在上述示例中，`DarkThemeFactory`和`LightThemeFactory`是两个具体工厂，它们分别创建了对应风格的按钮和文本框对象。客户端代码可以根据条件（如用户偏好）来决定使用哪个工厂，然后通过工厂创建出一系列相关的产品。这样，整个应用就可以具有一致的外观风格，而不需要关心具体产品的实现细节。

## 2.4 建造者模式

### 2.4.1 建造者模式的基本概念

建造者模式是一种创建型设计模式，它允许将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。该模式特别适用于那些对象的创建过程必须允许被构造的复杂对象有不同的表示。

建造者模