C++开发者必备：23种设计模式全面解析

---

创建型	结构型	行为型
工厂模式（简单工厂、工厂方法）	适配器模式	解释器模式
抽象工厂模式	桥接模式	模板方法模式
原型模式	组合模式	策略模式
建造者模式	装饰模式	观察者模式
单例模式	外观模式	状态模式
	享元模式	备忘录模式
	代理模式	迭代器模式
		命令模式
		责任链模式
		中介者模式
		访问者模式

• 创建型包含5种模式，涉及对象/对象组合的创建构建。
• 结构性包含7种模式，涉及对象/类之间的关系。
• 行为型包含11种模式，涉及对象/类的行为、状态、流程。

一、创建型模式

1、工厂模式

a、简单工厂

#include <iostream>
#include <stdexcept>

class Operation {
    
    
public:
    double numberA = 0;
    double numberB = 0;

    virtual double getResult() const = 0; // 纯虚函数
    virtual ~Operation() = default;      // 虚析构函数
};

class OperationAdd : public Operation {
    
    
public:
    double getResult() const override {
    
    
        return numberA + numberB;
    }
};

class OperationSub : public Operation {
    
    
public:
    double getResult() const override {
    
    
        return numberA - numberB;
    }
};

class OperationMul : public Operation {
    
    
public:
    double getResult() const override {
    
    
        return numberA * numberB;
    }
};

class OperationDiv : public Operation {
    
    
public:
    double getResult() const override {
    
    
        if (numberB == 0) {
    
    
            throw std::runtime_error("divided by 0");
        }
        return numberA / numberB;
    }
};

class OperationFactory {
    
    
public:
    static Operation* createOperation(char operatorType) {
    
    
        switch (operatorType) {
    
    
            case '+':
                return new OperationAdd();
            case '-':
                return new OperationSub();
            case '*':
                return new OperationMul();
            case '/':
                return new OperationDiv();
            default:
                throw std::runtime_error("unsupported operation");
        }
    }
};

int main() {
    
    
    try {
    
    
        char operatorType = '+';
        Operation* operation = OperationFactory::createOperation(operatorType);

        operation->numberA = 1.2;
        operation->numberB = 2.3;

        std::cout << "Result: " << operation->getResult() << std::endl;

        delete operation; // 释放内存
    } catch (const std::exception& ex) {
    
    
        std::cerr << "Error: " << ex.what() << std::endl;
    }

    return 0;
}

b、工厂方法

工厂方法模式，定义一个用于创建对象的接口，让子类决定实例化哪一个类。工厂方法使一个类的实例化延迟到其子类。

#include <iostream>
#include <stdexcept>
#include <memory> // 使用智能指针

// 抽象基类：Operation
class Operation {
    
    
public:
    double numberA = 0;
    double numberB = 0;

    virtual double getResult() const = 0; // 纯虚函数
    virtual ~Operation() = default;      // 虚析构函数
};

// 派生类：加法操作
class OperationAdd : public Operation {
    
    
public:
    double getResult() const override {
    
    
        return numberA + numberB;
    }
};

// 派生类：减法操作
class OperationSub : public Operation {
    
    
public:
    double getResult() const override {
    
    
        return numberA - numberB;
    }
};

// 派生类：乘法操作
class OperationMul : public Operation {
    
    
public:
    double getResult() const override {
    
    
        return numberA * numberB;
    }
};

// 派生类：除法操作
class OperationDiv : public Operation {
    
    
public:
    double getResult() const override {
    
    
        if (numberB == 0) {
    
    
            throw std::runtime_error("divided by 0");
        }
        return numberA / numberB;
    }
};

// 工厂接口
class IFactory {
    
    
public:
    virtual std::unique_ptr<Operation> createOperation() const = 0; // 使用智能指针
    virtual ~IFactory() = default;
};

// 加法工厂
class AddFactory : public IFactory {
    
    
public:
    std::unique_ptr<Operation> createOperation() const override {
    
    
        return std::make_unique<OperationAdd>();
    }
};

// 减法工厂
class SubFactory : public IFactory {
    
    
public:
    std::unique_ptr<Operation> createOperation() const override {
    
    
        return std::make_unique<OperationSub>();
    }
};

// 乘法工厂
class MulFactory : public IFactory {
    
    
public:
    std::unique_ptr<Operation> createOperation() const override {
    
    
        return std::make_unique<OperationMul>();
    }
};

// 除法工厂
class DivFactory : public IFactory {
    
    
public:
    std::unique_ptr<Operation> createOperation() const override {
    
    
        return std::make_unique<OperationDiv>();
    }
};

// 工厂方法客户端
int main() {
    
    
    try {
    
    
        // 创建一个除法工厂
        std::unique_ptr<IFactory> operFactory = std::make_unique<DivFactory>();
        // 通过工厂创建一个除法操作对象
        std::unique_ptr<Operation> operation = operFactory->createOperation();

        operation->numberA = 3.4;
        operation->numberB = 4.5;

        std::cout << "Result: " << operation->getResult() << std::endl;
    } catch (const std::exception& ex) {
    
    
        std::cerr << "Error: " << ex.what() << std::endl;
    }

    return 0;
}

2、抽象工厂模式

抽象工厂模式，提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。

#include <iostream>
#include <memory>

// 抽象产品A
class AbstractProductA {
    
    
public:
    virtual void methodA() const = 0;
    virtual ~AbstractProductA() = default;
};

// 具体产品A1
class ProductA1 : public AbstractProductA {
    
    
public:
    void methodA() const override {
    
    
        std::cout << "ProductA1's methodA" << std::endl;
    }
};

// 具体产品A2
class ProductA2 : public AbstractProductA {
    
    
public:
    void methodA() const override {
    
    
        std::cout << "ProductA2's methodA" << std::endl;
    }
};

// 抽象产品B
class AbstractProductB {
    
    
public:
    virtual void methodB() const = 0;
    virtual ~AbstractProductB() = default;
};

// 具体产品B1
class ProductB1 : public AbstractProductB {
    
    
public:
    void methodB() const override {
    
    
        std::cout << "ProductB1's methodB" << std::endl;
    }
};

// 具体产品B2
class ProductB2 : public AbstractProductB {
    
    
public:
    void methodB() const override {
    
    
        std::cout << "ProductB2's methodB" << std::endl;
    }
};

// 抽象工厂
class AbstractFactory {
    
    
public:
    virtual std::unique_ptr<AbstractProductA> createProductA() const = 0;
    virtual std::unique_ptr<AbstractProductB> createProductB() const = 0;
    virtual ~AbstractFactory() = default;
};

// 具体工厂1
class ConcreteFactory1 : public AbstractFactory {
    
    
public:
    std::unique_ptr<AbstractProductA> createProductA() const override {
    
    
        return std::make_unique<ProductA1>();
    }

    std::unique_ptr<AbstractProductB> createProductB() const override {
    
    
        return std::make_unique<ProductB1>();
    }
};

// 具体工厂2
class ConcreteFactory2 : public AbstractFactory {
    
    
public:
    std::unique_ptr<AbstractProductA> createProductA() const override {
    
    
        return std::make_unique<ProductA2>();
    }

    std::unique_ptr<AbstractProductB> createProductB() const override {
    
    
        return std::make_unique<ProductB2>();
    }
};

