23种常见设计模式（附代码帮助理解）

最新推荐文章于 2024-09-26 22:04:35 发布

CCC：CarCrazeCurator

最新推荐文章于 2024-09-26 22:04:35 发布

阅读量716

点赞数 24

文章标签：设计模式

本文链接：https://blog.csdn.net/liumao99/article/details/141019509

版权

类别	模式名称	特点描述
创建型模式	单例模式	保证一个类只有一个实例，并提供一个全局访问点。
	工厂方法	定义创建对象的接口，让子类决定实例化哪一个类。
	抽象工厂	创建相关或依赖对象的家族，而不需明确指定具体类。
	建造者模式	分离复杂对象的构建和表示，使得同样的构建过程可以创建不同的表示。
	原型模式	通过拷贝现有的实例创建新的实例，而不是通过新建。
结构型模式	适配器模式	将一个类的接口转换成客户期望的另一个接口。
	装饰器模式	动态地给一个对象添加额外的职责。
	代理模式	为其他对象提供一个代替或占位符以控制对它的访问。
	外观模式	提供一个统一的接口来访问子系统中的一群接口。
	桥接模式	将抽象部分与它的实现部分分离，使它们可以独立地变化。
	组合模式	将对象组合成树形结构以表示“部分-整体”的层次结构。
	享元模式	通过共享来高效地支持大量细粒度的对象。
行为型模式	策略模式	定义一系列算法，把它们一个个封装起来，并使它们可以互换。
	模板方法	在方法中定义一个算法的骨架，而将一些步骤的执行延迟到子类中。
	观察者模式	对象间存在一对多的依赖关系，当一个对象改变状态时，所有依赖于它的对象都被通知并自动更新。
	迭代器模式	顺序访问一个聚合对象中的各个元素，不暴露其内部的表示。
	中介者模式	用一个中介对象来封装一系列对象之间的交互。
	命令模式	将请求封装为一个对象，从而使用户可用不同的请求对客户进行参数化。
	备忘录模式	在不破坏封装性的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态。
	状态模式	允许一个对象在其内部状态发生改变时改变其行为。
	访问者模式	为一个对象结构（如组合结构）增加新能力。
	解释器模式	定义一个语言的文法表示，并定义一个解释器，这个解释器使用该表示来解释语言中的句子。
	责任链模式	使多个对象都有机会处理请求，从而避免请求的发送者和接收者之间的耦合关系。

1.单例模式 (Singleton Pattern)

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

class Singleton {
private:
    static Singleton* instance;
    Singleton() {}

public:
    static Singleton* getInstance() {
        if (instance == nullptr) {
            instance = new Singleton();
        }
        return instance;
    }
};
Singleton* Singleton::instance = nullptr;

2.工厂方法模式 (Factory Method Pattern)

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

class Product {
public:
    virtual ~Product() {}
    virtual void doSomething() const = 0;
};

class ConcreteProductA : public Product {
public:
    void doSomething() const override {
        std::cout << "ConcreteProductA does something." << std::endl;
    }
};

class ConcreteProductB : public Product {
public:
    void doSomething() const override {
        std::cout << "ConcreteProductB does something." << std::endl;
    }
};

class Creator {
public:
    virtual ~Creator() {}
    virtual Product* createProduct() const = 0;
};

class ConcreteCreatorA : public Creator {
public:
    Product* createProduct() const override {
        return new ConcreteProductA();
    }
};

class ConcreteCreatorB : public Creator {
public:
    Product* createProduct() const override {
        return new ConcreteProductB();
    }
};

3.抽象工厂模式 (Abstract Factory Pattern)

创建相关或依赖对象的家族，而不需明确指定具体类。

class AbstractFactory {
public:
    virtual ~AbstractFactory() {}
    virtual Product* createProduct() = 0;
};

class ConcreteFactoryA : public AbstractFactory {
public:
    Product* createProduct() override {
        return new ConcreteProductA();
    }
};

class ConcreteFactoryB : public AbstractFactory {
public:
    Product* createProduct() override {
        return new ConcreteProductB();
    }
};

4.建造者模式 (Builder Pattern)

分离复杂对象的构建和表示，使得同样的构建过程可以创建不同的表示。

class Product {
private:
    std::string part;

public:
    void setPart(const std::string& part) {
        this->part = part;
    }
    void display() const {
        std::cout << "Product Part: " << part << std::endl;
    }
};

