C++开发中的常用设计模式：深入解析与应用场景

在C++这类强大的系统级编程语言中，设计模式并非空中楼阁的理论，而是解决特定复杂工程问题的利器。它们提供了经过验证的最佳实践方案，能够显著提升代码的可维护性、可扩展性、复用性和灵活性。本文将深入探讨C++开发中最常用的一些设计模式，并结合具体场景说明它们解决了什么问题。

1. 单例模式 (Singleton Pattern)

核心思想：确保一个类只有一个实例，并提供一个全局访问点。

解决的问题：

• 资源冲突：避免多个实例竞争同一份稀缺资源（如配置文件、日志文件、线程池、数据库连接池等）。
• 全局状态管理：为需要在整个应用程序中访问的状态或服务提供一个统一的、受控的访问入口，而不是使用全局变量（这违背了OOP的封装原则）。

C++特色实现（Meyers’ Singleton）：
利用局部静态变量的特性，这是C++11及以后版本中线程安全且最简洁优雅的实现方式。

class DatabaseConnectionPool {
public:
    // 删除拷贝构造函数和赋值操作符，确保唯一性
    DatabaseConnectionPool(const DatabaseConnectionPool&) = delete;
    DatabaseConnectionPool& operator=(const DatabaseConnectionPool&) = delete;

    // 全局访问点
    static DatabaseConnectionPool& getInstance() {
        static DatabaseConnectionPool instance; // C++11保证线程安全
        return instance;
    }

    // 其他业务方法
    Connection getConnection() { /* ... */ }
    void releaseConnection(Connection conn) { /* ... */ }

private:
    // 私有化构造函数，防止外部创建
    DatabaseConnectionPool() { /* 初始化连接池 */ }
    ~DatabaseConnectionPool() { /* 清理资源 */ }

    // ... 其他成员数据 ...
};

// 使用示例
auto& pool = DatabaseConnectionPool::getInstance();
auto conn = pool.getConnection();
// ... 使用连接 ...
pool.releaseConnection(conn);

应用场景：日志管理器、应用配置、硬件设备访问类（如唯一的打印机对象）。

2. 工厂模式 (Factory Pattern) & 抽象工厂模式 (Abstract Factory Pattern)

核心思想：将对象的创建逻辑与使用逻辑分离。客户端不关心对象的具体类型，只关心其接口。

解决的问题：

• 依赖耦合：new ConcreteClass() 会将客户端代码与具体实现类紧密耦合。添加新的类需要修改所有创建它的代码。
• 复杂创建过程：如果对象的创建过程非常复杂（需要配置、步骤繁多），工厂可以将其封装起来，保持客户端代码的简洁。

简单工厂示例：

class Button {
public:
    virtual void render() = 0;
    virtual ~Button() {}
};

class WindowsButton : public Button { void render() override { /* Windows风格按钮 */ } };
class LinuxButton : public Button { void render() override { /* Linux风格按钮 */ } };

class ButtonFactory {
public:
    static Button* createButton(const std::string& osType) {
        if (osType == "Windows") return new WindowsButton();
        else if (osType == "Linux") return new LinuxButton();
        return nullptr;
    }
};

// 使用
// 客户端代码只需要知道工厂和抽象接口，与具体按钮类解耦
Button* btn = ButtonFactory::createButton(getCurrentOS());
btn->render();
delete btn; // 可结合智能指针避免手动管理

应用场景：

• 跨平台UI库：根据当前操作系统创建风格一致的按钮、窗口等控件。
• 插件系统：根据配置文件动态加载和创建不同的插件对象。
• 连接器创建：创建不同类型的数据库连接、网络连接。

3. 观察者模式 (Observer Pattern)

核心思想：定义一种一对多的依赖关系，当一个对象（主题）的状态发生改变时，所有依赖于它的对象（观察者）都会自动得到通知并更新。

解决的问题：

• 紧耦合的通信：主题对象不需要知道谁需要通知，观察者也不需要一直轮询主题的状态。两者通过抽象接口交互，降低了耦合度。
• 动态联动：可以随时增加或删除观察者，系统扩展性极强。

C++现代实现（利用标准库）：

#include <iostream>
#include <vector>
#include <functional>
#include <algorithm>

// 主题（被观察者）
class Sensor {
public:
    using Callback = std::function<void(float)>;

    void registerCallback(Callback cb) {
        callbacks_.push_back(cb);
    }

    void unregisterCallback(Callback cb) {
        // 简化处理，实际可能需要更复杂的逻辑
        callbacks_.erase(std::remove(callbacks_.begin(), callbacks_.end(), cb), callbacks_.end());
    }

    void setTemperature(float temp) {
        temperature_ = temp;
        notify();
    }

private:
    void notify() {
        for (const auto& cb : callbacks_) {
            cb(temperature_);
        }
    }

    std::vector<Callback> callbacks_;
    float temperature_;
};

// 观察者（可以是任何可调用对象，如函数、lambda、成员函数）
class Display {
public:
    void update(float temp) {
        std::cout << "Temperature updated: " << temp << "°C\n";
    }
};

