BLOG

class Employee {
public:
    std::string name;
    Employee(const std::string& name) : name(name) {}
};

class Company {
private:
    std::vector<Employee> employees; // 关联：Company 拥有 Employee 对象

public:
    void addEmployee(const Employee& employee) {
        employees.push_back(employee);
    }
};

class Document {
public:
    std::string content;
    Document(const std::string& content) : content(content) {}
};

class Printer {
public:
    void printDocument(const Document& doc) { // 依赖：Printer 使用 Document 对象
        std::cout << "Printing: " << doc.content << std::endl;
    }
};

cpp
Copy code
class Teacher {
public:
    std::string name;
    Teacher(const std::string& name) : name(name) {}
};

class School {
private:
    std::vector<Teacher*> teachers; // 聚合关系：School 拥有 Teacher 指针，但不负责其生命周期

public:
    void addTeacher(Teacher* teacher) {
        teachers.push_back(teacher);
    }
};

class Heart {
public:
    void beat() {
        std::cout << "Heart is beating..." << std::endl;
    }
};

class Person {
private:
    Heart heart; // 组合关系：Person 包含 Heart，并负责其生命周期

public:
    void live() {
        heart.beat();
    }
};

#include <iostream>

// 抽象产品类
class Product {
public:
    virtual void Operation() const = 0;
    virtual ~Product() {}
};

// 具体产品类1
class ConcreteProduct1 : public Product {
public:
    void Operation() const override {
        std::cout << "Operation of ConcreteProduct1" << std::endl;
    }
};

// 具体产品类3（似乎是应该有ConcreteProduct2，这里直接跳到ConcreteProduct3）
class ConcreteProduct3 : public Product {
public:
    void Operation() const override {
        std::cout << "Operation of ConcreteProduct3" << std::endl;
    }
};

// 抽象工厂类
class Factory {
public:
    virtual Product* CreateProduct() const = 0;
    virtual ~Factory() {}
};

// 具体工厂类
class ConcreteFactory : public Factory {
public:
    Product* CreateProduct() const override {
        // 根据需要创建不同的产品实例
        return new ConcreteProduct1(); // 或者根据某些条件返回 ConcreteProduct3
    }
};

int main() {
    // 创建具体工厂对象
    const Factory* factory = new ConcreteFactory();

    // 使用工厂创建产品对象
    const Product* product = factory->CreateProduct();
    product->Operation();

    // 释放资源
    delete product;
    delete factory;

    return 0;
}

#include <iostream>

// 抽象产品A的接口
class AbstractProductA {
public:
    virtual void Operation() const = 0;
    virtual ~AbstractProductA() {}
};

// 抽象产品B的接口
class AbstractProductB {
public:
    virtual void Operation() const = 0;
    virtual ~AbstractProductB() {}
};

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

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

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

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

// 抽象工厂接口
class AbstractFactory {
public:
    virtual AbstractProductA* CreateProductA() const = 0;
    virtual AbstractProductB* CreateProductB() const = 0;
    virtual ~AbstractFactory() {}
};

// 具体工厂1
class ConcreteFactory1 : public AbstractFactory {
public:
    AbstractProductA* CreateProductA() const override {
        return new ProductA1();
    }
    AbstractProductB* CreateProductB() const override {
        return new ProductB1();
    }
};

// 具体工厂2
class ConcreteFactory2 : public AbstractFactory {
public:
    AbstractProductA* CreateProductA() const override {
        return new ProductA2();
    }
    AbstractProductB* CreateProductB() const override {
        return new ProductB2();
    }
};

// 客户端代码
int main() {
    AbstractFactory* factory1 = new ConcreteFactory1();
    AbstractProductA* productA = factory1->CreateProductA();
    AbstractProductB* productB = factory1->CreateProductB();

    productA->Operation();
    productB->Operation();

    delete productA;
    delete productB;
    delete factory1;

    AbstractFactory* factory2 = new ConcreteFactory2();
    productA = factory2->CreateProductA();
    productB = factory2->CreateProductB();

    productA->Operation();
    productB->Operation();

    delete productA;
    delete productB;
    delete factory2;

    return 0;
}

