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

工程实践中常见的几种设计模式解析及 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;
}

---

总结

以上四种设计模式（单例模式、工厂模式、观察者模式和策略模式）是工程实践中最常用的设计模式之一。每种模式都有其适用的场景和注意事项，合理使用它们可以显著提升代码的质量和系统的可维护性。

在实际开发中，我们需要根据具体需求选择合适的设计模式，并结合语言特性和框架进行实现。同时，也要注意避免过度设计，以免增加不必要的复杂性。