能否给出更多现代C++设计模式的示例

好的，以下是一些现代 C++ 中常见设计模式的实现示例：

1. 单例模式 (Singleton)

确保一个类只有一个实例，并提供全局访问点。

class Singleton { public: static Singleton& getInstance() { static Singleton instance; // 线程安全（C++11起） return instance; } void doSomething() { // 业务逻辑 } // 禁用拷贝和赋值 Singleton(const Singleton&) = delete; Singleton& operator=(const Singleton&) = delete; private: Singleton() = default; // 私有构造函数 }; // 使用示例 Singleton::getInstance().doSomething();

2. 策略模式 (Strategy)

定义一系列算法，并将每个算法封装起来，使它们可以互相替换。

#include <functional> #include <iostream> class Context { public: using Strategy = std::function<void()>; explicit Context(Strategy strategy) : strategy_(std::move(strategy)) {} void executeStrategy() { if (strategy_) strategy_(); } private: Strategy strategy_; }; // 使用示例 int main() { Context ctx1([]{ std::cout << "Strategy A\n"; }); Context ctx2([]{ std::cout << "Strategy B\n"; }); ctx1.executeStrategy(); // 输出: Strategy A ctx2.executeStrategy(); // 输出: Strategy B }

3. 观察者模式 (Observer)

定义对象间的一对多依赖关系，当一个对象状态改变时，所有依赖它的对象都会收到通知。

#include <vector> #include <functional> #include <iostream> class Subject { public: using Observer = std::function<void()>; void attach(Observer obs) { observers_.push_back(std::move(obs)); } void notify() { for (const auto& obs : observers_) { obs(); } } private: std::vector<Observer> observers_; }; // 使用示例 int main() { Subject subject; subject.attach([]{ std::cout << "Observer 1 notified\n"; }); subject.attach([]{ std::cout << "Observer 2 notified\n"; }); subject.notify(); // 输出: // Observer 1 notified // Observer 2 notified }

4. 工厂模式 (Factory)

定义一个创建对象的接口，但由子类决定实例化哪个类。

#include <memory> #include <iostream> class Product { public: virtual ~Product() = default; virtual void use() = 0; }; class ConcreteProductA : public Product { public: void use() override { std::cout << "Using Product A\n"; } }; class ConcreteProductB : public Product { public: void use() override { std::cout << "Using Product B\n"; } }; class Factory { public: virtual std::unique_ptr<Product> createProduct() = 0; }; class FactoryA : public Factory { public: std::unique_ptr<Product> createProduct() override { return std::make_unique<ConcreteProductA>(); } }; class FactoryB : public Factory { public: std::unique_ptr<Product> createProduct() override { return std::make_unique<ConcreteProductB>(); } }; // 使用示例 int main() { FactoryA factoryA; auto productA = factoryA.createProduct(); productA->use(); // 输出: Using Product A FactoryB factoryB; auto productB = factoryB.createProduct(); productB->use(); // 输出: Using Product B }

5. 访问者模式 (Visitor)

在不修改对象结构的前提下定义新操作。

#include <vector> #include <memory> #include <iostream> class Element; class ConcreteElementA; class ConcreteElementB; class Visitor { public: virtual void visit(ConcreteElementA& element) = 0; virtual void visit(ConcreteElementB& element) = 0; }; class Element { public: virtual ~Element() = default; virtual void accept(Visitor& visitor) = 0; }; class ConcreteElementA : public Element { public: void accept(Visitor& visitor) override { visitor.visit(*this); } }; class ConcreteElementB : public Element { public: void accept(Visitor& visitor) override { visitor.visit(*this); } }; class ConcreteVisitor : public Visitor { public: void visit(ConcreteElementA& element) override { std::cout << "Visitor processing ElementA\n"; } void visit(ConcreteElementB& element) override { std::cout << "Visitor processing ElementB\n"; } }; // 使用示例 int main() { std::vector<std::unique_ptr<Element>> elements; elements.push_back(std::make_unique<ConcreteElementA>()); elements.push_back(std::make_unique<ConcreteElementB>()); ConcreteVisitor visitor; for (auto& elem : elements) { elem->accept(visitor); } // 输出: // Visitor processing ElementA // Visitor processing ElementB }

以上示例结合了现代 C++ 特性（如std::function、智能指针、lambda 等），可根据实际需求调整实现细节。