#include <iostream>
#include <mutex>

class Singleton {
private:
    static Singleton* instance;
    static std::mutex mutex;

protected:
    // 构造函数为 protected，防止外部构造
    Singleton() {
        std::cout << "Singleton created." << std::endl;
    }

public:
    // 禁止拷贝构造函数和赋值操作
    Singleton(const Singleton&) = delete;
    Singleton& operator=(const Singleton&) = delete;

    // 静态方法用于访问类的实例
    static Singleton* getInstance() {
        std::lock_guard<std::mutex> lock(mutex);
        if (instance == nullptr) {
            instance = new Singleton();
        }
        return instance;
    }

    void doSomething() {
        std::cout << "Doing something." << std::endl;
    }
};

// 初始化静态成员变量
Singleton* Singleton::instance = nullptr;
std::mutex Singleton::mutex;

int main() {
    // 获取单例对象并调用方法
    Singleton* singleton = Singleton::getInstance();
    singleton->doSomething();

    return 0;
}

#include <iostream>
#include <string>

// 产品类
class Product {
public:
    void addPart(const std::string& part) {
        std::cout << "Part " << part << " added." << std::endl;
    }

    void show() {
        std::cout << "Product completed!" << std::endl;
    }
};

// 抽象建造者类
class Builder {
public:
    virtual ~Builder() {}
    virtual void buildPartA() = 0;
    virtual void buildPartB() = 0;
    virtual void buildPartC() = 0;
    virtual Product* getProduct() = 0;
};

// 具体建造者类
class ConcreteBuilder : public Builder {
private:
    Product* product;

public:
    ConcreteBuilder() {
        product = new Product();
    }

    ~ConcreteBuilder() {
        delete product;
    }

    void buildPartA() override {
        product->addPart("A");
    }

    void buildPartB() override {
        product->addPart("B");
    }

    void buildPartC() override {
        product->addPart("C");
    }

    Product* getProduct() override {
        return product;
    }
};

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

public:
    Director(Builder* bldr) : builder(bldr) {}

    void construct() {
        builder->buildPartA();
        builder->buildPartB();
        builder->buildPartC();
    }
};

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

    director.construct();
    Product* product = builder.getProduct();
    product->show();

    return 0;
}

#include <iostream>
#include <memory>
using namespace std;

// 抽象原型类
class Prototype {
public:
    virtual ~Prototype() {}
    virtual unique_ptr<Prototype> clone() = 0;
};

// 具体原型类
class ConcretePrototype : public Prototype {
private:
    int value;

public:
    ConcretePrototype(int val) : value(val) {}
    ConcretePrototype(const ConcretePrototype& other) : value(other.value) {}

    unique_ptr<Prototype> clone() override {
        return make_unique<ConcretePrototype>(*this);
    }

    void setValue(int val) {
        value = val;
    }

    int getValue() const {
        return value;
    }
};

// 客户端代码
int main() {
    unique_ptr<Prototype> prototype = make_unique<ConcretePrototype>(100);
    unique_ptr<Prototype> clonedPrototype = prototype->clone();

    ConcretePrototype* concretePrototype = dynamic_cast<ConcretePrototype*>(clonedPrototype.get());
    if (concretePrototype) {
        cout << "Cloned value: " << concretePrototype->getValue() << endl;
    }

    return 0;
}

#include <iostream>
using namespace std;

// 实现接口
class AbstractionImp {
public:
    virtual void operation() = 0;
    virtual ~AbstractionImp() {}
};

// 具体实现A
class ConcreteAbstractionImpA : public AbstractionImp {
public:
    void operation() override {
        cout << "ConcreteAbstractionImpA operation." << endl;
    }
};

// 具体实现B
class ConcreteAbstractionImpB : public AbstractionImp {
public:
    void operation() override {
        cout << "ConcreteAbstractionImpB operation." << endl;
    }
};