// 客户端
int main() {
    
    
    // 使用具体工厂1
    std::unique_ptr<AbstractFactory> factory1 = std::make_unique<ConcreteFactory1>();
    std::unique_ptr<AbstractProductA> productA1 = factory1->createProductA();
    std::unique_ptr<AbstractProductB> productB1 = factory1->createProductB();
    productA1->methodA();
    productB1->methodB();

    // 使用具体工厂2
    std::unique_ptr<AbstractFactory> factory2 = std::make_unique<ConcreteFactory2>();
    std::unique_ptr<AbstractProductA> productA2 = factory2->createProductA();
    std::unique_ptr<AbstractProductB> productB2 = factory2->createProductB();
    productA2->methodA();
    productB2->methodB();

    return 0;
}

3、原型模式

原型模式，用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象。

#include <iostream>
#include <memory>

// 原型接口
class Prototype {
    
    
public:
    virtual std::unique_ptr<Prototype> clone() const = 0; // 纯虚函数，返回智能指针
    virtual ~Prototype() = default;
};

// 具体原型A
class ConcretePrototypeA : public Prototype {
    
    
public:
    std::unique_ptr<Prototype> clone() const override {
    
    
        return std::make_unique<ConcretePrototypeA>(*this); // 调用拷贝构造函数
    }
};

// 具体原型B
class ConcretePrototypeB : public Prototype {
    
    
public:
    std::unique_ptr<Prototype> clone() const override {
    
    
        return std::make_unique<ConcretePrototypeB>(*this); // 调用拷贝构造函数
    }
};

// 客户端
int main() {
    
    
    // 创建具体原型A和具体原型B
    std::unique_ptr<ConcretePrototypeA> prototypeA = std::make_unique<ConcretePrototypeA>();
    std::unique_ptr<ConcretePrototypeB> prototypeB = std::make_unique<ConcretePrototypeB>();

    // 克隆具体原型A和具体原型B
    std::unique_ptr<ConcretePrototypeA> cloneA = std::unique_ptr<ConcretePrototypeA>(static_cast<ConcretePrototypeA*>(prototypeA->clone().release()));
    std::unique_ptr<ConcretePrototypeB> cloneB = std::unique_ptr<ConcretePrototypeB>(static_cast<ConcretePrototypeB*>(prototypeB->clone().release()));

    // 检查克隆是否成功
    std::cout << "Clone A == Prototype A: " << (cloneA.get() != prototypeA.get()) << std::endl;
    std::cout << "Clone B == Prototype B: " << (cloneB.get() != prototypeB.get()) << std::endl;

    return 0;
}

4、建造者模式

建造者模式，将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。

#include <iostream>
#include <string>
#include <memory>

// 产品类
class Product {
    
    
private:
    std::string part1_;
    std::string part2_;

public:
    void setPart1(const std::string& part1) {
    
    
        part1_ = part1;
    }

    void setPart2(const std::string& part2) {
    
    
        part2_ = part2;
    }

    void show() const {
    
    
        std::cout << "Part 1: " << part1_ << std::endl;
        std::cout << "Part 2: " << part2_ << std::endl;
    }
};

// 建造者接口
class Builder {
    
    
public:
    virtual void buildPart() = 0;
    virtual std::unique_ptr<Product> getResult() = 0;
    virtual ~Builder() = default;
};

// 具体建造者类
class ConcreteBuilder : public Builder {
    
    
private:
    std::unique_ptr<Product> product_;

public:
    ConcreteBuilder() : product_(std::make_unique<Product>()) {
    
    }

    void buildPart() override {
    
    
        product_->setPart1("Part 1 built by ConcreteBuilder");
        product_->setPart2("Part 2 built by ConcreteBuilder");
    }

    std::unique_ptr<Product> getResult() override {
    
    
        return std::move(product_);
    }
};

// 指挥者类
class Director {
    
    
private:
    Builder* builder_;

public:
    explicit Director(Builder* builder) : builder_(builder) {
    
    }

    void construct() {
    
    
        builder_->buildPart();
    }
};

// 客户端代码
int main() {
    
    
    ConcreteBuilder builder;
    Director director(&builder);

    director.construct();
    std::unique_ptr<Product> product = builder.getResult();
    product->show();

    return 0;
}

5、单例模式

单例模式，保证一个类仅有一个实例，并提供一个访问它的全局访问点。

#include <iostream>
#include <memory>
#include <mutex>

// 线程安全的单例模式
class SingletonThreadSafe {
    
    
private:
    static std::unique_ptr<SingletonThreadSafe> instance_; // 静态实例指针
    static std::mutex mutex_; // 用于线程安全的互斥锁

    // 私有构造函数，禁止直接实例化
    SingletonThreadSafe() {
    
    }

public:
    // 删除拷贝构造函数和赋值运算符，防止拷贝
    SingletonThreadSafe(const SingletonThreadSafe&) = delete;
    SingletonThreadSafe& operator=(const SingletonThreadSafe&) = delete;

    // 获取单例实例的静态方法
    static SingletonThreadSafe* getInstance() {
    
    
        if (instance_ == nullptr) {
    
    
            std::lock_guard<std::mutex> lock(mutex_); // 加锁确保线程安全
            if (instance_ == nullptr) {
    
    
                instance_ = std::unique_ptr<SingletonThreadSafe>(new SingletonThreadSafe());
            }
        }
        return instance_.get();
    }
};

// 初始化静态成员变量
std::unique_ptr<SingletonThreadSafe> SingletonThreadSafe::instance_ = nullptr;
std::mutex SingletonThreadSafe::mutex_;

// 客户端代码
int main() {
    
    
    SingletonThreadSafe* instance1 = SingletonThreadSafe::getInstance();
    SingletonThreadSafe* instance2 = SingletonThreadSafe::getInstance();

    if (instance1 == instance2) {
    
    
        std::cout << "Same instance" << std::endl;
    } else {
    
    
        std::cout << "Different instances" << std::endl;
    }

    return 0;
}

二、结构型模式

1、适配器模式

适配器模式，将一个类的接口转换成客户希望的另外一个接口。Adapter 模式使得原本由于接口不兼容而不能一起工作的那些类可以一起工作。

#include <iostream>
#include <memory>

// 需要适配的类
class Adaptee {
    
    
public:
    void specificRequest() {
    
    
        std::cout << "Specific request!" << std::endl;
    }
};

// 客户所期待的接口
class Target {
    
    
public:
    virtual void request() {
    
    
        std::cout << "Regular request!" << std::endl;
    }

    virtual ~Target() = default; // 确保基类具有虚析构函数
};

// 适配器类，通过包装一个 Adaptee 对象，把原接口转换成目标接口
class Adapter : public Target {
    
    
private:
    std::unique_ptr<Adaptee> adaptee;

public:
    Adapter() : adaptee(std::make_unique<Adaptee>()) {
    
    }

    void request() override {
    
    
        adaptee->specificRequest();
    }
};

// 客户端代码
int main() {
    
    
    std::unique_ptr<Target> target = std::make_unique<Adapter>();
    target->request();

    return 0;
}

2、桥接模式

桥接模式，将抽象部分与它的实现部分分离，使它们都可以独立地变化。

#include <iostream>
#include <memory>
#include <string>

// 实现部分的接口
class Implementor {
    
    
public:
    virtual void operation() = 0;
    virtual ~Implementor() = default; // 确保基类有虚析构函数
};

// 具体实现A
class ConcreteImplementorA : public Implementor {
    
    
public:
    void operation() override {
    
    
        std::cout << "ConcreteImplementorA's method executed" << std::endl;
    }
};

// 具体实现B
class ConcreteImplementorB : public Implementor {
    
    
public:
    void operation() override {
    
    
        std::cout << "ConcreteImplementorB's method executed" << std::endl;
    }
};