class Builder {
public:
    virtual ~Builder() {}
    virtual void buildPart() = 0;
};

class ConcreteBuilder : public Builder {
private:
    Product* product;
public:
    ConcreteBuilder() : product(new Product()) {}
    ~ConcreteBuilder() {
        delete product;
    }
    void buildPart() override {
        product->setPart("ConcretePart");
    }
    Product* getProduct() {
        return product;
    }
};

5.原型模式 (Prototype Pattern)

通过拷贝现有的实例创建新的实例，而不是通过新建。

class Prototype {
public:
    virtual ~Prototype() {}
    virtual Prototype* clone() const = 0;
};

class ConcretePrototype : public Prototype {
public:
    Prototype* clone() const override {
        return new ConcretePrototype(*this);
    }
};

6.适配器模式 (Adapter Pattern)

将一个类的接口转换成客户期望的另一个接口。

class Target {
public:
    virtual ~Target() {}
    virtual void request() const = 0;
};

class Adaptee {
public:
    void specificRequest() const {
        std::cout << "Adaptee specific request." << std::endl;
    }
};

class Adapter : public Target {
private:
    Adaptee* adaptee;
public:
    Adapter(Adaptee* adaptee) : adaptee(adaptee) {}
    void request() const override {
        adaptee->specificRequest();
    }
};

7.装饰器模式 (Decorator Pattern)

动态地给一个对象添加额外的职责。

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

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

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

class ConcreteDecorator : public Decorator {
public:
    ConcreteDecorator(Component* component) : Decorator(component) {}
    void additionalOperation() const {
        std::cout << "ConcreteDecorator additional operation." << std::endl;
    }
    void operation() const override {
        Decorator::operation();
        additionalOperation();
    }
};

8.代理模式 (Proxy Pattern)

为其他对象提供一个代替或占位符以控制对它的访问。

class Subject {
public:
    virtual ~Subject() {}
    virtual void request() const = 0;
};

class RealSubject : public Subject {
public:
    void request() const override {
        std::cout << "RealSubject request." << std::endl;
    }
};

class Proxy : public Subject {
private:
    RealSubject* realSubject;
public:
    Proxy() : realSubject(new RealSubject()) {}
    void request() const override {
        realSubject->request();
    }
};

9.外观模式 (Facade Pattern)

提供一个统一的接口来访问子系统中的一群接口。

class SubsystemA {
public:
    void operationA() const {
        std::cout << "SubsystemA operationA." << std::endl;
    }
};

class SubsystemB {
public:
    void operationB() const {
        std::cout << "SubsystemB operationB." << std::endl;
    }
};

class Facade {
private:
    SubsystemA* subsystemA;
    SubsystemB* subsystemB;
public:
    Facade() : subsystemA(new SubsystemA()), subsystemB(new SubsystemB()) {}
    void operation() const {
        subsystemA->operationA();
        subsystemB->operationB();
    }
};

10.桥接模式 (Bridge Pattern)

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

class Implementation {
public:
    virtual ~Implementation() {}
    virtual void operationImpl() const = 0;
};

class RefinedAbstraction {
private:
    Implementation* implementation;
public:
    RefinedAbstraction(Implementation* implementation) : implementation(implementation) {}
    void operation() const {
        std::cout << "RefinedAbstraction operation with ";
        implementation->operationImpl();
    }
};

class ConcreteImplementationA : public Implementation {
public:
    void operationImpl() const override {
        std::cout << "ConcreteImplementationA.";
    }
};

class ConcreteImplementationB : public Implementation {
public:
    void operationImpl() const override {
        std::cout << "ConcreteImplementationB.";
    }
};

11.组合模式 (Composite Pattern)

将对象组合成树形结构以表示“部分-整体”的层次结构。

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

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

class Composite : public Component {
private:
    std::vector<Component*> children;
public:
    void operation() const override {
        for (auto& child : children) {
            child->operation();
        }
    }
    void add(Component* component) {
        children.push_back(component);
    }
    void remove(Component* component) {
        children.erase(std::remove(children.begin(), children.end(), component), children.end());
    }
};

12.享元模式 (Flyweight Pattern)

通过共享来高效地支持大量细粒度的对象。

class Flyweight {
public:
    virtual ~Flyweight() {}
    virtual void operation(const std::string& extrinsicState) const = 0;
};