// 抽象类
class Abstraction {
protected:
    AbstractionImp* imp;
public:
    Abstraction(AbstractionImp* implementation) : imp(implementation) {}
    virtual void operation() = 0;
    virtual ~Abstraction() {}
};

// 细化抽象
class RefinedAbstraction : public Abstraction {
public:
    RefinedAbstraction(AbstractionImp* implementation) : Abstraction(implementation) {}
    void operation() override {
        cout << "RefinedAbstraction: ";
        imp->operation();
    }
};

// 客户端代码
int main() {
    AbstractionImp* impA = new ConcreteAbstractionImpA();
    AbstractionImp* impB = new ConcreteAbstractionImpB();

    Abstraction* abstractionA = new RefinedAbstraction(impA);
    Abstraction* abstractionB = new RefinedAbstraction(impB);

    abstractionA->operation();
    abstractionB->operation();

    delete abstractionA;
    delete abstractionB;
    delete impA;
    delete impB;

    return 0;
}

#include <iostream>
using namespace std;

// 目标接口（Target）
class Target {
public:
    virtual void Request() {
        cout << "Target: Default request." << endl;
    }
};

// 适配者类（Adaptee）
class Adaptee {
public:
    void SpecificRequest() {
        cout << "Adaptee: Specific request." << endl;
    }
};

// 适配器类（Adapter），继承自Target和Adaptee
class Adapter : public Target, private Adaptee {
public:
    void Request() override {
        // 调用适配者的特定方法
        SpecificRequest();
    }
};

// 客户端代码
int main() {
    Target* target = new Adapter();
    target->Request();  // 输出: Adaptee: Specific request.
    delete target;
    return 0;
}

#include <iostream>
using namespace std;

// 目标接口（Target）
class Target {
public:
    virtual void Request() {
        cout << "Target: Default request." << endl;
    }
};

// 适配者类（Adaptee）
class Adaptee {
public:
    void SpecificRequest() {
        cout << "Adaptee: Specific request." << endl;
    }
};

// 适配器类（Adapter），组合一个Adaptee对象
class Adapter : public Target {
private:
    Adaptee* adaptee;  // 组合适配者类
public:
    Adapter(Adaptee* a) : adaptee(a) {}

    void Request() override {
        // 调用适配者的特定方法
        adaptee->SpecificRequest();
    }
};

// 客户端代码
int main() {
    Adaptee* adaptee = new Adaptee();
    Target* target = new Adapter(adaptee);
    target->Request();  // 输出: Adaptee: Specific request.
    delete adaptee;
    delete target;
    return 0;
}

#include <iostream>
using namespace std;

// 抽象组件类（Component）
class Component {
public:
    virtual void Operation() = 0; // 抽象操作方法
    virtual ~Component() {}
};

// 具体组件类（ConcreteComponent）
class ConcreteComponent : public Component {
public:
    void Operation() override {
        cout << "ConcreteComponent: 执行基础操作。" << endl;
    }
};

// 抽象装饰器类（Decorator）
class Decorator : public Component {
protected:
    Component* component;  // 维护一个Component的引用
public:
    Decorator(Component* c) : component(c) {}
    
    void Operation() override {
        if (component) {
            component->Operation();
        }
    }
};

// 具体装饰器类（ConcreteDecorator）
class ConcreteDecorator : public Decorator {
public:
    ConcreteDecorator(Component* c) : Decorator(c) {}

    void Operation() override {
        Decorator::Operation();  // 调用原始组件的操作
        AddedBehavior();         // 增加的新行为
    }

    void AddedBehavior() {
        cout << "ConcreteDecorator: 添加额外的行为。" << endl;
    }
};

// 客户端代码
int main() {
    Component* component = new ConcreteComponent();
    Component* decorator = new ConcreteDecorator(component);

    decorator->Operation();  // 输出：执行基础操作，添加额外的行为

    delete decorator;
    delete component;
    return 0;
}

#include <iostream>
#include <vector>
using namespace std;

