C++高级应用_设计模式

在C++中，设计模式是一套被广泛认可的解决特定编程问题的最佳实践。这些模式可以帮助开发者构建灵活、可维护和可重用的代码。以下是一些最常见的设计模式及其在C++中的应用：

1. 单例模式（Singleton）

概念：确保一个类只有一个实例，并提供一个全局访问点。
原理：使用私有构造函数和静态实例变量。
用法：通常用于管理共享资源，如配置信息、线程池等。

案例代码：

class Singleton {
private:
    static Singleton* instance;
    Singleton() {}

public:
    static Singleton* getInstance() {
        if (instance == nullptr) {
            instance = new Singleton();
        }
        return instance;
    }
};

Singleton* Singleton::instance = nullptr;

int main() {
    Singleton* s1 = Singleton::getInstance();
    Singleton* s2 = Singleton::getInstance();
    assert(s1 == s2); // 确保是同一个实例
    return 0;
}

2. 工厂模式（Factory Method）

概念：定义一个创建对象的接口，但让子类决定实例化哪个类。
原理：使用多态来创建对象。
用法：用于代码中需要生成一系列相关或依赖对象的场景。

案例代码：

class Product {
public:
    virtual void use() = 0;
};

class ConcreteProductA : public Product {
public:
    void use() override {
        cout << "Using A" << endl;
    }
};

class ConcreteProductB : public Product {
public:
    void use() override {
        cout << "Using B" << endl;
    }
};

class Factory {
public:
    virtual Product* createProduct() = 0;
};

class ConcreteFactoryA : public Factory {
public:
    Product* createProduct() override {
        return new ConcreteProductA();
    }
};

class ConcreteFactoryB : public Factory {
public:
    Product* createProduct() override {
        return new ConcreteProductB();
    }
};

int main() {
    Factory* factory = new ConcreteFactoryA();
    Product* product = factory->createProduct();
    product->use(); // 使用A
    delete product;
    delete factory;
    return 0;
}

3. 观察者模式（Observer）

概念：定义对象间的一种一对多的依赖关系，当一个对象改变状态时，所有依赖于它的对象都得到通知并自动更新。
原理：使用回调函数或事件。
用法：用于实现数据和视图之间的同步，如模型-视图-控制器（MVC）架构。

案例代码：

#include <list>
#include <algorithm>

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

class Subject {
private:
    std::list<Observer*> observers;
public:
    void attach(Observer* observer) {
        observers.push_back(observer);
    }
    void detach(Observer* observer) {
        observers.remove(observer);
    }
    void notify() {
        for (auto observer : observers) {
            observer->update();
        }
    }
};

class ConcreteObserver : public Observer {
public:
    void update() override {
        cout << "Observer updated" << endl;
    }
};

int main() {
    Subject subject;
    ConcreteObserver observer;
    subject.attach(&observer);
    subject.notify(); // 通知所有观察者
    subject.detach(&observer);
    return 0;
}

4. 策略模式（Strategy）

概念：定义一系列算法，将每个算法封装起来，并使它们可以互换使用。
原理：使用多态来动态选择算法。
用法：用于需要动态改变算法或行为的场景。

案例代码：

class Context {
public:
    virtual void executeStrategy() = 0;
};

class ConcreteStrategyA : public Context {
public:
    void executeStrategy() override {
        cout << "Executing Strategy A" << endl;
    }
};

class ConcreteStrategyB : public Context {
public:
    void executeStrategy() override {
        cout << "Executing Strategy B" << endl;
    }
};

class Strategy {
public:
    virtual void algorithm() = 0;
};

class ContextClient {
private:
    Strategy* strategy;
public:
    void setStrategy(Strategy* strategy) {
        this->strategy = strategy;
    }
    void executeStrategy() {
        strategy->executeStrategy();
    }
};

int main() {
    ContextClient client;
    client.setStrategy(new ConcreteStrategyA());
    client.executeStrategy(); // 执行策略A
    client.setStrategy(new ConcreteStrategyB());
    client.executeStrategy(); // 执行策略B
    return 0;
}

这些设计模式提供了一套通用的解决方案，可以帮助开发者解决特定的编程问题，并提高代码的可维护性和可扩展性。在实际开发中，根据具体需求选择合适的设计模式是非常重要的。