// 抽象部分
class Abstraction {
    
    
protected:
    std::shared_ptr<Implementor> implementor; // 聚合Implementor
    std::string name;

public:
    Abstraction(const std::string& name) : name(name) {
    
    }

    void setImplementor(std::shared_ptr<Implementor> impl) {
    
    
        implementor = impl;
    }

    virtual void operation() {
    
    
        std::cout << "Abstraction-" << name << ": ";
        if (implementor) {
    
    
            implementor->operation();
        }
    }

    virtual ~Abstraction() = default;
};

// 扩展抽象部分A
class AbstractionA : public Abstraction {
    
    
public:
    AbstractionA(const std::string& name) : Abstraction(name) {
    
    }

    void operation() override {
    
    
        Abstraction::operation();
    }
};

// 扩展抽象部分B
class AbstractionB : public Abstraction {
    
    
public:
    AbstractionB(const std::string& name) : Abstraction(name) {
    
    }

    void operation() override {
    
    
        Abstraction::operation();
    }
};

// 客户端
int main() {
    
    
    std::shared_ptr<Abstraction> a = std::make_shared<AbstractionA>("A");
    a->setImplementor(std::make_shared<ConcreteImplementorA>());
    a->operation();
    a->setImplementor(std::make_shared<ConcreteImplementorB>());
    a->operation();

    std::shared_ptr<Abstraction> b = std::make_shared<AbstractionB>("B");
    b->setImplementor(std::make_shared<ConcreteImplementorA>());
    b->operation();
    b->setImplementor(std::make_shared<ConcreteImplementorB>());
    b->operation();

    // 符合开放-封闭原则，如果需要新的 Abstraction 或 ConcreteImplementor，只需扩展类
    return 0;
}

3、组合模式

组合模式，将对象组合成树形结构以表示“部分-整体”的层次结构。组合模式使得用户对单个对象和组合对象的使用具有一致性。

#include <iostream>
#include <vector>
#include <memory>
#include <string>
#include <algorithm>

// 抽象基类 Component，声明接口
class Component {
    
    
protected:
    std::string name;

    // 用于显示层次结构的辅助函数
    std::string repeatableLayer(int depth) const {
    
    
        return std::string(depth, '-');
    }

public:
    explicit Component(const std::string& name) : name(name) {
    
    }

    virtual ~Component() = default;

    virtual void add(std::shared_ptr<Component> component) {
    
    
        std::cout << "Cannot add to this component" << std::endl;
    }

    virtual void remove(std::shared_ptr<Component> component) {
    
    
        std::cout << "Cannot remove from this component" << std::endl;
    }

    virtual void display(int depth) const = 0;
};

// 叶子节点 Leaf，没有子节点
class Leaf : public Component {
    
    
public:
    explicit Leaf(const std::string& name) : Component(name) {
    
    }

    void display(int depth) const override {
    
    
        std::cout << repeatableLayer(depth) << name << std::endl;
    }
};

// 组合节点 Composite，用于存储子节点
class Composite : public Component {
    
    
private:
    std::vector<std::shared_ptr<Component>> children;

public:
    explicit Composite(const std::string& name) : Component(name) {
    
    }

    void add(std::shared_ptr<Component> component) override {
    
    
        children.push_back(component);
    }

    void remove(std::shared_ptr<Component> component) override {
    
    
        // 使用自定义比较函数来删除
        auto it = std::find(children.begin(), children.end(), component);
        if (it != children.end()) {
    
    
            children.erase(it);
        } else {
    
    
            std::cout << "Component not found to remove" << std::endl;
        }
    }

    void display(int depth) const override {
    
    
        // 显示当前节点名称
        std::cout << repeatableLayer(depth) << name << std::endl;

        // 遍历并显示子节点
        for (const auto& child : children) {
    
    
            child->display(depth + 2);
        }
    }
};

// 客户端
int main() {
    
    
    // 生成树根，根上长出两叶 Leaf A 和 Leaf B
    auto root = std::make_shared<Composite>("root");
    root->add(std::make_shared<Leaf>("Leaf A"));
    root->add(std::make_shared<Leaf>("Leaf B"));

    // 根上长出分支 Composite X，分支上也有两叶 Leaf X-A 和 Leaf X-B
    auto compositeX = std::make_shared<Composite>("Composite X");
    compositeX->add(std::make_shared<Leaf>("Leaf X-A"));
    compositeX->add(std::make_shared<Leaf>("Leaf X-B"));
    root->add(compositeX);

    // 在 Composite X 上再长出分支 Composite X-Y，分支上也有两叶 Leaf X-Y-A 和 Leaf X-Y-B
    auto compositeXY = std::make_shared<Composite>("Composite X-Y");
    compositeXY->add(std::make_shared<Leaf>("Leaf X-Y-A"));
    compositeXY->add(std::make_shared<Leaf>("Leaf X-Y-B"));
    compositeX->add(compositeXY);

    // 显示树的结构
    root->display(1);

    // 测试删除节点
    std::cout << "\nRemoving Leaf X-A from Composite X" << std::endl;
    compositeX->remove(std::make_shared<Leaf>("Leaf X-A"));
    root->display(1);

    return 0;
}

4、装饰模式

装饰模式，动态地给一个对象添加一些额外的职责，就增加功能来说，装饰模式比生成子类更为灵活。

#include <iostream>
#include <memory>
#include <string>

// Component is the interface for the object
class Component {
    
    
public:
    virtual ~Component() = default;
    virtual void operation() = 0;
};

// ConcreteComponent defines a concrete object
class ConcreteComponent : public Component {
    
    
public:
    void operation() override {
    
    
        std::cout << "Operation of ConcreteComponent" << std::endl;
    }
};

// Decorator is the abstract class, inheriting from Component
class Decorator : public Component {
    
    
protected:
    std::shared_ptr<Component> component;

public:
    virtual ~Decorator() = default;

    void setComponent(std::shared_ptr<Component> comp) {
    
    
        component = comp;
    }

    void operation() override {
    
    
        if (component) {
    
    
            component->operation();
        }
    }
};

// ConcreteDecoratorA is a concrete decorator A
class ConcreteDecoratorA : public Decorator {
    
    
private:
    std::string addedState;

public:
    void operation() override {
    
    
        // First, call the original component's operation(), then add functionality
        Decorator::operation();
        addedState = "New state in A ";
        std::cout << addedState << "Operation of ConcreteDecoratorA" << std::endl;
    }
};

// ConcreteDecoratorB is a concrete decorator B
class ConcreteDecoratorB : public Decorator {
    
    
public:
    void operation() override {
    
    
        Decorator::operation();
        addedBehavior();
        std::cout << "Operation of ConcreteDecoratorB" << std::endl;
    }

    void addedBehavior() {
    
    
        std::cout << "Added behavior in B ";
    }
};

// ConcreteDecoratorC is a concrete decorator C
class ConcreteDecoratorC : public Decorator {
    
    
public:
    void operation() override {
    
    
        Decorator::operation();
        std::cout << "No special behavior in C " << "Operation of ConcreteDecoratorC" << std::endl;
    }
};