// 抽象组件类（Component）
class Component {
public:
    virtual void Operation() = 0;  // 纯虚函数，定义操作
    virtual void Add(Component* component) {
        throw std::runtime_error("Add operation not supported.");
    }
    virtual void Remove(Component* component) {
        throw std::runtime_error("Remove operation not supported.");
    }
    virtual Component* GetChild(int index) {
        throw std::runtime_error("GetChild operation not supported.");
    }
    virtual ~Component() {}
};

// 叶子节点类（Leaf）
class Leaf : public Component {
public:
    void Operation() override {
        cout << "Leaf: Performing operation." << endl;
    }
};

// 组合节点类（Composite），可以包含多个子节点
class Composite : public Component {
private:
    vector<Component*> children;  // 存储子组件的集合
public:
    void Operation() override {
        cout << "Composite: Performing operation on children." << endl;
        for (auto child : children) {
            child->Operation();  // 递归调用子组件的操作
        }
    }

    void Add(Component* component) override {
        children.push_back(component);
    }

    void Remove(Component* component) override {
        auto it = std::find(children.begin(), children.end(), component);
        if (it != children.end()) {
            children.erase(it);
        }
    }

    Component* GetChild(int index) override {
        if (index < children.size()) {
            return children[index];
        }
        return nullptr;
    }
};

// 客户端代码
int main() {
    Component* leaf1 = new Leaf();
    Component* leaf2 = new Leaf();
    Component* composite1 = new Composite();

    // 将叶子节点添加到组合中
    composite1->Add(leaf1);
    composite1->Add(leaf2);

    // 执行组合的操作
    composite1->Operation();

    // 清理内存
    delete leaf1;
    delete leaf2;
    delete composite1;

    return 0;
}

#include <iostream>
#include <unordered_map>
#include <string>
using namespace std;

// 享元基类（Flyweight）
class Flyweight {
public:
    virtual void Operation(const string& extrinsicState) = 0;  // 接收外部状态
    virtual ~Flyweight() {}
};

// 具体享元类（ConcreteFlyweight），实现共享的操作
class ConcreteFlyweight : public Flyweight {
private:
    string intrinsicState;  // 内部状态（共享部分）
public:
    ConcreteFlyweight(const string& state) : intrinsicState(state) {}
    
    void Operation(const string& extrinsicState) override {
        cout << "具体享元: 内部状态 = " << intrinsicState 
             << ", 外部状态 = " << extrinsicState << endl;
    }
};

// 不共享的享元类（UnsharedConcreteFlyweight），每个实例都有自己独立的状态
class UnsharedConcreteFlyweight : public Flyweight {
public:
    void Operation(const string& extrinsicState) override {
        cout << "不共享的享元: 外部状态 = " << extrinsicState << endl;
    }
};

// 享元工厂类（FlyweightFactory）
class FlyweightFactory {
private:
    unordered_map<string, Flyweight*> flyweights;  // 享元池
public:
    ~FlyweightFactory() {
        for (auto pair : flyweights) {
            delete pair.second;
        }
    }

    // 获取享元对象，如果不存在则创建新的
    Flyweight* GetFlyweight(const string& key) {
        if (flyweights.find(key) == flyweights.end()) {
            flyweights[key] = new ConcreteFlyweight(key);
            cout << "创建享元对象: " << key << endl;
        }
        return flyweights[key];
    }
};

// 客户端代码
int main() {
    FlyweightFactory* factory = new FlyweightFactory();

    // 获取共享的享元对象
    Flyweight* flyweight1 = factory->GetFlyweight("A");
    Flyweight* flyweight2 = factory->GetFlyweight("B");
    Flyweight* flyweight3 = factory->GetFlyweight("A");  // 重复的享元对象

    // 使用共享的享元对象
    flyweight1->Operation("外部状态1");
    flyweight2->Operation("外部状态2");
    flyweight3->Operation("外部状态3");

    // 使用不共享的享元对象
    Flyweight* unshared = new UnsharedConcreteFlyweight();
    unshared->Operation("外部状态4");

    delete unshared;
    delete factory;
    return 0;
}

#include <iostream>
using namespace std;

