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

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

1. 单例模式 (Singleton)

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

cpp 复制代码

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)

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

cpp 复制代码

#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)

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

cpp 复制代码

#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)

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

cpp 复制代码

#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)

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

cpp 复制代码

#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 等），可根据实际需求调整实现细节。