设计模式为 c++++ 框架提供经过验证的解决方案，提高代码质量和可扩展性。包括策略模式，允许动态改变算法；观察者模式，实现一对多订阅和通知；工厂模式，提供创建对象的一致方式，提高可扩展性。

拓展 C++ 框架的强大工具：设计模式

设计模式为开发者提供了经过实战验证的解决方案，旨在改善代码质量、可扩展性和可维护性。通过采用设计模式，我们可以扩展 C++ 框架，使其更灵活、更高效。

策略模式

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

策略模式允许我们改变算法，而不影响客户端代码。这对于需要支持不同行为的框架尤其有用。

class Context {
    std::function<int(int, int)> strategy_;

public:
    Context(std::function<int(int, int)> strategy) : strategy_(strategy) {}
    int operate(int x, int y) { return strategy_(x, y); }
};

class AddStrategy {
public:
    int operator()(int x, int y) { return x + y; }
};

class MultiplyStrategy {
public:
    int operator()(int x, int y) { return x * y; }
};

int main() {
    Context ctx(AddStrategy());
    int sum = ctx.operate(3, 5); // 8

    ctx.strategy_ = MultiplyStrategy();
    int product = ctx.operate(3, 5); // 15

    return 0;
}

观察者模式

观察者模式是一种一对多的关系，允许对象订阅某个主题，以便在主题状态改变时收到通知。这对于构建灵活的事件驱动的框架很有用。

class Subject {
public:
    std::vector<Observer*> observers_;
    void addObserver(Observer* o) { observers_.push_back(o); }
    void notifyObservers() {
        for (auto o : observers_)
            o->update(this);
    }
};

class Observer {
public:
    virtual void update(Subject* s) = 0;
};

class ConcreteObserver1 : public Observer {
public:
    void update(Subject* s) { // Handle notification from Subject instance s }
};

class ConcreteObserver2 : public Observer {
public:
    void update(Subject* s) { // Handle notification differently }
};

int main() {
    Subject subject;

    ConcreteObserver1 obs1;
    ConcreteObserver2 obs2;

    subject.addObserver(&obs1);
    subject.addObserver(&obs2);

    subject.notifyObservers(); // Notifies observers about changes to the subject

    return 0;
}

工厂模式

工厂模式提供了一种创建对象的通用方式，而不暴露创建逻辑。这有助于提高代码的可扩展性和可重用性。

class Car {
    std::string make_;
    std::string model_;

public:
    Car(const std::string& make, const std::string& model) : make_(make), model_(model) {}
    std::string getMake() { return make_; }
    std::string getModel() { return model_; }
};

class CarFactory {
public:
    virtual Car* createCar(const std::string& make, const std::string& model) = 0;
};

class SedanFactory : public CarFactory {
public:
    Car* createCar(const std::string& make, const std::string& model) override {
        return new Sedan(make, model);
    }
};

int main() {
    SedanFactory sedanFactory;
    Car* sedan = sedanFactory.createCar("Toyota", "Camry");

    std::cout << "Make: " << sedan->getMake() << std::endl;  // Output: Toyota
    std::cout << "Model: " << sedan->getModel() << std::endl; // Output: Camry

    return 0;
}

通过在 C++ 框架中应用这些设计模式，您可以提高其灵活性、可扩展性和可维护性。这些模式提供了强大的工具，可以扩展框架，使其更易于适应不断变化的需求。