// Client code
int main() {
    
    
    // Create a concrete Component object
    auto concreteComponent = std::make_shared<ConcreteComponent>();

    // Create concrete decorator A and decorate the original object
    ConcreteDecoratorA decoratorA;
    decoratorA.setComponent(concreteComponent);

    // Create concrete decorator B and decorate the original object
    ConcreteDecoratorB decoratorB;
    decoratorB.setComponent(concreteComponent);

    // Create concrete decorator C and decorate the original object
    ConcreteDecoratorC decoratorC;
    decoratorC.setComponent(concreteComponent);

    // Use decorator A, B, C to decorate the original object
    std::cout << "Using ConcreteDecoratorA:" << std::endl;
    decoratorA.operation();

    std::cout << "\nUsing ConcreteDecoratorB:" << std::endl;
    decoratorB.operation();

    std::cout << "\nUsing ConcreteDecoratorC:" << std::endl;
    decoratorC.operation();

    return 0;
}

5、外观模式

外观模式，为子系统中的一组接口提供一个一致的界面，此模式定义了一个高层接口，这个接口使得这一子系统更加容易使用。

#include <iostream>
#include <memory>

// "System" interface (abstract class in C++)
class SystemInterface {
    
    
public:
    virtual ~SystemInterface() = default;
};

// SubSystemOne class implements SystemInterface
class SubSystemOne : public SystemInterface {
    
    
public:
    void methodOne() {
    
    
        std::cout << "SubSystem method one" << std::endl;
    }
};

// SubSystemTwo class implements SystemInterface
class SubSystemTwo : public SystemInterface {
    
    
public:
    void methodTwo() {
    
    
        std::cout << "SubSystem method two" << std::endl;
    }
};

// SubSystemThree class implements SystemInterface
class SubSystemThree : public SystemInterface {
    
    
public:
    void methodThree() {
    
    
        std::cout << "SubSystem method three" << std::endl;
    }
};

// SubSystemFour class implements SystemInterface
class SubSystemFour : public SystemInterface {
    
    
public:
    void methodFour() {
    
    
        std::cout << "SubSystem method four" << std::endl;
    }
};

// Facade class that simplifies access to the subsystems
class Facade {
    
    
private:
    std::shared_ptr<SubSystemOne> subSystemOne;
    std::shared_ptr<SubSystemTwo> subSystemTwo;
    std::shared_ptr<SubSystemThree> subSystemThree;
    std::shared_ptr<SubSystemFour> subSystemFour;

public:
    Facade() {
    
    
        subSystemOne = std::make_shared<SubSystemOne>();
        subSystemTwo = std::make_shared<SubSystemTwo>();
        subSystemThree = std::make_shared<SubSystemThree>();
        subSystemFour = std::make_shared<SubSystemFour>();
    }

    void methodA() {
    
    
        std::cout << "Method Group A:" << std::endl;
        subSystemOne->methodOne();
        subSystemTwo->methodTwo();
        subSystemFour->methodFour();
    }

    void methodB() {
    
    
        std::cout << "Method Group B:" << std::endl;
        subSystemThree->methodThree();
        subSystemFour->methodFour();
    }
};

// FacadeClient (client code)
int main() {
    
    
    // The client can use the Facade to interact with the subsystems
    // without knowing the details of each subsystem.
    // This is similar to hiding the complexity of legacy systems.
    
    Facade facade;

    facade.methodA();
    facade.methodB();

    return 0;
}

6、享元模式

享元模式，运用共享技术有效地支持大量细粒度的对象。

#include <iostream>
#include <memory>
#include <unordered_map>

// FlyWeight base class, accepting and acting on external state
class FlyWeight {
    
    
public:
    virtual ~FlyWeight() = default;
    virtual void operation(int extrinsicState) = 0;
};

// ConcreteFlyWeight class implements FlyWeight
class ConcreteFlyWeight : public FlyWeight {
    
    
public:
    void operation(int extrinsicState) override {
    
    
        std::cout << "Concrete FlyWeight: " << extrinsicState << std::endl;
    }
};

// UnsharedConcreteFlyWeight class implements FlyWeight
class UnsharedConcreteFlyWeight : public FlyWeight {
    
    
public:
    void operation(int extrinsicState) override {
    
    
        std::cout << "Unshared Concrete FlyWeight: " << extrinsicState << std::endl;
    }
};

// FlyWeightFactory class responsible for managing FlyWeight objects
class FlyWeightFactory {
    
    
private:
    std::unordered_map<std::string, std::shared_ptr<FlyWeight>> flyWeights;

public:
    std::shared_ptr<FlyWeight> getFlyWeight(const std::string& key) {
    
    
        // If the FlyWeight with the given key does not exist, create it
        if (flyWeights.find(key) == flyWeights.end()) {
    
    
            flyWeights[key] = std::make_shared<ConcreteFlyWeight>();
        }
        return flyWeights[key];
    }
};

// Client code to use FlyWeightFactory
int main() {
    
    
    int extrinsicState = 22;
    FlyWeightFactory factory;

    // Get and use shared FlyWeight objects
    std::shared_ptr<FlyWeight> fx = factory.getFlyWeight("X");
    fx->operation(--extrinsicState);

    std::shared_ptr<FlyWeight> fy = factory.getFlyWeight("Y");
    fy->operation(--extrinsicState);

    std::shared_ptr<FlyWeight> fz = factory.getFlyWeight("Z");
    fz->operation(--extrinsicState);

    // Get and use a non-shared FlyWeight object
    std::shared_ptr<FlyWeight> uf = std::make_shared<UnsharedConcreteFlyWeight>();
    uf->operation(--extrinsicState);

    return 0;
}

7、代理模式

代理模式，为其他对象提供一种代理以控制对这个对象的访问。

#include <iostream>
#include <memory>

// Subject interface shared by both RealSubject and Proxy
class Subject {
    
    
public:
    virtual ~Subject() = default;
    virtual void request() = 0;
};

// RealSubject class that implements the Subject interface
class RealSubject : public Subject {
    
    
public:
    void request() override {
    
    
        std::cout << "RealSubject's request" << std::endl;
    }
};

// Proxy class that implements the Subject interface and uses RealSubject
class Proxy : public Subject {
    
    
private:
    std::shared_ptr<Subject> subject;

public:
    Proxy() {
    
    
        subject = std::make_shared<RealSubject>();
    }

    void request() override {
    
    
        subject->request();
    }
};

// Client code to use Proxy and RealSubject
int main() {
    
    
    // Create Proxy object, which will delegate request to RealSubject
    Proxy proxy;
    proxy.request();  // This will call RealSubject's request

    return 0;
}

三、行为型模式

1、解释器模式

解释器模式，给定一个语言，定义它的文法的一种表示，并定义一个解释器，这个解释器使用该表示来解释语言中的句子。

#include <iostream>
#include <memory>
#include <vector>

// Context class, holds the global information
class Context {
    
    
private:
    std::string input;
    std::string output;

public:
    const std::string& getInput() const {
    
    
        return input;
    }

    void setInput(const std::string& input) {
    
    
        this->input = input;
    }

    const std::string& getOutput() const {
    
    
        return output;
    }

    void setOutput(const std::string& output) {
    
    
        this->output = output;
    }
};

// AbstractExpression class, declares the interpret method
class AbstractExpression {
    
    
public:
    virtual ~AbstractExpression() = default;
    virtual void interpret(Context& context) = 0;
};

// TerminalExpression class, represents terminal symbols in the grammar
class TerminalExpression : public AbstractExpression {
    
    
public:
    void interpret(Context& context) override {
    
    
        std::cout << "Terminal Interpreter" << std::endl;
    }
};

// NonTerminalExpression class, represents non-terminal symbols in the grammar
class NonTerminalExpression : public AbstractExpression {
    
    
public:
    void interpret(Context& context) override {
    
    
        std::cout << "Non-terminal Interpreter" << std::endl;
    }
};

