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

    return 0;
}

总结

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

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