class Singleton {
private:
    Singleton() = default;

public:
    static Singleton *GetInstance() {
        static Singleton instance;
        return &instance;
    }

    Singleton(Singleton const &other) = delete;
    Singleton(Singleton const &&other) = delete;
    Singleton &operator=(Singleton const &other) = delete;
    Singleton &operator=(Singleton const &&other) = delete;
};

#pragma once
#include <iostream>

class Product {
public:
    Product() = default;
    virtual ~Product() {};

    virtual void use() = 0;
};

class ConcreteProductA : public Product {
public:
    virtual ~ConcreteProductA() {}

    virtual void use() {
        std::cout << "use ConcreteProductA\n";
    }
};

class ConcreteProductB : public Product {
public:
    virtual ~ConcreteProductB() {};

    virtual void use() {
        std::cout << "use ConcreteProductB\n";
    }
};

class Factory {
public:
    Factory() = default;
    virtual ~Factory() {};

    virtual Product *createProduct() = 0;
};

class ConcreteFactoryA : public Factory {
public:
    ConcreteFactoryA() = default;
    virtual ~ConcreteFactoryA() {}

    virtual Product *createProduct() {
        return new ConcreteProductA();
    }
};

class ConcreteFactoryB : public Factory {
public:
    ConcreteFactoryB() = default;
    virtual ~ConcreteFactoryB() {};

    virtual Product *createProduct() {
        return new ConcreteProductB();
    }
};

#pragma once

#include <iostream>

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

    virtual void use() = 0;
};

class AbstractProductB {
public:
    AbstractProductB() = default;
    ~AbstractProductB() = default;

    virtual void eat() = 0;
};

class ProductA1 : public ::AbstractProductA {
public:
    ProductA1() = default;
    virtual ~ProductA1() = default;

    void use() override {
        std::cout << "use ProductA1\n";
    }
};

class ProductA2 : public AbstractProductA {
public:
    ProductA2() = default;
    virtual ~ProductA2() = default;

    void use() override {
        std::cout << "use ProductA2\n";
    }
};

class ProductB1 : public AbstractProductB {
public:
    ProductB1() = default;
    virtual ~ProductB1() = default;

    void eat() override {
        std::cout << "eat ProductB1\n";
    }
};

class ProductB2 : public AbstractProductB {
public:
    ProductB2() = default;
    virtual ~ProductB2() = default;

    void eat() override {
        std::cout << "eat ProductB2\n";
    }
};

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

    virtual AbstractProductA *createProductA() = 0;
    virtual AbstractProductB *createProductB() = 0;
};

class ConcreteFactory1 : public AbstractFactory {
public:
    ConcreteFactory1() = default;
    virtual ~ConcreteFactory1() = default;

    AbstractProductA *createProductA() override {
        return new ProductA1();
    }
    AbstractProductB *createProductB() override {
        return new ProductB1();
    }
};

class ConcreteFactory2 : public AbstractFactory {
public:
    ConcreteFactory2() = default;
    virtual ~ConcreteFactory2() = default;

    AbstractProductA *createProductA() override {
        return new ProductA2();
    }

    AbstractProductB *createProductB() override {
        return new ProductB2();
    }
};

#pragma once

#include <iostream>

class Product {
public:
    void setPart1(const std::string& part1) {
        this->part1 = part1;
    }

    void setPart2(const std::string& part2) {
        this->part2 = part2;
    }

    std::string getProduct() const {
        return part1 + " " + part2;
    }

private:
    std::string part1;
    std::string part2;
};

class Builder {
public:
    virtual ~Builder() = default;
    virtual void buildPart1() = 0;
    virtual void buildPart2() = 0;
    virtual Product* getProduct() = 0;
};

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

    ~ConcreteBuilder() {
        delete product;
    }

    void buildPart1() override {
        product->setPart1("Part1");
    }

    void buildPart2() override {
        product->setPart2("Part2");
    }

    Product* getProduct() override {
        return product;
    }

private:
    Product* product = nullptr;
};

class Director {
public:
    void construct(Builder* builder) {
        builder->buildPart1();
        builder->buildPart2();
    }
};

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

	virtual Prototype *clone() = 0;
};

class ConcretePrototype : public Prototype {
public:
	ConcretePrototype(std::string const &data) : m_data(data) {}
	virtual ~ConcretePrototype() = default;

	Prototype *clone() override {
		return new ConcretePrototype(this->m_data);
	}

	std::string getData() const {
		return m_data;
	}

private:
	std::string m_data;
}

// 目标接口
class Target {
public:
	virtual void request() = 0;
};