// InterpreterClient (Client code)
int main() {
    
    
    Context context;

    // Create a list of AbstractExpressions
    std::vector<std::shared_ptr<AbstractExpression>> list;

    // Add different types of expressions to the list
    list.push_back(std::make_shared<TerminalExpression>());
    list.push_back(std::make_shared<NonTerminalExpression>());
    list.push_back(std::make_shared<TerminalExpression>());
    list.push_back(std::make_shared<TerminalExpression>());

    // Interpret each expression
    for (const auto& expression : list) {
    
    
        expression->interpret(context);
    }

    return 0;
}

2、模板方法模式

模板方法模式，定义一个操作中的算法的骨架，而将一些步骤延迟到子类中。模板方法使得子类可以不改变一个算法的结构即可重定义该算法的某些特定步骤。

#include <iostream>
#include <memory>

// AbstractTemplate class: Defines the template method and abstract operations
class AbstractTemplate {
    
    
public:
    virtual ~AbstractTemplate() = default;

    virtual void primitiveOperation1() = 0;  // Abstract method 1
    virtual void primitiveOperation2() = 0;  // Abstract method 2

    // Template method: Defines the structure of the algorithm
    void templateMethod() {
    
    
        primitiveOperation1();
        primitiveOperation2();
        std::cout << "Template Method Finished\n";
    }
};

// ConcreteClassA: Implements the abstract operations for Class A
class ConcreteClassA : public AbstractTemplate {
    
    
public:
    void primitiveOperation1() override {
    
    
        std::cout << "ConcreteClassA Method 1 Implementation\n";
    }

    void primitiveOperation2() override {
    
    
        std::cout << "ConcreteClassA Method 2 Implementation\n";
    }
};

// ConcreteClassB: Implements the abstract operations for Class B
class ConcreteClassB : public AbstractTemplate {
    
    
public:
    void primitiveOperation1() override {
    
    
        std::cout << "ConcreteClassB Method 1 Implementation\n";
    }

    void primitiveOperation2() override {
    
    
        std::cout << "ConcreteClassB Method 2 Implementation\n";
    }
};

// TemplateClient (Client code)
int main() {
    
    
    // Create instances of ConcreteClassA and ConcreteClassB
    std::unique_ptr<AbstractTemplate> abstractTemplate;

    abstractTemplate = std::make_unique<ConcreteClassA>();
    abstractTemplate->templateMethod();

    abstractTemplate = std::make_unique<ConcreteClassB>();
    abstractTemplate->templateMethod();

    return 0;
}

3、策略模式

场景：商场促销。简单工厂模式虽然也能解决这个问题，但这个模式只是解决对象的创建问题，而且由于工厂本身包括了所有的收费方式，商场是可能经常性地更改打折额度和返利额度，每次维护或扩展收费方式都要改动这个工厂。所以它不是最好的办法。

面对算法的时常变动，应该有更好的办法。

策略模式：它定义了算法家族，分别封装起来，让它们之间可以互相替换，此模式让算法的变化，不会影响到使用算法的客户。

#include <iostream>
#include <memory>

// Strategy Interface: Defines the algorithm interface
class Strategy {
    
    
public:
    virtual ~Strategy() = default;
    virtual void algorithmInterface() const = 0;
};

// ConcreteStrategyA: Implements the algorithm for Strategy A
class ConcreteStrategyA : public Strategy {
    
    
public:
    void algorithmInterface() const override {
    
    
        std::cout << "Concrete implementation of Strategy A\n";
    }
};

// ConcreteStrategyB: Implements the algorithm for Strategy B
class ConcreteStrategyB : public Strategy {
    
    
public:
    void algorithmInterface() const override {
    
    
        std::cout << "Concrete implementation of Strategy B\n";
    }
};

// ConcreteStrategyC: Implements the algorithm for Strategy C
class ConcreteStrategyC : public Strategy {
    
    
public:
    void algorithmInterface() const override {
    
    
        std::cout << "Concrete implementation of Strategy C\n";
    }
};

// Context: Holds a reference to a strategy and calls the strategy's algorithm
class Context {
    
    
private:
    std::shared_ptr<Strategy> strategy;

public:
    Context(std::shared_ptr<Strategy> strategy) : strategy(strategy) {
    
    }

    // Context Interface
    void contextInterface() const {
    
    
        strategy->algorithmInterface();
    }
};

// StrategyClient (Client code)
int main() {
    
    
    // Create contexts with different strategies
    std::shared_ptr<Strategy> strategyA = std::make_shared<ConcreteStrategyA>();
    Context contextA(strategyA);
    contextA.contextInterface();

    std::shared_ptr<Strategy> strategyB = std::make_shared<ConcreteStrategyB>();
    Context contextB(strategyB);
    contextB.contextInterface();

    std::shared_ptr<Strategy> strategyC = std::make_shared<ConcreteStrategyC>();
    Context contextC(strategyC);
    contextC.contextInterface();

    return 0;
}

4、观察者模式

观察者模式定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象。这个主题对象在状态发生变化时，会通知所有观察者对象，使它们能够自动更新自己。

#include <iostream>
#include <vector>
#include <memory>
#include <string>
#include <algorithm>

// 抽象观察者
class Observer {
    
    
public:
    virtual ~Observer() = default;
    virtual void update() = 0;
};

// 抽象主题（通知者）
class Subject {
    
    
protected:
    std::vector<std::shared_ptr<class Observer>> observers;

public:
    virtual ~Subject() = default;

    void attach(std::shared_ptr<class Observer> observer) {
    
    
        observers.push_back(observer);
    }

    void detach(std::shared_ptr<class Observer> observer) {
    
    
        observers.erase(std::remove(observers.begin(), observers.end(), observer), observers.end());
    }

    void notifyObservers() {
    
    
        for (auto& observer : observers) {
    
    
            observer->update();
        }
    }
};

// 具体主题（通知者）
class ConcreteSubject : public Subject {
    
    
private:
    std::string subjectState;

public:
    const std::string& getSubjectState() const {
    
    
        return subjectState;
    }

    void setSubjectState(const std::string& state) {
    
    
        subjectState = state;
    }
};

// 具体观察者
class ConcreteObserver : public Observer {
    
    
private:
    std::string name;
    std::string observerState;
    std::shared_ptr<ConcreteSubject> concreteSubject;

public:
    ConcreteObserver(std::shared_ptr<ConcreteSubject> subject, const std::string& name)
            : concreteSubject(subject), name(name) {
    
    }

    void update() override {
    
    
        observerState = concreteSubject->getSubjectState();
        std::cout << "Observer " << name << "'s new state is: " << observerState << std::endl;
    }

    const std::string& getName() const {
    
    
        return name;
    }

    void setName(const std::string& newName) {
    
    
        name = newName;
    }

    const std::string& getObserverState() const {
    
    
        return observerState;
    }

    void setObserverState(const std::string& newState) {
    
    
        observerState = newState;
    }

    std::shared_ptr<ConcreteSubject> getConcreteSubject() const {
    
    
        return concreteSubject;
    }

    void setConcreteSubject(std::shared_ptr<ConcreteSubject> subject) {
    
    
        concreteSubject = subject;
    }
};

