设计模式是 c++++ 框架中的解决方案，可解决常见问题，如：适配器模式：使不兼容类相互协作。单例模式：确保类只有一个实例，提供全局访问。观察者模式：允许对象订阅目标对象事件，并在目标对象状态改变时进行通知。

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

引言

设计模式是在面向对象编程中用来解决常见问题的一组解决方案。它们有助于提升代码的可重用性、可维护性和灵活性。在 C++ 框架中，采用合适的设计模式至关重要，能确保代码的健壮性和可扩展性。

立即学习“C++免费学习笔记（深入）”；

适配器模式

适配器模式允许不同的类或接口相互协作。它通过提供一个适配器类，将一个接口转换成另一个接口，从而使本来不兼容的类能够共同工作。

// 目标接口
class ITarget {
public:
    virtual void request() = 0;
};

// 适配器类，将 Adaptee 适配为 ITarget
class Adapter : public ITarget {
    Adaptee* adaptee_;
public:
    Adapter(Adaptee* adaptee) : adaptee_(adaptee) {}
    virtual void request() override {
        adaptee_->specificRequest();
    }
};

// 具体类
class Adaptee {
public:
    virtual void specificRequest() {
        // 具体实现
    }
};

int main() {
    Adaptee* adaptee = new Adaptee();
    ITarget* target = new Adapter(adaptee);
    target->request();
    return 0;
}

单例模式

单例模式确保一个类只有一个实例，并提供一个全局访问点。它用于实现全局配置对象、数据库连接池和缓存等场景。

// 单例类
class Singleton {
private:
    static Singleton* instance_;
    Singleton() {}
public:
    static Singleton* getInstance() {
        if (instance_ == nullptr) {
            instance_ = new Singleton();
        }
        return instance_;
    }
};

int main() {
    Singleton* instance1 = Singleton::getInstance();
    Singleton* instance2 = Singleton::getInstance();
    assert(instance1 == instance2); // 始终返回同一个实例
    return 0;
}

观察者模式

观察者模式允许对象在不了解目标对象的情况下订阅其事件。当目标对象状态发生变化时，它会通知所有观察者。这种模式适用于松耦合事件处理和消息传递。

// 目标类
class Subject {
public:
    virtual void attach(Observer* observer) = 0;
    virtual void detach(Observer* observer) = 0;
    virtual void notify() = 0;
};

// 观察者类
class Observer {
public:
    virtual void update() = 0;
};

class ConcreteSubject : public Subject {
    std::vector<Observer*> observers_;
    int state_;
public:
    void attach(Observer* observer) override {
        observers_.push_back(observer);
    }
    void detach(Observer* observer) override {
        auto it = std::find(observers_.begin(), observers_.end(), observer);
        if (it != observers_.end()) {
            observers_.erase(it);
        }
    }
    void notify() override {
        for (auto observer : observers_) {
            observer->update();
        }
    }
    int getState() const { return state_; }
    void setState(int state) {
        state_ = state;
        notify();
    }
};

class ConcreteObserver : public Observer {
    ConcreteSubject* subject_;
public:
    ConcreteObserver(ConcreteSubject* subject) : subject_(subject) {}
    void update() override {
        int state = subject_->getState();
        // 根据状态更新自身状态
    }
};

int main() {
    ConcreteSubject* subject = new ConcreteSubject();
    ConcreteObserver* observer1 = new ConcreteObserver(subject);
    ConcreteObserver* observer2 = new ConcreteObserver(subject);
    subject->attach(observer1);
    subject->attach(observer2);

    subject->setState(10);
    subject->setState(20);
    return 0;
}

这些只是 C++ 框架中众多设计模式中的几个。通过选择和应用适当的设计模式，开发人员可以创建可维护、可扩展且易于使用的代码。