// 被适配者
class Adaptee {
public:
	void specificRequest() {
		std::cout << "specificRequest" << std::endl;
	}
};

// 适配器类
class Adapter : public Target {
public:
	Adapter(Adaptee *adaptee) {
		m_adaptee = adaptee;
	}
	void request() override {
		m_adaptee->specificRequest();
	}
private:
	Adaptee *m_adaptee;
};

// 抽象对象类
class Subject {
public:
	virtual void request() = 0;
};

// 具体对象类
class RealSubject : public Subject {
public:
	void request() override {
		std::cout << "RealSubject: Handling request.\n";
	}
};

// 代理类
class Proxy : public Subject {
public:
	void request() override {
		realSubject.request();
	}

private:
	RealSubject realSubject;
};

class Component {
public:
	virtual ~Component() = default;
	virtual void operation() = 0;
};

class ConcreteComponent : public Component {
public:
	void operation() override {
		std::cout << "ConcreteComponent operation" << std::endl;
	}
};

class Decorator : public Component {
public:
	Decorator(Component *component) : m_component(component) {}
	void operation() override {
		m_component->operation();
	}

protected:
	Component *m_component;
};

class ConcreteDecorator : public Decorator {
public:
	ConcreteDecorator(Component *component) : Decorator(component) {}

	void operation() override {
		Decorator::operation();
		std::cout << "ConcreteDecorator operation" << std::endl;
	}
};

class SubSystemA {
public:
	void operationA() {
		std::cout << "operationA" << std::endl;
	}
};

class SubSystemB {
public:
	void operationB() {
		std::cout << "operationB" << std::endl;
	}
};

class SubSystemC {
public:
	void operationC() {
		std::cout << "operationC" << std::endl;
	}
};

class Facade {
public:
	void operation() {
		subSystemA.operationA();
		subSystemB.operationB();
		subSystemC.operationC();
	}

private:
	SubSystemA subSystemA;
	SubSystemB subSystemB;
	SubSystemC subSystemC;
};

// 实现
class Implementation {
public:
	virtual void operationImpl() {};
};

// 具体实现A
class ConcreteImplementationA : public Implementation {
public:
	void operationImpl() override {};
};

// 具体实现B
class ConcreteImplementationB : public Implementation {
public:
	void operationImpl() override {};
};

// 抽象
class Abstraction {
public:
	Abstraction(Implementation *impl) : impl(impl) {}
	virtual void operation() = 0;
protected:
	Implementation *impl;
};

// 修正抽象
class RefinedAbstraction : public Abstraction {
public:
	RefinedAbstraction(Implementation *impl) : Abstraction(impl) {}
	void operation() override {
		impl->operationImpl();
	}
};

// 组件
class Component {
public:
	virtual ~Component() = default;
	virtual void operation() = 0;
};

// 叶子节点
class Leaf : public Component {
public:
	void operation() override {
		std::cout << "Leaf operation" << std::endl;
	}
};

// 组合节点：包含叶子节点的操作行为
class Composite : public Component {
public:
	void add(Component *component) {
		m_component.push_back(std::make_unique<Component>(component));
	}

	void remove(Component *component) {
		// ...
	}

	void operation() override {
		std::cout << "Composite operation" << std::endl;

		for (auto &component : m_component) {
			component->operation();
		}
	}
private:
	std::vector<std::unique_ptr<Component>> m_component;
};

class FlyWeight {
public:
    virtual ~FlyWeight() = default;
    virtual void operation(std::string externalState) = 0;
};

class ConcreteFlyWeight : public FlyWeight {
public:
    ConcreteFlyWeight(std::string const& state)
            : m_state(state) {}

    void operation(std::string externalState) override {
        std::cout << "ConcreteFlyWeight: " << m_state << " " << externalState << std::endl;
    }

private:
    std::string m_state; // 内部状态
};

class FlyWeightFactory {
public:
    FlyWeight* getFlyWeight(std::string key) {
        if (m_flyweights.find(key) == m_flyweights.end()) {
            FlyWeight* flyweight = new ConcreteFlyWeight(key);
            m_flyweights[key] = flyweight;
        }
        return m_flyweights[key];
    }

private:
    std::map<std::string, FlyWeight*> m_flyweights;
};

class Observer {
public:
    virtual ~Observer() = default;
    virtual void update(std::string message) = 0;
};

class Subject {
public:
    virtual ~Subject() = default;
    virtual void registerObserver(Observer *observer) = 0;
    virtual void removeObserver(Observer *observer) = 0;
    virtual void notifyObserver() = 0;
};

class ConcreteSubject : public Subject {
public:
    ~ConcreteSubject() = default;
    void registerObserver(Observer *observer) override {
        observers.emplace_back(observer);
    }