// 观察者模式客户端
int main() {
    
    
    auto concreteSubject = std::make_shared<ConcreteSubject>();

    auto observer1 = std::make_shared<ConcreteObserver>(concreteSubject, "X");
    auto observer2 = std::make_shared<ConcreteObserver>(concreteSubject, "Y");
    auto observer3 = std::make_shared<ConcreteObserver>(concreteSubject, "Z");

    concreteSubject->attach(observer1);
    concreteSubject->attach(observer2);
    concreteSubject->attach(observer3);

    concreteSubject->setSubjectState("ABC");
    concreteSubject->notifyObservers();

    return 0;
}

在上面的代码中，ConcreteObserver 持有对 ConcreteSubject 的 shared_ptr，而 ConcreteSubject 又持有对 Observer（包括 ConcreteObserver）的 shared_ptr。这种结构可能会导致循环引用，因为：

1. ConcreteSubject 持有对 Observer 的 shared_ptr，意味着如果 ConcreteSubject 被销毁，那么它的观察者仍然会持有 ConcreteSubject 的 shared_ptr，从而阻止 ConcreteSubject 的销毁。
2. ConcreteObserver 持有对 ConcreteSubject 的 shared_ptr，如果 ConcreteObserver 被销毁，它的 shared_ptr 仍然引用 ConcreteSubject，这样又会阻止 ConcreteObserver 的销毁。

• 如何避免循环引用：

1. 使用 weak_ptr：weak_ptr 是一种智能指针，它不会增加引用计数，因此避免了循环引用。您可以将 ConcreteObserver 中对 ConcreteSubject 的 shared_ptr 改为 weak_ptr。这样，ConcreteObserver 不再直接影响 ConcreteSubject 的生命周期，避免了循环引用问题。

• 修改后的代码：

#include <iostream>
#include <vector>
#include <memory>
#include <string>
#include <algorithm>

// 抽象观察者
class Observer {
    
    
public:
    virtual ~Observer() = default;
    virtual void update() = 0;
};

// 抽象主题（通知者）
class Subject {
    
    
protected:
    std::vector<std::shared_ptr<class Observer>> observers;

public:
    virtual ~Subject() = default;

    void attach(std::shared_ptr<class Observer> observer) {
    
    
        observers.push_back(observer);
    }

    void detach(std::shared_ptr<class Observer> observer) {
    
    
        observers.erase(std::remove(observers.begin(), observers.end(), observer), observers.end());
    }

    void notifyObservers() {
    
    
        for (auto& observer : observers) {
    
    
            observer->update();
        }
    }
};

// 具体主题（通知者）
class ConcreteSubject : public Subject {
    
    
private:
    std::string subjectState;

public:
    const std::string& getSubjectState() const {
    
    
        return subjectState;
    }

    void setSubjectState(const std::string& state) {
    
    
        subjectState = state;
    }
};

// 具体观察者
class ConcreteObserver : public Observer {
    
    
private:
    std::string name;
    std::string observerState;
    std::weak_ptr<ConcreteSubject> concreteSubject; // 使用 weak_ptr

public:
    ConcreteObserver(std::shared_ptr<ConcreteSubject> subject, const std::string& name)
            : concreteSubject(subject), name(name) {
    
    }

    void update() override {
    
    
        if (auto subject = concreteSubject.lock()) {
    
     // 检查 subject 是否还有效
            observerState = subject->getSubjectState();
            std::cout << "Observer " << name << "'s new state is: " << observerState << std::endl;
        }
    }

    const std::string& getName() const {
    
    
        return name;
    }

    void setName(const std::string& newName) {
    
    
        name = newName;
    }

    const std::string& getObserverState() const {
    
    
        return observerState;
    }

    void setObserverState(const std::string& newState) {
    
    
        observerState = newState;
    }

    std::shared_ptr<ConcreteSubject> getConcreteSubject() const {
    
    
        return concreteSubject.lock(); // 使用 weak_ptr.lock() 获取 shared_ptr
    }

    void setConcreteSubject(std::shared_ptr<ConcreteSubject> subject) {
    
    
        concreteSubject = subject;
    }
};

// 观察者模式客户端
int main() {
    
    
    auto concreteSubject = std::make_shared<ConcreteSubject>();

    auto observer1 = std::make_shared<ConcreteObserver>(concreteSubject, "X");
    auto observer2 = std::make_shared<ConcreteObserver>(concreteSubject, "Y");
    auto observer3 = std::make_shared<ConcreteObserver>(concreteSubject, "Z");

    concreteSubject->attach(observer1);
    concreteSubject->attach(observer2);
    concreteSubject->attach(observer3);

    concreteSubject->setSubjectState("ABC");
    concreteSubject->notifyObservers();

    return 0;
}

5、状态模式

状态模式，当一个对象的内在状态改变时允许改变其行为，这个对象看起来像是改变了其类。

#include <iostream>
#include <memory>

class Context;
class ConcreteStateB;  // 前向声明
class ConcreteStateC;  // 前向声明

// 抽象状态类
class State {
    
    
public:
    virtual ~State() = default;
    virtual void handle(class Context* context) = 0;
};

// Context类，维护一个ConcreteState子类的实例
class Context {
    
    
private:
    std::shared_ptr<State> state;

public:
    Context(std::shared_ptr<State> initialState) : state(initialState) {
    
    }

    std::shared_ptr<State> getState() {
    
    
        return state;
    }

    void setState(std::shared_ptr<State> newState) {
    
    
        state = newState;
    }

    void request() {
    
    
        state->handle(this);
    }
};

// 具体状态A
class ConcreteStateA : public State {
    
    
public:
    void handle(Context* context) override {
    
    
        std::cout << "Now in state A" << std::endl;
        // context->setState(std::make_shared<ConcreteStateB>());
        context->setState(std::static_pointer_cast<State>(std::make_shared<ConcreteStateB>()));

    }
};

// 具体状态B
class ConcreteStateB : public State {
    
    
public:
    void handle(Context* context) override {
    
    
        std::cout << "Now in state B" << std::endl;
        // context->setState(std::make_shared<ConcreteStateC>());
        context->setState(std::static_pointer_cast<State>(std::make_shared<ConcreteStateC>()));
    }
};

// 具体状态C
class ConcreteStateC : public State {
    
    
public:
    void handle(Context* context) override {
    
    
        std::cout << "Now in state C" << std::endl;
        context->setState(std::make_shared<ConcreteStateA>());
    }
};

// 客户端：不断请求，不断更改状态
int main() {
    
    
    // 初始化状态为 ConcreteStateA
    auto context = std::make_shared<Context>(std::make_shared<ConcreteStateA>());

    // 模拟请求，不断转换状态
    context->request(); // 当前状态为A，切换到B
    context->request(); // 当前状态为B，切换到C
    context->request(); // 当前状态为C，切换到A
    context->request(); // 当前状态为A，切换到B
    context->request(); // 当前状态为B，切换到C

    return 0;
}

6、备忘录模式

备忘录：在不破坏封装性的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态。这样以后就可将该对象恢复到原先保存的状态。

#include <iostream>
#include <memory>
#include <string>

// 发起人（Originator）类
class Originator {
    
    
private:
    std::string state;

public:
    // 创建备忘录
    class Memento {
    
    
    private:
        std::string state;

    public:
        Memento(const std::string& state) : state(state) {
    
    }
        std::string getState() const {
    
    
            return state;
        }
    };

    // 创建备忘录
    std::shared_ptr<Memento> createMemento() {
    
    
        return std::make_shared<Memento>(this->state);
    }

    // 恢复备忘录中的状态
    void recoverMemento(std::shared_ptr<Memento> memento) {
    
    
        this->state = memento->getState();
    }

    // 显示当前状态
    void show() const {
    
    
        std::cout << "state = " << this->state << std::endl;
    }