class ConcreteFlyweight : public Flyweight {
public:
    void operation(const std::string& extrinsicState) const override {
        std::cout << "ConcreteFlyweight operation with extrinsic state: " << extrinsicState << std::endl;
    }
};

class FlyweightFactory {
private:
    std::map<std::string, Flyweight*> flyweights;
public:
    Flyweight* getFlyweight(const std::string& intrinsicState) {
        auto it = flyweights.find(intrinsicState);
        if (it == flyweights.end()) {
            flyweights[intrinsicState] = new ConcreteFlyweight();
        }
        return flyweights[intrinsicState];
    }
};

13.策略模式 (Strategy Pattern)

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

class Strategy {
public:
    virtual ~Strategy() {}
    virtual void algorithmInterface() const = 0;
};

class ConcreteStrategyA : public Strategy {
public:
    void algorithmInterface() const override {
        std::cout << "ConcreteStrategyA algorithm interface." << std::endl;
    }
};

class ConcreteStrategyB : public Strategy {
public:
    void algorithmInterface() const override {
        std::cout << "ConcreteStrategyB algorithm interface." << std::endl;
    }
};

class Context {
private:
    Strategy* strategy;
public:
    Context(Strategy* strategy) : strategy(strategy) {}
    void setStrategy(Strategy* strategy) {
        this->strategy = strategy;
    }
    void contextInterface() {
        strategy->algorithmInterface();
    }
};

14.模板方法模式 (Template Method Pattern)

在方法中定义一个算法的骨架，而将一些步骤的执行延迟到子类中。

class AbstractClass {
protected:
    void primitiveOperation1() const {
        std::cout << "AbstractClass primitiveOperation1." << std::endl;
    }
    void primitiveOperation2() const {
        std::cout << "AbstractClass primitiveOperation2." << std::endl;
    }
public:
    void templateMethod() const {
        primitiveOperation1();
        primitiveOperation2();
    }
};

class ConcreteClass : public AbstractClass {
protected:
    void primitiveOperation1() const override {
        std::cout << "ConcreteClass primitiveOperation1." << std::endl;
    }
    void primitiveOperation2() const override {
        std::cout << "ConcreteClass primitiveOperation2." << std::endl;
    }
};

15.观察者模式 (Observer Pattern)

对象间存在一对多的依赖关系，当一个对象改变状态时，所有依赖于它的对象都被通知并自动更新。

class Observer {
public:
    virtual void update() = 0;
};

class Subject {
private:
    std::vector<Observer*> observers;

public:
    void attach(Observer* observer) {
        observers.push_back(observer);
    }

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

    void notify() {
        for (auto* observer : observers) {
            observer->update();
        }
    }
};

class ConcreteObserver : public Observer {
public:
    void update() override {
        // 更新逻辑
    }
};

16.迭代器模式 (Iterator Pattern)

顺序访问一个聚合对象中的各个元素，不暴露其内部的表示。

class Iterator {
public:
    virtual bool hasNext() = 0;
    virtual void next() = 0;
    virtual void first() = 0;
    virtual void last() = 0;
};

class Aggregate {
public:
    virtual Iterator* createIterator() = 0;
};

class ConcreteAggregate : public Aggregate {
private:
    std::vector<int> items;

public:
    void add(int item) {
        items.push_back(item);
    }

    Iterator* createIterator() override {
        return new ConcreteIterator(this);
    }
};

class ConcreteIterator : public Iterator {
private:
    ConcreteAggregate* aggregate;
    int position;

public:
    ConcreteIterator(ConcreteAggregate* aggregate) : aggregate(aggregate), position(0) {}

    bool hasNext() override {
        return position < aggregate->items.size();
    }

    void next() override {
        position++;
    }

    void first() override {
        position = 0;
    }

    void last() override {
        position = aggregate->items.size() - 1;
    }
};

17.中介者模式 (Mediator Pattern)

用一个中介对象来封装一系列对象之间的交互。

class Mediator {
public:
    virtual void send(const std::string& message, Colleague* sender) = 0;
};

class Colleague {
protected:
    Mediator* mediator;

public:
    Colleague(Mediator* mediator) : mediator(mediator) {}

    void setMediator(Mediator* mediator) {
        this->mediator = mediator;
    }

    virtual void send(const std::string& message) = 0;
    virtual void receive(const std::string& message) = 0;
};