    void removeObserver(Observer *observer) override {
        observers.erase(std::remove(observers.begin(), observers.end(), observer), observers.end());
    }

    void notifyObserver() override {
        for (auto &observer : observers) {
            observer->update(state);
        }
    }

    void setState(std::string state) {
        this->state = state;
        notifyObserver();
    }

private:
    std::vector<Observer *> observers;
    std::string state;
};

class ConcreteObserver : public Observer {
public:
    ~ConcreteObserver() = default;
    void update(std::string message) override {
        std::cout << "ConcreteObserver: " << message << std::endl;
    }
};

class Strategy {
public:
    virtual ~Strategy() = default;
    virtual void AlgorithmInterface() = 0;
};

class ConcreteStrategyA : public Strategy {
public:
    void AlgorithmInterface() override {
        std::cout << "Called ConcreteStrategyA's AlgorithmInterface" << std::endl;
    }
};

class ConcreteStrategyB : public Strategy {
public:
    void AlgorithmInterface() override {
        std::cout << "Called ConcreteStrategyB's AlgorithmInterface" << std::endl;
    }
};

class Context {
public:
    Context(Strategy* strategy)
            : m_strategy(strategy) {}
    void ContextInterface() {
        m_strategy->AlgorithmInterface();
    }

private:
    Strategy* m_strategy;
};

// 抽象命令类
class Command {
public:
    virtual ~Command() {}
    virtual void execute() = 0;
};

// 接收者
class Receiver {
public:
    void action() {
        std::cout << "Receiver::action()" << std::endl;
    }
};

// 调用者
class Invoker {
public:
    Invoker(Command *command)
            : m_command(command) {}

    void executeCommand() {
        m_command->execute();
    }

private:
    Command *m_command;
};

// 具体命令类
class ConcreteCommand : public Command {
public:
    ConcreteCommand(Receiver receiver)
            : m_receiver(receiver) {}

    void execute() override {
        m_receiver.action();
    }

private:
    Receiver m_receiver;
};

class Colleague;

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

// 具体中介者
class ConcreteMediator : public Mediator {
public:
    void Register(Colleague *colleague) override {
        m_colleagues.push_back(colleague);
    }

    void Send(std::string const &message, Colleague *colleague) override {
        for (auto const &c : m_colleagues) {
            if (c != colleague) {
                c->receive(message);
            }
        }
    }

private:
    std::vector<Colleague *> m_colleagues;
};

// 抽象同事
class Colleague {
public:
    virtual ~Colleague() {}
    virtual void send(std::string const &message) = 0;
    virtual void receive(std::string const &message) = 0;

protected:
    Mediator *m_mediator;
};

// 具体同事A
class ConcreteColleagueA : public Colleague {
public:
    ConcreteColleagueA(Mediator *mediator) {
        m_mediator = mediator;
    }

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

    void receive(std::string const &message) override {
        std::cout << "ColleagueA received: " << message << std::endl;
    }
};

// 具体同事B
class ConcreteColleagueB : public Colleague {
public:
    ConcreteColleagueB(Mediator *mediator) {
        m_mediator = mediator;
    }

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

    void receive(std::string const &message) override {
        std::cout << "ColleagueB received: " << message << std::endl;
    }
};

// 备忘录
class Memento {
public:
    Memento(std::string state)
            : m_state(state) {}

    std::string getState() const {
        return m_state;
    }

private:
    std::string m_state;
};

// 发起人
class Originator {
public:
    void setState(std::string state) {
        m_state = state;
    }

    std::string getState() const {
        return m_state;
    }

    Memento *createMemento() {
        return new Memento(m_state);
    }

    void restoreFromMemento(Memento *memento) {
        m_state = memento->getState();
    }

private:
    std::string m_state;
};

// 管理者
class Caretaker {
public:
    void addMemento(Memento *memento) {
        m_mementos.emplace_back(memento);
    }

    Memento *getMemento(int idx) {
        if (idx >= 0 && idx < m_mementos.size())
            return m_mementos[idx];
    }

private:
    std::vector<Memento *> m_mementos;
};

// 模板类
class AbstractClass {
public:
    virtual ~AbstractClass() = default;
    void templateMethod() {
        step1();
        step2();
        step3();
    }

protected:
    virtual void step1() {}
    virtual void step2() {}
    virtual void step3() {}
};

// 具体类
class ConcreteClass : public AbstractClass {
protected:
    void step1() override {
        std::cout << "Step 1\n";
    }

    void step2() override {
        std::cout << "Step 2\n";
    }

    void step3() override {
        std::cout << "Step 3\n";
    }
};