// 抽象主题类（Subject），定义公共接口
class Subject {
public:
    virtual void Request() = 0;
    virtual ~Subject() {}
};

// 真实主题类（ConcreteSubject），实现实际的业务逻辑
class ConcreteSubject : public Subject {
public:
    void Request() override {
        cout << "ConcreteSubject: Handling request." << endl;
    }
};

// 代理类（Proxy），控制对ConcreteSubject的访问
class Proxy : public Subject {
private:
    ConcreteSubject* realSubject;

public:
    Proxy() : realSubject(nullptr) {}

    ~Proxy() {
        if (realSubject) {
            delete realSubject;
        }
    }

    void Request() override {
        if (!realSubject) {
            realSubject = new ConcreteSubject();  // 延迟实例化真实对象
        }
        cout << "Proxy: Delegating request to ConcreteSubject." << endl;
        realSubject->Request();  // 转发请求给真实对象
    }
};

// 客户端代码
int main() {
    Subject* proxy = new Proxy();
    
    // 客户端通过代理来访问真实主题
    proxy->Request();  // 输出代理类和真实类的操作

    delete proxy;
    return 0;
}

#include <iostream>
using namespace std;

// 抽象类（AbstractClass），定义了模板方法以及抽象的原语操作
class AbstractClass {
public:
    // 模板方法，定义算法的骨架
    void TemplateMethod() {
        Primitive1();
        Primitive2();
    }

    // 原语操作1，子类需要实现
    virtual void Primitive1() = 0;

    // 原语操作2，子类需要实现
    virtual void Primitive2() = 0;

    virtual ~AbstractClass() {}
};

// 具体类1（ConcreteClass1），实现具体的原语操作
class ConcreteClass1 : public AbstractClass {
public:
    void Primitive1() override {
        cout << "ConcreteClass1: 实现Primitive1" << endl;
    }

    void Primitive2() override {
        cout << "ConcreteClass1: 实现Primitive2" << endl;
    }
};

// 具体类2（ConcreteClass2），实现具体的原语操作
class ConcreteClass2 : public AbstractClass {
public:
    void Primitive1() override {
        cout << "ConcreteClass2: 实现Primitive1" << endl;
    }

    void Primitive2() override {
        cout << "ConcreteClass2: 实现Primitive2" << endl;
    }
};

// 客户端代码
int main() {
    AbstractClass* class1 = new ConcreteClass1();
    AbstractClass* class2 = new ConcreteClass2();

    // 使用模板方法执行算法
    cout << "ConcreteClass1调用模板方法:" << endl;
    class1->TemplateMethod();

    cout << "\nConcreteClass2调用模板方法:" << endl;
    class2->TemplateMethod();

    // 释放内存
    delete class1;
    delete class2;

    return 0;
}

#include <iostream>
using namespace std;

// 策略接口类（Strategy），定义了算法接口
class Strategy {
public:
    virtual void AlgorithmInterface() = 0;  // 定义算法的接口
    virtual ~Strategy() {}
};

// 具体策略A（ConcreteStrategyA），实现了具体的算法
class ConcreteStrategyA : public Strategy {
public:
    void AlgorithmInterface() override {
        cout << "执行算法 A" << endl;
    }
};

// 具体策略B（ConcreteStrategyB），实现了另一种算法
class ConcreteStrategyB : public Strategy {
public:
    void AlgorithmInterface() override {
        cout << "执行算法 B" << endl;
    }
};

// 上下文类（Context），持有一个策略对象，并使用它来完成具体的操作
class Context {
private:
    Strategy* strategy;  // 持有一个策略对象
public:
    Context(Strategy* strategy) : strategy(strategy) {}

    void DoAction() {
        // 调用策略的算法接口
        strategy->AlgorithmInterface();
    }

    // 设置新的策略
    void SetStrategy(Strategy* newStrategy) {
        strategy = newStrategy;
    }
};