    // 设置状态
    void setState(const std::string& state) {
    
    
        this->state = state;
    }

    // 获取当前状态
    std::string getState() const {
    
    
        return state;
    }
};

// 管理者（CareTaker）类
class CareTaker {
    
    
private:
    std::shared_ptr<Originator::Memento> memento;

public:
    // 获取备忘录
    std::shared_ptr<Originator::Memento> getMemento() const {
    
    
        return memento;
    }

    // 设置备忘录
    void setMemento(std::shared_ptr<Originator::Memento> memento) {
    
    
        this->memento = memento;
    }
};

// 客户端
int main() {
    
    
    // 设置初始状态
    Originator originator;
    originator.setState("On");
    originator.show();

    // 管理者通过备忘录保存状态
    CareTaker careTaker;
    careTaker.setMemento(originator.createMemento());

    // 改变状态
    originator.setState("Off");
    originator.show();

    // 通过管理者从备忘录中恢复状态
    originator.recoverMemento(careTaker.getMemento());
    originator.show();

    return 0;
}

7、迭代器模式

迭代器模式，提供一种方法顺序访问一个聚合对象中各个元素，而又不暴露该对象的内部表示。

#include <iostream>
#include <vector>
#include <memory>
#include <string>

// 迭代器接口
template <typename T>
class Iterator {
    
    
public:
    virtual ~Iterator() = default;
    virtual T first() = 0;
    virtual T next() = 0;
    virtual bool isDone() const = 0;
    virtual T currentItem() const = 0;
};

// 聚集接口
template <typename T>
class Aggregate {
    
    
public:
    virtual ~Aggregate() = default;
    virtual class Iterator<T>* createIterator() = 0;
};

// 具体聚集类
template <typename T>
class ConcreteAggregate : public Aggregate<T> {
    
    
private:
    std::vector<T> items;

public:
    // 创建迭代器
    class Iterator<T>* createIterator() override;

    int count() const {
    
    
        return items.size();
    }

    T getItems(int index) const {
    
    
        return items[index];
    }

    void setItems(const T& item) {
    
    
        items.push_back(item);
    }
};

// 具体迭代器类
template <typename T>
class ConcreteIterator : public Iterator<T> {
    
    
private:
    ConcreteAggregate<T>* concreteAggregate;
    int current = 0;

public:
    ConcreteIterator(ConcreteAggregate<T>* concreteAggregate)
            : concreteAggregate(concreteAggregate) {
    
    }

    T first() override {
    
    
        return concreteAggregate->getItems(0);
    }

    T next() override {
    
    
        current++;
        if (current < concreteAggregate->count()) {
    
    
            return concreteAggregate->getItems(current);
        }
        return T();  // 返回默认值
    }

    bool isDone() const override {
    
    
        return current >= concreteAggregate->count();
    }

    T currentItem() const override {
    
    
        return concreteAggregate->getItems(current);
    }
};

// ConcreteAggregate 的 createIterator 实现
template <typename T>
class Iterator<T>* ConcreteAggregate<T>::createIterator() {
    
    
    return new ConcreteIterator<T>(this);
}

// 迭代器客户端
int main() {
    
    
    ConcreteAggregate<std::string> bus;

    // 大鸟
    bus.setItems("Big Bird");
    // 小菜
    bus.setItems("Small Dish");
    // 行李
    bus.setItems("Luggage");
    // 老外
    bus.setItems("Foreigner");
    // 公交内部员工
    bus.setItems("Bus Internal Staff");
    // 小偷
    bus.setItems("Thief");

    std::unique_ptr<Iterator<std::string>> iterator(bus.createIterator());

    while (!iterator->isDone()) {
    
    
        std::cout << iterator->currentItem() << " please buy a ticket!" << std::endl;
        iterator->next();
    }

    return 0;
}

8、命令模式

命令模式，将一个请求封装为一个对象，从而使你可用不同的请求对客户进行参数化：对请求排队或记录请求日志，以 及支持可撤销的操作。

#include <iostream>
#include <vector>
#include <memory>

// 接收者接口
class Reciever {
    
    
public:
    virtual ~Reciever() = default;
    virtual void action() const = 0;
};

class RecieverA : public Reciever {
    
    
public:
    void action() const override {
    
    
        std::cout << "RecieverA execute the request!" << std::endl;
    }
};

class RecieverB : public Reciever {
    
    
public:
    void action() const override {
    
    
        std::cout << "RecieverB execute the request!" << std::endl;
    }
};

class RecieverC : public Reciever {
    
    
public:
    void action() const override {
    
    
        std::cout << "RecieverC execute the request!" << std::endl;
    }
};

// 命令接口
class Command {
    
    
protected:
    std::vector<std::shared_ptr<Reciever>> recievers;

public:
    virtual ~Command() = default;
    virtual void execute() const = 0;

    void addReciever(const std::shared_ptr<Reciever>& reciever) {
    
    
        recievers.push_back(reciever);
    }
};

// 具体命令类
class ConcreteCommand : public Command {
    
    
public:
    ConcreteCommand(const std::vector<std::shared_ptr<Reciever>>& recievers) {
    
    
        this->recievers = recievers;
    }

    void execute() const override {
    
    
        for (const auto& reciever : recievers) {
    
    
            reciever->action();
        }
    }
};

// 调用者类
class Invoker {
    
    
private:
    std::shared_ptr<Command> command;

public:
    void setCommand(const std::shared_ptr<Command>& command) {
    
    
        this->command = command;
    }

    void executeCommand() const {
    
    
        command->execute();
    }
};

// 客户端
int main() {
    
    
    std::vector<std::shared_ptr<Reciever>> recievers;
    recievers.push_back(std::make_shared<RecieverA>());
    recievers.push_back(std::make_shared<RecieverB>());
    recievers.push_back(std::make_shared<RecieverC>());

    std::shared_ptr<Command> command = std::make_shared<ConcreteCommand>(recievers);
    Invoker invoker;
    invoker.setCommand(command);
    invoker.executeCommand();

    return 0;
}

9、责任链模式

责任链模式，使多个对象都有机会处理请求，从而避免请求的发送者和接收者之间的耦合关系。将这个对象连成一条链，并沿着这条链传递该请求，直到有一个对象处理它为止。

#include <iostream>
#include <vector>
#include <memory>

// 处理请求的接口
class Handler {
    
    
protected:
    std::shared_ptr<Handler> successor;

public:
    virtual ~Handler() = default;

    void setSuccessor(const std::shared_ptr<Handler>& successor) {
    
    
        this->successor = successor;
    }

    virtual void handleRequest(int request) = 0;
};

// 具体处理者A
class ConcreteHandlerA : public Handler {
    
    
public:
    void handleRequest(int request) override {
    
    
        if (request >= 0 && request <= 10) {
    
    
            std::cout << typeid(*this).name() << " processed the request " << request << std::endl;
        } else if (successor != nullptr) {
    
    
            successor->handleRequest(request);
        }
    }
};

// 具体处理者B
class ConcreteHandlerB : public Handler {
    
    
public:
    void handleRequest(int request) override {
    
    
        if (request > 10 && request <= 20) {
    
    
            std::cout << typeid(*this).name() << " processed the request " << request << std::endl;
        } else if (successor != nullptr) {
    
    
            successor->handleRequest(request);
        }
    }
};

