工程实践中常见的几种设计模式解析及 C++ 实现

在软件工程中，设计模式是一种通用的解决方案，用于解决常见问题和优化代码结构。它们通过提供一种规范化的编程思想，帮助开发者写出更高效、可维护和可扩展的代码。本文将介绍几种在工程实践中常见的设计模式，包括其实现原理、使用场景以及注意事项，并结合 C++ 语言进行实现。

1. 单例模式 (Singleton Pattern)

实现原理

单例模式确保一个类只有一个实例，并提供全局访问点。其核心思想是通过控制构造函数和复制操作符，使得类只能生成一个对象实例。

关键点：

隐藏构造函数（将构造函数设为私有）。
提供一个静态方法用于获取唯一实例。
使用懒汉式或饿汉式实现线程安全的单例模式。

使用场景

当需要全局只有一个实例时，例如配置管理、日志记录等。
需要避免大量重复对象创建的情况。

注意事项

单例模式可能会隐藏类之间的依赖关系，导致代码难以维护。
线程安全性需要额外处理（如双重检查锁定）。
在某些场景下，单例模式可能导致性能问题或内存泄漏。

C++ 实现

class Singleton {
private:static Singleton* instance;Singleton() = default;  // 隐藏构造函数~Singleton() = default; // 隐藏析构函数public:// 静态方法获取实例（线程安全）static Singleton* getInstance() {if (instance == nullptr) {instance = new Singleton();}return instance;}// 删除复制操作符，防止复制Singleton(const Singleton&) = delete;Singleton& operator=(const Singleton&) = delete;void doSomething() {// 业务逻辑}
};// 静态变量初始化为 nullptr
Singleton* Singleton::instance = nullptr;int main() {Singleton* s1 = Singleton::getInstance();Singleton* s2 = Singleton::getInstance();if (s1 == s2) { // 比较两个指针是否相同// 输出：两者指向同一个实例}return 0;
}

2. 工厂模式 (Factory Pattern)

实现原理

工厂模式通过提供一个接口，用于创建对象，而无需显式指定具体类。这提高了代码的灵活性和可扩展性。

关键点：

定义一个抽象产品类（Product）。
提供一个工厂类（Factory），通过其方法创建具体的子类实例。
工厂模式分为简单工厂模式和抽象工厂模式。

使用场景

需要根据不同的条件动态选择具体实现时。
避免代码直接依赖于具体实现类，提高系统的灵活性。

注意事项

工厂类可能会变得复杂，尤其是在支持多种产品的情况下。
增加新的产品类需要同时修改工厂类，这可能违反“开闭原则”。

C++ 实现

// 抽象产品类
class Product {
public:virtual ~Product() = default;virtual void use() = 0;
};// 具体产品类
class ConcreteProductA : public Product {
public:void use() override {// 使用具体实现 A}
};class ConcreteProductB : public Product {
public:void use() override {// 使用具体实现 B}
};// 工厂类
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() {// 使用工厂创建产品Factory* factory = new ConcreteFactoryA();auto product = factory->createProduct();product->use();delete factory;return 0;
}

3. 观察者模式 (Observer Pattern)

实现原理

观察者模式定义了一种一对多的依赖关系，当一个对象（主题）的状态发生变化时，所有依赖它的对象（观察者）都会收到通知并自动更新。

关键点：

定义一个主题类（Subject），包含状态和注册/注销观察者的接口。
观察者类（Observer）通过继承或实现接口，提供一个更新方法。
主题类维护一个观察者列表，并在状态变化时通知所有观察者。

使用场景

系统中存在一对多的依赖关系时。
需要动态地添加或删除观察者。

注意事项

观察者模式可能会导致循环依赖问题。
观察者和主题之间的耦合可能会影响代码的可维护性。

C++ 实现

#include <vector>
#include <memory>class Observer {
public:virtual ~Observer() = default;virtual void update(int value) = 0;
};class Subject {
private:int state_;std::vector<std::shared_ptr<Observer>> observers_;public:void attach(std::shared_ptr<Observer> observer) {observers_.push_back(observer);}void detach(std::shared_ptr<Observer> observer) {// 实现观察者的移除逻辑}int getState() const {return state_;}void setState(int value) {if (state_ != value) {state_ = value;notify();}}private:void notify() {for (auto& observer : observers_) {observer->update(state_);}}
};class ConcreteObserver : public Observer {
public:void update(int value) override {// 处理状态变化}
};int main() {std::shared_ptr<Subject> subject = std::make_shared<Subject>();std::shared_ptr<ConcreteObserver> observer1 = std::make_shared<ConcreteObserver>();std::shared_ptr<ConcreteObserver> observer2 = std::make_shared<ConcreteObserver>();subject->attach(observer1);subject->attach(observer2);subject->setState(10); // 所有观察者都会收到更新return 0;
}

4. 策略模式 (Strategy Pattern)

实现原理

策略模式定义了一系列算法，并将它们封装起来，使它们可以互换。上下文类通过接口调用具体策略类的方法。

关键点：

定义一个策略接口（Strategy），包含算法的声明。
具体策略类（Concrete Strategy）实现策略接口。
上下文类（Context）维护一个策略对象，并根据需要切换策略。

使用场景

需要动态选择不同算法时。
系统中存在多个相似但具体的算法，且希望它们可以互换使用。

注意事项

增加新的具体策略类可能会影响上下文的代码复杂性。
必须确保所有策略接口的一致性。

C++ 实现

class Strategy {
public:virtual ~Strategy() = default;virtual int calculate(int a, int b) = 0;
};// 具体策略类 A：加法
class AddStrategy : public Strategy {
public:int calculate(int a, int b) override {return a + b;}
};// 具体策略类 B：乘法
class MultiplyStrategy : public Strategy {
public:int calculate(int a, int b) override {return a * b;}
};// 上下文类
class Context {
private:std::shared_ptr<Strategy> strategy_;public:Context(std::shared_ptr<Strategy> strategy) : strategy_(strategy) {}void setStrategy(std::shared_ptr<Strategy> strategy) {strategy_ = strategy;}int execute(int a, int b) {return strategy_->calculate(a, b);}
};int main() {std::shared_ptr<Context> context = std::make_shared<Context>(std::make_shared<AddStrategy>());// 使用加法策略int result1 = context->execute(3, 5); // 8// 切换到乘法策略context->setStrategy(std::make_shared<MultiplyStrategy>());int result2 = context->execute(3, 5); // 15return 0;
}