// 客户端代码
int main() {
    // 创建具体策略
    Strategy* strategyA = new ConcreteStrategyA();
    Strategy* strategyB = new ConcreteStrategyB();

    // 使用策略A
    Context* context = new Context(strategyA);
    context->DoAction();  // 输出：执行算法 A

    // 切换为策略B
    context->SetStrategy(strategyB);
    context->DoAction();  // 输出：执行算法 B

    // 清理内存
    delete strategyA;
    delete strategyB;
    delete context;

    return 0;
}

#include <iostream>
using namespace std;

// 状态接口类（State）
class State {
public:
    virtual void OperationInterface() = 0;  // 定义状态相关的操作
    virtual void ChangeState(class Context* context) = 0;  // 改变上下文的状态
    virtual ~State() {}
};

// 前置声明上下文类（Context）
class Context;

// 具体状态A（ConcreteStateA）
class ConcreteStateA : public State {
public:
    void OperationInterface() override {
        cout << "ConcreteStateA: 执行操作。" << endl;
    }

    void ChangeState(Context* context) override;
};

// 具体状态B（ConcreteStateB）
class ConcreteStateB : public State {
public:
    void OperationInterface() override {
        cout << "ConcreteStateB: 执行操作。" << endl;
    }

    void ChangeState(Context* context) override;
};

// 上下文类（Context），持有状态对象
class Context {
private:
    State* state;  // 当前状态对象

public:
    Context(State* initialState) : state(initialState) {}

    // 设置新的状态
    void ChangeState(State* newState) {
        state = newState;
    }

    // 执行状态相关的操作
    void OperationInterface() {
        state->OperationInterface();
    }

    // 调用状态的切换逻辑
    void RequestChangeState() {
        state->ChangeState(this);
    }
};

// 状态转换实现
void ConcreteStateA::ChangeState(Context* context) {
    cout << "从 ConcreteStateA 切换到 ConcreteStateB" << endl;
    context->ChangeState(new ConcreteStateB());
}

void ConcreteStateB::ChangeState(Context* context) {
    cout << "从 ConcreteStateB 切换到 ConcreteStateA" << endl;
    context->ChangeState(new ConcreteStateA());
}

// 客户端代码
int main() {
    // 创建初始状态为 ConcreteStateA
    State* initialState = new ConcreteStateA();
    Context* context = new Context(initialState);

    // 执行操作并切换状态
    context->OperationInterface();  // 输出: ConcreteStateA: 执行操作。
    context->RequestChangeState();  // 切换到 ConcreteStateB

    // 再次执行操作
    context->OperationInterface();  // 输出: ConcreteStateB: 执行操作。
    context->RequestChangeState();  // 切换回 ConcreteStateA

    // 清理内存
    delete context;

    return 0;
}

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

// 抽象观察者类（Observer），定义了Update接口
class Observer {
public:
    virtual void Update(int state) = 0;  // 接收通知更新的方法
    virtual ~Observer() {}
};

// 抽象主题类（Subject），管理观察者的注册和通知
class Subject {
private:
    vector<Observer*> observers;  // 存储观察者的列表
public:
    // 注册观察者
    void Attach(Observer* observer) {
        observers.push_back(observer);
    }

    // 移除观察者
    void Detach(Observer* observer) {
        observers.erase(remove(observers.begin(), observers.end(), observer), observers.end());
    }

    // 通知所有观察者
    void Notify(int state) {
        for (Observer* observer : observers) {
            observer->Update(state);
        }
    }
};

// 具体主题类（ConcreteSubject），继承自Subject
class ConcreteSubject : public Subject {
private:
    int state;  // 主题的状态
public:
    int GetState() const {
        return state;
    }

    void SetState(int newState) {
        state = newState;
        Notify(state);  // 当状态改变时通知所有观察者
    }
};

// 具体观察者A（ConcreteObserverA），实现Update接口
class ConcreteObserverA : public Observer {
public:
    void Update(int state) override {
        cout << "ConcreteObserverA: 观察到状态变化为 " << state << endl;
    }
};

