C++ 框架中设计模式的最佳实践

C++ 是一种功能强大且广泛应用的编程语言，它在系统编程、游戏开发、嵌入式系统等多个领域都得到了广泛的应用。在开发过程中，使用设计模式不仅可以提高代码的可读性和可维护性，还能增强系统的灵活性和可扩展性。本文将介绍在 C++ 框架中应用设计模式的最佳实践，旨在帮助开发者更有效地利用设计模式来优化代码结构。

单例模式

单例模式保证一个类只有一个实例，并提供一个全局访问点。它在需要控制对象创建次数的场景下非常有用，例如数据库连接、日志管理等。

实现方式

在 C++ 中实现单例模式通常涉及到以下几个方面：

构造函数私有化

提供一个静态成员函数来获取唯一实例

使用静态成员变量保存唯一实例

class Singleton {
public:
    static Singleton& getInstance() {
        static Singleton instance;
        return instance;
    }
private:
    Singleton() {}  // 私有构造函数
    Singleton(const Singleton&) = delete;  // 禁用复制构造函数
    void operator=(const Singleton&) = delete;  // 禁用赋值运算符
};

工厂模式

工厂模式是一种创建型模式，根据输入类型动态创建对象。它在需要创建大量具有相似属性的对象时尤其有用，例如多种类型的图形对象。

实现方式

在 C++ 中实现工厂模式的一种常见方法是定义一个基类和若干派生类，并提供一个工厂类来创建这些派生类的实例。

class Shape {
public:
    virtual void draw() = 0;  // 纯虚函数
    virtual ~Shape() = default;
};
class Circle : public Shape {
public:
    void draw() override {
        std::cout << "Drawing Circle" << std::endl;
    }
};
class Square : public Shape {
public:
    void draw() override {
        std::cout << "Drawing Square" << std::endl;
    }
};
class ShapeFactory {
public:
    enum ShapeType { CIRCLE, SQUARE };
    static std::unique_ptr createShape(ShapeType type) {
        switch (type) {
            case CIRCLE: return std::make_unique();
            case SQUARE: return std::make_unique();
            default: return nullptr;
        }
    }
};

观察者模式

观察者模式是一种行为型模式，它允许一个对象（被观察者）在状态改变时通知所有依赖于它的对象（观察者）。该模式在事件驱动的系统中非常常见，例如 GUI 事件处理、订阅发布系统等。

实现方式

在 C++ 中实现观察者模式通常涉及到以下步骤：

定义一个观察者接口

在被观察者类中保存观察者列表，并提供添加和删除观察者的方法

在状态改变时通知所有观察者

#include 
#include 
class Observer {
public:
    virtual void update() = 0;
    virtual ~Observer() = default;
};
class Subject {
public:
    void addObserver(Observer* observer) {
        observers.push_back(observer);
    }
    void removeObserver(Observer* observer) {
        observers.erase(std::remove(observers.begin(), observers.end(), observer), observers.end());
    }
    void notifyObservers() {
        for(auto observer : observers) {
            observer->update();
        }
    }
private:
    std::vector observers;
};
class ConcreteObserver : public Observer {
public:
    void update() override {
        std::cout << "Observer notified" << std::endl;
    }
};
int main() {
    Subject subject;
    ConcreteObserver observer1, observer2;
    subject.addObserver(&observer1);
    subject.addObserver(&observer2);
    subject.notifyObservers();
    return 0;
}

策略模式

策略模式是一种行为型模式，它将不同的算法封装成独立的类，并使它们可互相替换。这个模式的应用场景包括需要在运行时选择算法或行为的地方。

实现方式

通常，通过定义一个策略接口和若干具体实现，然后在需要使用策略的类中通过接口引用具体策略。

class Strategy {
public:
    virtual void execute() = 0;
    virtual ~Strategy() = default;
};
class ConcreteStrategyA : public Strategy {
public:
    void execute() override {
        std::cout << "Executing Strategy A" << std::endl;
    }
};
class ConcreteStrategyB : public Strategy {
public:
    void execute() override {
        std::cout << "Executing Strategy B" << std::endl;
    }
};
class Context {
public:
    void setStrategy(std::unique_ptr newStrategy) {
        strategy = std::move(newStrategy);
    }
    void performAction() {
        if(strategy) {
            strategy->execute();
        }
    }
private:
    std::unique_ptr strategy;
};
int main() {
    Context context;
    context.setStrategy(std::make_unique());
    context.performAction();
    context.setStrategy(std::make_unique());
    context.performAction();
    return 0;
}

总而言之，设计模式是编程中的宝贵工具，它们能显著提升代码的可维护性、可扩展性和复用性。掌握并合理应用这些模式，能让 C++ 开发变得更加高效和优雅。