// 具体处理者C
class ConcreteHandlerC : public Handler {
    
    
public:
    void handleRequest(int request) override {
    
    
        if (request > 20 && request <= 30) {
    
    
            std::cout << typeid(*this).name() << " processed the request " << request << std::endl;
        } else if (successor != nullptr) {
    
    
            successor->handleRequest(request);
        }
    }
};

// 客户端
int main() {
    
    
    std::shared_ptr<Handler> handlerA = std::make_shared<ConcreteHandlerA>();
    std::shared_ptr<Handler> handlerB = std::make_shared<ConcreteHandlerB>();
    std::shared_ptr<Handler> handlerC = std::make_shared<ConcreteHandlerC>();

    handlerA->setSuccessor(handlerB);
    handlerB->setSuccessor(handlerC);

    std::vector<int> requests = {
    
    2, 14, 5, 6, 8, 23, 12, 21};

    for (int request : requests) {
    
    
        handlerA->handleRequest(request);
    }

    return 0;
}

10、中介者模式

中介者模式，用一个中介对象来封装一系列的对象交互。中介者使各对象不需要显式地相互引用，从而使其耦合松散，而且可以独立地改变它们之间的交互。

#include <iostream>
#include <string>
#include <memory>

class Colleague;

// 抽象中介者类
class Mediator {
    
    
public:
    virtual ~Mediator() = default;
    virtual void send(const std::string& message, Colleague* colleague) = 0;
};

class Colleague {
    
    
protected:
    std::shared_ptr<Mediator> mediator;

public:
    Colleague(std::shared_ptr<Mediator> mediator) : mediator(mediator) {
    
    }
    virtual ~Colleague() = default;
    virtual void sendMsg(const std::string& message) = 0;
    virtual void notifyMsg(const std::string& message) = 0;
};

// 具体同事类1
class ConcreteColleague1 : public Colleague {
    
    
public:
    ConcreteColleague1(std::shared_ptr<Mediator> mediator) : Colleague(mediator) {
    
    }

    void sendMsg(const std::string& message) override {
    
    
        mediator->send(message, this);
    }

    void notifyMsg(const std::string& message) override {
    
    
        std::cout << "Colleague 1 got the message:" << message << std::endl;
    }
};

// 具体同事类2
class ConcreteColleague2 : public Colleague {
    
    
public:
    ConcreteColleague2(std::shared_ptr<Mediator> mediator) : Colleague(mediator) {
    
    }

    void sendMsg(const std::string& message) override {
    
    
        mediator->send(message, this);
    }

    void notifyMsg(const std::string& message) override {
    
    
        std::cout << "Colleague 2 got the message:" << message << std::endl;
    }
};

// 具体中介者类
class ConcreteMediator : public Mediator {
    
    
private:
    std::shared_ptr<ConcreteColleague1> c1;
    std::shared_ptr<ConcreteColleague2> c2;

public:
    void setC1(std::shared_ptr<ConcreteColleague1> colleague) {
    
    
        c1 = colleague;
    }

    void setC2(std::shared_ptr<ConcreteColleague2> colleague) {
    
    
        c2 = colleague;
    }

    void send(const std::string& message, Colleague* colleague) override {
    
    
        if (colleague == c1.get()) {
    
    
            c2->notifyMsg(message);
        } else {
    
    
            c1->notifyMsg(message);
        }
    }
};

// 客户端
int main() {
    
    
    // 创建中介者
    std::shared_ptr<ConcreteMediator> concreteMediator = std::make_shared<ConcreteMediator>();

    // 创建具体同事类对象并让它们知道中介者
    std::shared_ptr<ConcreteColleague1> concreteColleague1 = std::make_shared<ConcreteColleague1>(concreteMediator);
    std::shared_ptr<ConcreteColleague2> concreteColleague2 = std::make_shared<ConcreteColleague2>(concreteMediator);

    // 让中介者知道具体同事类对象
    concreteMediator->setC1(concreteColleague1);
    concreteMediator->setC2(concreteColleague2);

    // 发送消息
    concreteColleague1->sendMsg("Have you eaten?");
    concreteColleague2->sendMsg("No, are you planning to treat us?");

    return 0;
}

11、访问者模式

访问者模式，表示一个作用于某对象结构中的各元素的操作。它使你可以在不改变各元素的类的前提下定义作用于这些元素的新操作。

#include <iostream>
#include <vector>
#include <memory>
#include <algorithm>

class Visitor;

// 抽象元素类
class Element {
    
    
public:
    virtual ~Element() = default;

    virtual void accept(Visitor *visitor) = 0;

    virtual std::string getName() = 0;
};

// 抽象访问者类
class ConcreteElementA; // 前向声明
class ConcreteElementB; // 前向声明

class Visitor {
    
    
public:
    virtual ~Visitor() = default;

    virtual void visitConcreteElementA(ConcreteElementA *concreteElementA) = 0;

    virtual void visitConcreteElementB(ConcreteElementB *concreteElementB) = 0;
};

// 具体元素A
class ConcreteElementA : public Element {
    
    
public:
    void accept(Visitor *visitor) override {
    
    
        visitor->visitConcreteElementA(this);
    }

    std::string getName() override {
    
    
        return "ConcreteElementA";
    }
};

// 具体元素B
class ConcreteElementB : public Element {
    
    
public:
    void accept(Visitor *visitor) override {
    
    
        visitor->visitConcreteElementB(this);
    }

    std::string getName() override {
    
    
        return "ConcreteElementB";
    }
};

// 具体访问者1
class ConcreteVisitor1 : public Visitor {
    
    
public:
    void visitConcreteElementA(ConcreteElementA *concreteElementA) override {
    
    
        std::cout << concreteElementA->getName() << " be " << this->getName() << " Visited" << std::endl;
    }

    void visitConcreteElementB(ConcreteElementB *concreteElementB) override {
    
    
        std::cout << concreteElementB->getName() << " be " << this->getName() << " Visited" << std::endl;
    }

    std::string getName() {
    
    
        return "ConcreteVisitor1";
    }
};

// 具体访问者2
class ConcreteVisitor2 : public Visitor {
    
    
public:
    void visitConcreteElementA(ConcreteElementA *concreteElementA) override {
    
    
        std::cout << concreteElementA->getName() << " be " << this->getName() << " Visited" << std::endl;
    }

    void visitConcreteElementB(ConcreteElementB *concreteElementB) override {
    
    
        std::cout << concreteElementB->getName() << " be " << this->getName() << " Visited" << std::endl;
    }

    std::string getName() {
    
    
        return "ConcreteVisitor2";
    }
};

// 对象结构类
class ObjectStructure {
    
    
private:
    std::vector<std::shared_ptr<Element>> elements;

public:
    void attach(std::shared_ptr<Element> element) {
    
    
        elements.push_back(element);
    }

    void detach(std::shared_ptr<Element> element) {
    
    
        elements.erase(std::remove(elements.begin(), elements.end(), element), elements.end());
    }

    void accept(Visitor *visitor) {
    
    
        for (auto &element: elements) {
    
    
            element->accept(visitor);
        }
    }
};

// 客户端
int main() {
    
    
    ObjectStructure o;

    o.attach(std::make_shared<ConcreteElementA>());
    o.attach(std::make_shared<ConcreteElementB>());

    ConcreteVisitor1 visitor1;
    ConcreteVisitor2 visitor2;

    std::cout << "Use visitor 1 to access the elements:" << std::endl;
    o.accept(&visitor1);

    std::cout << "\nUse visitor 2 to access the elements:" << std::endl;
    o.accept(&visitor2);

    return 0;
}

提示：更多内容可以访问Clang’s Blog：https://www.clang.asia