int main() {
    Sensor sensor;
    Display display;

    // 注册观察者（使用lambda捕获display对象）
    auto callback = [&display](float temp) { display.update(temp); };
    sensor.registerCallback(callback);

    sensor.setTemperature(23.5f); // 输出：Temperature updated: 23.5°C
    sensor.setTemperature(24.8f); // 输出：Temperature updated: 24.8°C

    return 0;
}

应用场景：GUI事件处理、实时数据监控（如股票价格）、发布/订阅消息系统、模型-视图-控制器（MVC）架构。

4. 策略模式 (Strategy Pattern)

核心思想：定义一系列算法，将它们一个个封装起来，并且使它们可以相互替换。策略模式让算法的变化独立于使用算法的客户。

解决的问题：

• 条件语句的泛滥：避免使用大量的 if-else 或 switch-case 来选择不同的算法行为，使得代码难以维护和扩展。
• 开闭原则：需要增加新算法时，只需添加新的策略类，而无需修改已有的上下文代码。

示例：排序策略

#include <vector>
#include <memory>

// 策略接口
class SortingStrategy {
public:
    virtual void sort(std::vector<int>& data) = 0;
    virtual ~SortingStrategy() = default;
};

// 具体策略A
class BubbleSort : public SortingStrategy {
public:
    void sort(std::vector<int>& data) override {
        std::cout << "Sorting using BubbleSort\n";
        // ... 实现冒泡排序 ...
    }
};

// 具体策略B
class QuickSort : public SortingStrategy {
public:
    void sort(std::vector<int>& data) override {
        std::cout << "Sorting using QuickSort\n";
        // ... 实现快速排序 ...
    }
};

// 上下文（Context）
class Sorter {
    std::unique_ptr<SortingStrategy> strategy_;
public:
    void setStrategy(std::unique_ptr<SortingStrategy> strategy) {
        strategy_ = std::move(strategy);
    }

    void executeStrategy(std::vector<int>& data) {
        if (strategy_) {
            strategy_->sort(data);
        }
    }
};

// 使用
int main() {
    Sorter sorter;
    std::vector<int> data = {5, 2, 7, 1, 9};

    // 运行时动态选择策略
    if (data.size() < 100) {
        sorter.setStrategy(std::make_unique<BubbleSort>());
    } else {
        sorter.setStrategy(std::make_unique<QuickSort>());
    }

    sorter.executeStrategy(data);
    return 0;
}

应用场景：支付方式选择（信用卡、支付宝、微信）、数据压缩算法（ZIP、RAR）、折扣计算策略（满减、打折、返现）、游戏中的AI行为。

5. RAII模式 (Resource Acquisition Is Initialization)

这是C++独有的、最重要的“模式”或编程范式，它甚至不是GoF经典设计模式之一，但却是C++资源管理的基石。

核心思想：将资源的生命周期与对象的生命周期绑定。在构造函数中获取资源（分配内存、打开文件、加锁），在析构函数中释放资源。利用栈对象离开作用域时自动调用析构函数的特性，确保资源100%被释放。

解决的问题：

• 资源泄漏：从根本上解决了由于异常、提前返回、遗忘导致的内存泄漏、文件句柄泄漏、锁未释放等问题。
• 异常安全：即使发生异常，栈展开（stack unwinding）过程也会调用已构造对象的析构函数，保证资源被清理。

示例：管理互斥锁

#include <mutex>

// C++标准库的std::lock_guard本身就是RAII的完美体现
class MyLockGuard {
public:
    explicit MyLockGuard(std::mutex& mtx) : mutex_(mtx) {
        mutex_.lock();
        std::cout << "Mutex locked\n";
    }
    ~MyLockGuard() {
        mutex_.unlock();
        std::cout << "Mutex unlocked\n";
    }
    // 禁止拷贝
    MyLockGuard(const MyLockGuard&) = delete;
    MyLockGuard& operator=(const MyLockGuard&) = delete;
private:
    std::mutex& mutex_;
};

std::mutex myMutex;

void criticalSection() {
    MyLockGuard lock(myMutex); // 构造时加锁
    // ... 操作共享资源 ...
    // 无论这里是否发生异常，或者有多个return语句，
    // 函数结束时，lock的析构函数都会被调用，自动解锁。
}

// 使用智能指针管理动态内存是RAII的另一大应用
void manageMemory() {
    // 传统危险方式
    // int* ptr = new int(42);
    // ... 如果这里抛出异常，内存泄漏 ...
    // delete ptr;

    // RAII方式（使用智能指针）
    std::unique_ptr<int> ptr = std::make_unique<int>(42);
    // ... 即使抛出异常，内存也会被自动释放 ...
} // ptr离开作用域，自动调用delete

应用场景：无处不在。管理任何资源：动态内存（std::unique_ptr, std::shared_ptr）、文件句柄（std::fstream）、网络套接字、互斥锁（std::lock_guard）、数据库连接等。

总结与对比

如何选择？

• 需要全局唯一实例？ -> 单例模式
• 需要隔离对象创建逻辑？ -> 工厂模式
• 一个对象状态改变需要通知其他多个对象？ -> 观察者模式
• 有多种算法或策略需要灵活切换？ -> 策略模式
• 在C++中，只要涉及资源管理，首要考虑RAII！

掌握这些模式的关键在于理解其意图和适用场景，而不是死记硬背UML图。在实际项目中，这些模式常常会组合使用，从而构建出健壮、灵活且易于维护的C++系统。