// 抽象迭代器
template <typename T>
class Iterator {
public:
    virtual ~Iterator() = default;
    virtual bool hasNext() = 0;
    virtual T next() = 0;
};

// 具体迭代器
template <typename T>
class ConcreteIterator : public Iterator {
public:
    ConcreteIterator(std::vector<T> elements)
            : m_elements(elements)
            , m_idx = 0 {}

    void bool hasNext() override {
        return m_idx < m_elements.size();
    }

    T next() override {
        if (hasNext()) {
            return m_elements[m_idx++];
        }
        return nullptr;
    }

private:
    int m_idx;
    std::vector<T> m_elements;
};

// 抽象聚合
template <typename T>
class Iterable {
public:
    virtual ~Iterable() = default;
    virtual Iterator<T> *createIterator() = 0;
};

// 具体聚合
template <typename T>
class ConcreteIterable : public Iterable {
public:
    ConcreteIterable(std::vector<T> elements)
            : m_elements(elements) {}

    Iterator<T> *createIterator() override {
        return new ConcreteIterator(m_elements);
    }

private:
    std::vector<T> m_elements;
};

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

// 具体状态 A
class ConcreteStateA : public State {
public:
    void handle() override {
        std::cout << "状态A下的操作\n";
    }
};

// 具体状态 B
class ConcreteStateB : public State {
public:
    void handle() override {
        std::cout << "状态B下的操作\n";
    }
};

class Context {
public:
    void setState(State *state) {
        currentState = state;
    }

    void request() {
        currentState->handle();
    }

private:
    State *currentState;
};

// 处理者
class Handler {
public:
    virtual void handleRequest(int requestId) = 0;
    virtual void setNextHandler(Handler *next) = 0;

protected:
    Handler *m_nextHandler;
};

// 具体处理者
class ConcreteHandler : public Handler {
public:
    void handleRequest(int requestId) {
        if (canHandle(requestId)) {
            std::cout << "ConcreteHandler::handleRequest() " << requestId << std::endl;
            return;
        } else if (m_nextHandler != nullptr) {
            m_nextHandler->handleRequest(requestId);
        } else {
            // 无法处理请求
        }
    }

    void setNextHandler(Handler *next) {
        m_nextHandler = next;
    }

private:
    bool canHandle(int requestId) {
        // 根据具体情况判断是否能处理请求
        return requestId > 0;
    }
};

// 抽象表达式
class Expression {
public:
    virtual ~Expression() = default;
    virtual int interpret() = 0;
};

// 终结符表达式
class TerminalExpression : public Expression {
public:
    TerminalExpression(int value)
            : m_value(value) {}

    int interpret() override {
        return m_value;
    }

private:
    int m_value;
};

// 非终结符表达式，此处举例为加法
class AddExpression : public Expression {
public:
    AddExpression(Expression *left, Expression *right)
            : m_left(left)
            , m_right(right) {}

    int interpret() override {
        return m_left->interpret() + m_right->interpret();
    }

private:
    Expression *m_left;
    Expression *m_right;
};

class Context {
public:
    // 存储一些全局信息或状态
};

class Visitor;

// 抽象元素类
class Element {
public:
    virtual ~Element() = default;
    virtual void accept(Visitor *visitor) = 0;
};

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

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

// 抽象访问者
class Visitor {
public:
    virtual ~Visitor() = default;
    virtual void visit(ConcreteElementA *element) = 0;
    virtual void visit(ConcreteElementB *element) = 0;
};

// 抽象访问者 A
class ConcreteVisitorA : public Visitor {
public:
    void visit(ConcreteElementA *element) override {
        std::cout << "ConcreteVisitorA visit ConcreElementA\n";
    }

    void visit(ConcreteElementB *element) override {
        std::cout << "ConcreteVisitorA visit ConcreElementB\n";
    }
};

// 抽象访问者 B
class ConcreteVisitorB : public Visitor {
public:
    void visit(ConcreteElementA *element) override {
        std::cout << "ConcreteVisitorB visit ConcreElementA\n";
    }

    void visit(ConcreteElementB *element) override {
        std::cout << "ConcreteVisitorB visit ConcreElementB\n";
    }
};

// 对象结构
class ObjectStructure {
public:
    void attach(Element *element) {
        m_elements.emplace_back(element);
    }

    void detach(Element *element) {
        auto it = std::find(m_elements.begin(), m_elements.end(), element);
        if (it != m_elements.end()) {
            m_elements.erase(it);
        }
    }

    void accept(Visitor *visitor) {
        for (Element *element : m_elements) {
            element->accept(visitor);
        }
    }

private:
    std::vector<Element *> m_elements;
};