class ConcreteMediator : public Mediator {
private:
    std::vector<Colleague*> colleagues;

public:
    void addColleague(Colleague* colleague) {
        colleagues.push_back(colleague);
    }

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

class ConcreteColleague : public Colleague {
public:
    ConcreteColleague(Mediator* mediator) : Colleague(mediator) {}

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

    void receive(const std::string& message) override {
        // 接收消息的逻辑
    }
};

18.命令模式 (Command Pattern)

将请求封装为一个对象，从而使用户可用不同的请求对客户进行参数化。

class Command {
public:
    virtual void execute() = 0;
};

class Receiver {
public:
    void action() {
        // 执行具体操作
    }
};

class ConcreteCommand : public Command {
private:
    Receiver* receiver;

public:
    ConcreteCommand(Receiver* receiver) : receiver(receiver) {}

    void execute() override {
        receiver->action();
    }
};

class Invoker {
private:
    Command* command;

public:
    void setCommand(Command* command) {
        this->command = command;
    }

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

19.备忘录模式 (Memento Pattern)

在不破坏封装性的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态。

class Memento {
private:
    int state;

public:
    Memento(int state) : state(state) {}

    int getState() const {
        return state;
    }
};

class Originator {
private:
    int state;

public:
    void setState(int state) {
        this->state = state;
    }

    int getState() const {
        return state;
    }

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

    void restoreMemento(Memento* memento) {
        state = memento->getState();
    }
};

class Caretaker {
private:
    Memento* memento;

public:
    void setMemento(Memento* memento) {
        this->memento = memento;
    }

    Memento* getMemento() {
        return memento;
    }
};

20.状态模式 (State Pattern)

允许一个对象在其内部状态发生改变时改变其行为。

class Context {
private:
    State* state;

public:
    void setState(State* state) {
        this->state = state;
    }

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

class State {
public:
    virtual void handle(Context* context) = 0;
};

class ConcreteStateA : public State {
public:
    void handle(Context* context) override {
        // 具体状态A的处理逻辑
    }
};

class ConcreteStateB : public State {
public:
    void handle(Context* context) override {
        // 具体状态B的处理逻辑
    }
};

21.访问者模式 (Visitor Pattern)

为一个对象结构（如组合结构）增加新能力。

class Element {
public:
    virtual void accept(Visitor* visitor) = 0;
};

class ConcreteElementA : public Element {
public:
    void accept(Visitor* visitor) override {
        visitor->visitConcreteElementA(this);
    }
};

class ConcreteElementB : public Element {
public:
    void accept(Visitor* visitor) override {
        visitor->visitConcreteElementB(this);
    }
};

class Visitor {
public:
    virtual void visitConcreteElementA(ConcreteElementA* element) = 0;
    virtual void visitConcreteElementB(ConcreteElementB* element) = 0;
};

class ConcreteVisitor : public Visitor {
public:
    void visitConcreteElementA(ConcreteElementA* element) override {
        // 具体访问者访问A元素的逻辑
    }

    void visitConcreteElementB(ConcreteElementB* element) override {
        // 具体访问者访问B元素的逻辑
    }
};

22.解释器模式 (Interpreter Pattern)

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

class AbstractExpression {
public:
    virtual void interpret(Context* context) = 0;
};

class TerminalExpression : public AbstractExpression {
public:
    void interpret(Context* context) override {
        // 终端表达式的解释逻辑
    }
};

class NonterminalExpression : public AbstractExpression {
public:
    void interpret(Context* context) override {
        // 非终端表达式的解释逻辑
    }
};

23.责任链模式 (Chain of Responsibility Pattern)

使多个对象都有机会处理请求，从而避免请求的发送者和接收者之间的耦合关系。

class Handler {
public:
    virtual void handleRequest(int request) = 0;
    virtual Handler* setNext(Handler* handler) = 0;
};

class ConcreteHandler1 : public Handler {
private:
    Handler* next;

public:
    Handler* setNext(Handler* handler) override {
        next = handler;
        return handler;
    }

    void handleRequest(int request) override {
        if (request >= 0 && request < 10) {
            std::cout << "ConcreteHandler1 handled request: " << request << std::endl;
        } else if (next != nullptr) {
            next->handleRequest(request);
        }
    }
};
// ConcreteHandler2, ConcreteHandler3 等类类似定义