// 具体观察者B（ConcreteObserverB），实现Update接口
class ConcreteObserverB : public Observer {
public:
    void Update(int state) override {
        cout << "ConcreteObserverB: 观察到状态变化为 " << state << endl;
    }
};

// 客户端代码
int main() {
    // 创建具体主题对象
    ConcreteSubject* subject = new ConcreteSubject();

    // 创建两个具体观察者对象
    Observer* observerA = new ConcreteObserverA();
    Observer* observerB = new ConcreteObserverB();

    // 注册观察者
    subject->Attach(observerA);
    subject->Attach(observerB);

    // 改变主题状态，观察者将收到通知
    subject->SetState(10);  // 输出: ConcreteObserverA 和 ConcreteObserverB 都收到状态 10 的通知

    // 移除一个观察者，并再次改变状态
    subject->Detach(observerA);
    subject->SetState(20);  // 输出: 只有 ConcreteObserverB 收到状态 20 的通知

    // 清理内存
    delete subject;
    delete observerA;
    delete observerB;

    return 0;
}

#include <iostream>
#include <string>
using namespace std;

// 前置声明
class Colleague;
class ConcreteColleagueA;
class ConcreteColleagueB;

// 中介者接口类（Mediator）
class Mediator {
public:
    virtual void IntroColleague(Colleague* colleagueA, Colleague* colleagueB) = 0;
    virtual void DoActionFromAtoB() = 0;
    virtual void DoActionFromBtoA() = 0;
    virtual ~Mediator() {}
};

// 同事接口类（Colleague）
class Colleague {
protected:
    Mediator* mediator;  // 持有一个中介者的引用
public:
    Colleague(Mediator* mediator) : mediator(mediator) {}
    virtual void Action() = 0;
};

// 具体同事类A（ConcreteColleagueA）
class ConcreteColleagueA : public Colleague {
public:
    ConcreteColleagueA(Mediator* mediator) : Colleague(mediator) {}

    void Action() override {
        cout << "具体同事A正在执行自己的操作。" << endl;
    }

    void SendAction() {
        cout << "具体同事A请求中介者将操作传递给同事B。" << endl;
        mediator->DoActionFromAtoB();
    }
};

// 具体同事类B（ConcreteColleagueB）
class ConcreteColleagueB : public Colleague {
public:
    ConcreteColleagueB(Mediator* mediator) : Colleague(mediator) {}

    void Action() override {
        cout << "具体同事B正在执行自己的操作。" << endl;
    }

    void SendAction() {
        cout << "具体同事B请求中介者将操作传递给同事A。" << endl;
        mediator->DoActionFromBtoA();
    }
};

// 具体中介者类（ConcreteMediator）
class ConcreteMediator : public Mediator {
private:
    Colleague* colleagueA;
    Colleague* colleagueB;
public:
    void IntroColleague(Colleague* a, Colleague* b) override {
        colleagueA = a;
        colleagueB = b;
    }

    void DoActionFromAtoB() override {
        cout << "中介者从A接收到请求，并要求B执行操作。" << endl;
        if (colleagueB) colleagueB->Action();
    }

    void DoActionFromBtoA() override {
        cout << "中介者从B接收到请求，并要求A执行操作。" << endl;
        if (colleagueA) colleagueA->Action();
    }
};

// 客户端代码
int main() {
    // 创建中介者对象
    ConcreteMediator* mediator = new ConcreteMediator();

    // 创建两个具体的同事对象
    ConcreteColleagueA* colleagueA = new ConcreteColleagueA(mediator);
    ConcreteColleagueB* colleagueB = new ConcreteColleagueB(mediator);

    // 通过中介者引入同事对象
    mediator->IntroColleague(colleagueA, colleagueB);

    // A 请求中介者通知 B
    colleagueA->SendAction();

    // B 请求中介者通知 A
    colleagueB->SendAction();

    // 清理内存
    delete colleagueA;
    delete colleagueB;
    delete mediator;

    return 0;
}

#include <iostream>
using namespace std;

// 接收者类（Receiver），定义了具体的动作
class Receiver {
public:
    void Action() {
        cout << "Receiver: 执行操作" << endl;
    }
};

// 命令接口类（Command），定义了一个执行操作的接口
class Command {
public:
    virtual void Execute() = 0;
    virtual ~Command() {}
};

// 具体命令类（ConcreteCommand），将接收者的操作封装为命令
class ConcreteCommand : public Command {
private:
    Receiver* receiver;  // 持有接收者的引用
public:
    ConcreteCommand(Receiver* r) : receiver(r) {}

    void Execute() override {
        receiver->Action();  // 调用接收者的操作
    }
};

// 调用者类（Invoker），调用命令对象执行请求
class Invoker {
private:
    Command* command;  // 持有一个命令对象的引用
public:
    void SetCommand(Command* cmd) {
        command = cmd;
    }

    void Invoke() {
        if (command) {
            command->Execute();  // 调用命令的执行方法
        }
    }
};

// 客户端代码
int main() {
    // 创建接收者
    Receiver* receiver = new Receiver();

    // 创建命令并将接收者关联到命令
    Command* command = new ConcreteCommand(receiver);

    // 创建调用者并将命令传递给调用者
    Invoker* invoker = new Invoker();
    invoker->SetCommand(command);

    // 调用者执行命令
    invoker->Invoke();

    // 清理内存
    delete command;
    delete invoker;
    delete receiver;

    return 0;
}

#include <iostream>
#include <vector>
using namespace std;

// 前向声明
class ConcreteElementA;
class ConcreteElementB;

// 访问者接口类（Visitor）
class Visitor {
public:
    virtual void VisitConcreteElementA(ConcreteElementA* element) = 0;
    virtual void VisitConcreteElementB(ConcreteElementB* element) = 0;
    virtual ~Visitor() {}
};

// 元素接口类（Element），定义接受访问者的方法
class Element {
public:
    virtual void Accept(Visitor* visitor) = 0;
    virtual ~Element() {}
};

// 具体元素A（ConcreteElementA），实现了接受访问者的方法
class ConcreteElementA : public Element {
public:
    void Accept(Visitor* visitor) override {
        visitor->VisitConcreteElementA(this);
    }

    string OperationA() const {
        return "具体元素A的操作";
    }
};

// 具体元素B（ConcreteElementB），实现了接受访问者的方法
class ConcreteElementB : public Element {
public:
    void Accept(Visitor* visitor) override {
        visitor->VisitConcreteElementB(this);
    }

    string OperationB() const {
        return "具体元素B的操作";
    }
};

// 具体访问者A（ConcreteVisitorA），实现访问操作
class ConcreteVisitorA : public Visitor {
public:
    void VisitConcreteElementA(ConcreteElementA* element) override {
        cout << "访问者A访问: " << element->OperationA() << endl;
    }

    void VisitConcreteElementB(ConcreteElementB* element) override {
        cout << "访问者A访问: " << element->OperationB() << endl;
    }
};

// 具体访问者B（ConcreteVisitorB），实现访问操作
class ConcreteVisitorB : public Visitor {
public:
    void VisitConcreteElementA(ConcreteElementA* element) override {
        cout << "访问者B访问: " << element->OperationA() << endl;
    }

    void VisitConcreteElementB(ConcreteElementB* element) override {
        cout << "访问者B访问: " << element->OperationB() << endl;
    }
};

// 客户端代码
int main() {
    vector<Element*> elements = {new ConcreteElementA(), new ConcreteElementB()};
    ConcreteVisitorA* visitorA = new ConcreteVisitorA();
    ConcreteVisitorB* visitorB = new ConcreteVisitorB();

    // 访问者A访问所有元素
    cout << "访问者A开始访问:" << endl;
    for (Element* elem : elements) {
        elem->Accept(visitorA);
    }

    // 访问者B访问所有元素
    cout << "\n访问者B开始访问:" << endl;
    for (Element* elem : elements) {
        elem->Accept(visitorB);
    }

    // 清理内存
    for (Element* elem : elements) {
        delete elem;
    }
    delete visitorA;
    delete visitorB;

    return 0;
}