您现在的位置是：网站首页>技术百科技术百科

设计模式（Design Patterns）

小大寒2024-01-01[技术百科]博学多闻

设计模式（Design Patterns）设计模式是软件开发中常用的解决方案，它们是对某些常见问题的最佳实践总结，可以帮助开发人员设计灵活、可维护、可扩展的代码。设计模式并不是具体的代码，而是一个可以在不同应用场景中反复使用的“模板”或“框架”。它们帮助开发者减少复杂性，提高代码的可复用性、可扩展性和可维护性。

设计模式（Design Patterns）

设计模式介绍

设计模式（Design Patterns）是软件工程中一种重要的概念，它代表了在特定情境下对常见问题的最佳解决方案。设计模式提供了一种可复用的设计框架，使得开发者在面对类似问题时能够迅速找到有效的解决方案。

设计模式通常被分为三大类：创建型模式（Creational Patterns）、结构型模式（Structural Patterns）和行为型模式（Behavioral Patterns）。

创建型模式

创建型模式关注对象的创建过程，旨在通过某种方式控制对象的创建，以实现解耦和增加灵活性。常见的创建型模式包括：

单例模式（Singleton）：确保一个类只有一个实例，并提供一个全局访问点。
工厂模式（Factory Method）：定义一个用于创建对象的接口，让子类决定实例化哪一个类。
抽象工厂模式（Abstract Factory）：提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。
建造者模式（Builder）：将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。
原型模式（Prototype）：用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象。

结构型模式

结构型模式关注类或对象的组合，旨在通过组合不同的类或对象来实现新的功能。常见的结构型模式包括：

适配器模式（Adapter）：将一个类的接口转换成客户希望的另一个接口，使原本由于接口不兼容而不能一起工作的类可以一起工作。
装饰者模式（Decorator）：动态地给一个对象添加一些额外的职责，就增加功能来说，装饰模式比生成子类更为灵活。
代理模式（Proxy）：为其他对象提供一种代理或占位符，以控制对这个对象的访问。
门面模式（Facade）：为子系统中的一组接口提供一个一致的界面，此模式定义了一个高层接口，这个接口使得这一子系统更加容易使用。
桥接模式（Bridge）：将抽象部分与它的实现部分分离，使它们都可以独立地变化。
组合模式（Composite）：将对象组合成树形结构以表示“部分-整体”的层次结构，组合模式使得用户对单个对象和组合对象的使用具有一致性。
享元模式（Flyweight）：运用共享技术有效地支持大量细粒度的对象。

行为型模式

行为型模式关注对象之间的交互和通信，旨在通过对象之间的交互来实现新的功能。常见的行为型模式包括：

模版方法模式（Template Method）：定义一个操作中的算法的骨架，而将一些步骤延迟到子类中。
策略模式（Strategy）：定义一系列的算法，把它们一个个封装起来，并且使它们可互相替换。
命令模式（Command）：将一个请求封装为一个对象，从而使你可用不同的请求对客户进行参数化、对请求排队或记录请求日志，以及支持可撤销的操作。
责任链模式（Chain of Responsibility）：使多个对象都有机会处理请求，从而避免请求的发送者和接收者之间的耦合关系。
状态模式（State）：允许一个对象在其内部状态改变时改变它的行为。
观察者模式（Observer）：定义对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。
中介者模式（Mediator）：用一个中介对象来封装一系列的对象交互，中介者使各对象不需要显式地相互引用，从而使其耦合松散，而且可以独立地改变它们之间的交互。
迭代器模式（Iterator）：提供一种方法顺序访问一个聚合对象中的各个元素，而又不需暴露该对象的内部表示。
访问者模式（Visitor）：表示一个作用于某对象结构中的各元素的操作，它使你可以在不修改各元素的类的前提下定义作用于这些元素的新操作。
备忘录模式（Memento）：在不破坏封装性的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态，这样以后就可将该对象恢复到原先保存的状态。
解释器模式（Interpreter）：给定一个语言，定义它的文法表示，并定义一个解释器，该解释器使用该表示来解释语言中的句子。

设计模式的作用

设计模式的主要作用包括：

提高代码的可读性：通过使用设计模式，可以使代码更加清晰易懂，便于其他开发者理解和维护。
提高代码的可重用性：设计模式提供了一套经过验证的解决方案，可以在不同的项目中重复使用。
提高代码的可扩展性：通过设计模式，可以使代码更加灵活，便于在将来进行扩展和修改。
促进团队协作：设计模式为团队成员提供了一种共同的语言和思维方式，有助于团队协作和沟通。

注意：虽然设计模式在软件开发中非常有用，但过度使用或滥用设计模式也可能导致代码过于复杂和难以维护。因此，在使用设计模式时，需要结合实际情况谨慎选择，确保设计模式的使用能够真正带来好处。

设计模式的优缺点

优点：

复用性高：设计模式基于最佳实践和经验总结，可以帮助开发人员在不同的项目中复用设计。
代码可维护性强：通过合理的设计模式应用，可以减少冗余代码，提高代码的可维护性。
系统扩展性好：设计模式往往是为了应对未来系统的扩展需求，因此系统在增加新功能时，不容易受到现有功能的影响。

缺点：

学习成本高：对于没有经验的开发人员，学习和理解设计模式可能需要一定时间。
设计过于复杂：滥用设计模式可能导致系统设计过于复杂，增加系统的维护成本。
性能问题：某些设计模式可能带来额外的性能开销，例如装饰器模式和代理模式可能会导致额外的层次和方法调用。

设计模式是软件开发中常用的解决方案，它们是对某些常见问题的最佳实践总结，可以帮助开发人员设计灵活、可维护、可扩展的代码。设计模式并不是具体的代码，而是一个可以在不同应用场景中反复使用的“模板”或“框架”。它们帮助开发者减少复杂性，提高代码的可复用性、可扩展性和可维护性。

一、创建型设计模式

创建型模式关注对象的创建过程，旨在通过某种方式控制对象的创建，以实现解耦和增加灵活性。以下是五种常见的创建型模式的详细讲解及其代码示例：

1. 单例模式（Singleton）

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

    #include <iostream>
    #include <mutex>
    
    class Singleton {
    private:
        static Singleton* instance;
        static std::mutex mtx; // 线程安全
        // 构造函数私有化，防止直接实例化
        Singleton() {
            std::cout << "Singleton Instance Created!" << std::endl;
        }
    public:
        // 禁止拷贝构造和赋值运算符
        Singleton(const Singleton&) = delete;
        Singleton& operator=(const Singleton&) = delete;
    
        // 提供全局访问点
        static Singleton* getInstance() {
            if (instance == nullptr) {
                std::lock_guard<std::mutex> lock(mtx);
                if (instance == nullptr) {
                    instance = new Singleton();
                }
            }
            return instance;
        }
    
        void show() {
            std::cout << "Hello from Singleton!" << std::endl;
        }
    };
    
    // 静态成员初始化
    Singleton* Singleton::instance = nullptr;
    std::mutex Singleton::mtx;
    
    int main() {
        Singleton* s1 = Singleton::getInstance();
        Singleton* s2 = Singleton::getInstance();
    
        s1->show();
        std::cout << (s1 == s2 ? "Instances are the same" : "Instances are different") << std::endl;
    
        return 0;
    }
        </std::mutex></mutex></iostream>

2. 工厂模式（Factory Method）

工厂模式定义一个用于创建对象的接口，让子类决定实例化哪一个类。

    #include <iostream>
    #include <memory>
    
    // 产品接口
    class Product {
    public:
        virtual void show() = 0;
        virtual ~Product() = default;
    };
    
    // 具体产品A
    class ProductA : public Product {
    public:
        void show() override {
            std::cout << "Product A created!" << std::endl;
        }
    };
    
    // 具体产品B
    class ProductB : public Product {
    public:
        void show() override {
            std::cout << "Product B created!" << std::endl;
        }
    };
    
    // 工厂接口
    class Factory {
    public:
        virtual std::shared_ptr<product> createProduct() = 0;
        virtual ~Factory() = default;
    };
    
    // 具体工厂A
    class FactoryA : public Factory {
    public:
        std::shared_ptr<product> createProduct() override {
            return std::make_shared<producta>();
        }
    };
    
    // 具体工厂B
    class FactoryB : public Factory {
    public:
        std::shared_ptr<product> createProduct() override {
            return std::make_shared<productb>();
        }
    };
    
    int main() {
        std::shared_ptr<factory> factoryA = std::make_shared<factorya>();
        std::shared_ptr<product> productA = factoryA->createProduct();
        productA->show();
    
        std::shared_ptr<factory> factoryB = std::make_shared<factoryb>();
        std::shared_ptr<product> productB = factoryB->createProduct();
        productB->show();
    
        return 0;
    }
        </product></factoryb></factory></product></factorya></factory></productb></product></producta></product></product></memory></iostream>

3. 抽象工厂模式（Abstract Factory）

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

    #include <iostream>
    #include <memory>
    
    // 抽象产品A
    class ProductA {
    public:
        virtual void show() = 0;
        virtual ~ProductA() = default;
    };
    
    // 抽象产品B
    class ProductB {
    public:
        virtual void display() = 0;
        virtual ~ProductB() = default;
    };
    
    // 具体产品A1
    class ProductA1 : public ProductA {
    public:
        void show() override {
            std::cout << "Product A1 created!" << std::endl;
        }
    };
    
    // 具体产品A2
    class ProductA2 : public ProductA {
    public:
        void show() override {
            std::cout << "Product A2 created!" << std::endl;
        }
    };
    
    // 具体产品B1
    class ProductB1 : public ProductB {
    public:
        void display() override {
            std::cout << "Product B1 created!" << std::endl;
        }
    };
    
    // 具体产品B2
    class ProductB2 : public ProductB {
    public:
        void display() override {
            std::cout << "Product B2 created!" << std::endl;
        }
    };
    
    // 抽象工厂
    class AbstractFactory {
    public:
        virtual std::shared_ptr<producta> createProductA() = 0;
        virtual std::shared_ptr<productb> createProductB() = 0;
        virtual ~AbstractFactory() = default;
    };
    
    // 具体工厂1
    class Factory1 : public AbstractFactory {
    public:
        std::shared_ptr<producta> createProductA() override {
            return std::make_shared<producta1>();
        }
    
        std::shared_ptr<productb> createProductB() override {
            return std::make_shared<productb1>();
        }
    };
    
    // 具体工厂2
    class Factory2 : public AbstractFactory {
    public:
        std::shared_ptr<producta> createProductA() override {
            return std::make_shared<producta2>();
        }
    
        std::shared_ptr<productb> createProductB() override {
            return std::make_shared<productb2>();
        }
    };
    
    int main() {
        std::shared_ptr<abstractfactory> factory1 = std::make_shared<factory1>();
        auto productA1 = factory1->createProductA();
        auto productB1 = factory1->createProductB();
        productA1->show();
        productB1->display();
    
        std::shared_ptr<abstractfactory> factory2 = std::make_shared<factory2>();
        auto productA2 = factory2->createProductA();
        auto productB2 = factory2->createProductB();
        productA2->show();
        productB2->display();
    
        return 0;
    }
        </factory2></abstractfactory></factory1></abstractfactory></productb2></productb></producta2></producta></productb1></productb></producta1></producta></productb></producta></memory></iostream>

4. 建造者模式（Builder）

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

#include <iostream>
#include <string>

// 产品类
class Product {
private:
    std::string partA;
    std::string partB;
    std::string partC;
public:
    void setPartA(const std::string& value) {
        partA = value;
    }
    void setPartB(const std::string& value) {
        partB = value;
    }
    void setPartC(const std::string& value) {
        partC = value;
    }
    void show() {
        std::cout << "Product built with: " << partA << ", " << partB << ", " << partC << std::endl;
    }
};

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

// 具体建造者
class ConcreteBuilder : public Builder {
private:
    Product product;
public:
    void buildPartA() override {
        product.setPartA("PartA");
    }
    void buildPartB() override {
        product.setPartB("PartB");
    }
    void buildPartC() override {
        product.setPartC("PartC");
    }
    Product getResult() override {
        return product;
    }
};

// 指挥者类
class Director {
private:
    Builder* builder;
public:
    Director(Builder* builder) : builder(builder) {}
    void construct() {
        builder->buildPartA();
        builder->buildPartB();
        builder->buildPartC();
    }
};

int main() {
    ConcreteBuilder builder;
    Director director(&builder);
    director.construct();
    Product product = builder.getResult();
    product.show();

    return 0;
}
    </string></iostream>

5. 原型模式（Prototype）

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

#include <iostream>
#include <memory>

// 原型类
class Prototype {
public:
    virtual std::shared_ptr<prototype> clone() const = 0;
    virtual void show() const = 0;
    virtual ~Prototype() = default;
};

// 具体原型A
class ConcretePrototypeA : public Prototype {
public:
    std::shared_ptr<prototype> clone() const override {
        return std::make_shared<concreteprototypea>(*this);
    }
    void show() const override {
        std::cout << "ConcretePrototypeA object cloned!" << std::endl;
    }
};

// 具体原型B
class ConcretePrototypeB : public Prototype {
public:
    std::shared_ptr<prototype> clone() const override {
        return std::make_shared<concreteprototypeb>(*this);
    }
    void show() const override {
        std::cout << "ConcretePrototypeB object cloned!" << std::endl;
    }
};

int main() {
    std::shared_ptr<prototype> prototypeA = std::make_shared<concreteprototypea>();
    std::shared_ptr<prototype> prototypeB = std::make_shared<concreteprototypeb>();

    // 克隆对象
    std::shared_ptr<prototype> clonedA = prototypeA->clone();
    std::shared_ptr<prototype> clonedB = prototypeB->clone();

    clonedA->show();
    clonedB->show();

    return 0;
}
    </prototype></prototype></concreteprototypeb></prototype></concreteprototypea></prototype></concreteprototypeb></prototype></concreteprototypea></prototype></prototype></memory></iostream>

二、结构型设计模式

结构型设计模式关注类或对象的组合，旨在通过组合不同的类或对象来实现新的功能。

1. 适配器模式（Adapter）

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

#include <iostream>
using namespace std;

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

// 被适配的类
class Adaptee {
public:
    void specificRequest() {
        cout << "Adaptee's specific request" << endl;
    }
};

// 适配器类
class Adapter : public Target {
private:
    Adaptee *adaptee;
public:
    Adapter(Adaptee *a) : adaptee(a) {}
    void request() override {
        adaptee->specificRequest(); // 调用Adaptee的特定请求方法
    }
};

int main() {
    Adaptee *adaptee = new Adaptee();
    Target *target = new Adapter(adaptee);
    target->request();  // 使用适配器模式
    delete adaptee;
    delete target;
    return 0;
}
    </iostream>

2. 装饰者模式（Decorator）

装饰者模式允许动态地给一个对象添加一些额外的职责，能够更灵活地增加功能，避免了通过继承来扩展功能。

#include <iostream>
using namespace std;

// 基础接口
class Component {
public:
    virtual void operation() = 0;
};

// 具体组件
class ConcreteComponent : public Component {
public:
    void operation() override {
        cout << "ConcreteComponent operation" << endl;
    }
};

// 装饰器基类
class Decorator : public Component {
protected:
    Component *component;
public:
    Decorator(Component *c) : component(c) {}
    void operation() override {
        component->operation();
    }
};

// 具体装饰器
class ConcreteDecoratorA : public Decorator {
public:
    ConcreteDecoratorA(Component *c) : Decorator(c) {}
    void operation() override {
        Decorator::operation();
        cout << "ConcreteDecoratorA operation" << endl;
    }
};

int main() {
    ConcreteComponent *component = new ConcreteComponent();
    Component *decorator = new ConcreteDecoratorA(component);
    decorator->operation();  // 动态增加功能
    delete component;
    delete decorator;
    return 0;
}
    </iostream>

3. 代理模式（Proxy）

代理模式为其他对象提供一种代理或占位符，以控制对这个对象的访问。代理模式可以在不改变客户端代码的情况下对被代理对象的操作进行控制。

#include <iostream>
using namespace std;

// 真实对象
class RealSubject {
public:
    void request() {
        cout << "RealSubject request" << endl;
    }
};

// 代理类
class Proxy {
private:
    RealSubject *realSubject;
public:
    Proxy() : realSubject(new RealSubject()) {}
    ~Proxy() {
        delete realSubject;
    }
    void request() {
        cout << "Proxy request" << endl;
        realSubject->request();  // 转发请求到真实对象
    }
};

int main() {
    Proxy proxy;
    proxy.request();  // 通过代理访问真实对象
    return 0;
}
    </iostream>

4. 门面模式（Facade）

门面模式为子系统中的一组接口提供一个一致的高层接口，使得这一子系统更加容易使用。

#include <iostream>
using namespace std;

class SubSystem1 {
public:
    void operation1() {
        cout << "SubSystem1 operation1" << endl;
    }
};

class SubSystem2 {
public:
    void operation2() {
        cout << "SubSystem2 operation2" << endl;
    }
};

class Facade {
private:
    SubSystem1 *subSystem1;
    SubSystem2 *subSystem2;
public:
    Facade() : subSystem1(new SubSystem1()), subSystem2(new SubSystem2()) {}
    ~Facade() {
        delete subSystem1;
        delete subSystem2;
    }
    void operation() {
        subSystem1->operation1();
        subSystem2->operation2();
    }
};

int main() {
    Facade facade;
    facade.operation();  // 使用门面类简化操作
    return 0;
}
    </iostream>

5. 桥接模式（Bridge）

桥接模式将抽象部分与它的实现部分分离，使它们都可以独立地变化。通过桥接模式，可以让不同的实现方式灵活地组合。

#include <iostream>
using namespace std;

// 实现接口
class Implementor {
public:
    virtual void operationImpl() = 0;
};

// 具体实现类
class ConcreteImplementorA : public Implementor {
public:
    void operationImpl() override {
        cout << "ConcreteImplementorA operationImpl" << endl;
    }
};

class ConcreteImplementorB : public Implementor {
public:
    void operationImpl() override {
        cout << "ConcreteImplementorB operationImpl" << endl;
    }
};

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

// 扩展抽象类
class RefinedAbstraction : public Abstraction {
public:
    RefinedAbstraction(Implementor *impl) : Abstraction(impl) {}
    void operation() override {
        implementor->operationImpl();  // 调用实现类的具体方法
    }
};

int main() {
    ConcreteImplementorA *implA = new ConcreteImplementorA();
    Abstraction *abstractionA = new RefinedAbstraction(implA);
    abstractionA->operation();  // 桥接模式使用
    delete implA;
    delete abstractionA;
    return 0;
}
    </iostream>

6. 组合模式（Composite）

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

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

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

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

// 组合类
class Composite : public Component {
private:
    vector<component*> children;
public:
    void add(Component *component) {
        children.push_back(component);
    }
    void operation() override {
        for (auto child : children) {
            child->operation();
        }
    }
    ~Composite() {
        for (auto child : children) {
            delete child;
        }
    }
};

int main() {
    Leaf *leaf1 = new Leaf();
    Leaf *leaf2 = new Leaf();
    Composite *composite = new Composite();
    composite->add(leaf1);
    composite->add(leaf2);
    composite->operation();  // 树形结构的操作
    delete composite;
    return 0;
}
    </component*></vector></iostream>

7. 享元模式（Flyweight）

享元模式通过共享技术有效地支持大量细粒度的对象，通过对象的共享减少内存使用。

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

class Flyweight {
public:
    virtual void operation(int extrinsicState) = 0;
};

// 具体享元类
class ConcreteFlyweight : public Flyweight {
public:
    void operation(int extrinsicState) override {
        cout << "ConcreteFlyweight operation with state: " << extrinsicState << endl;
    }
};

// 享元工厂
class FlyweightFactory {
private:
    unordered_map<int, flyweight*=""> flyweights;
public:
    Flyweight* getFlyweight(int key) {
        if (flyweights.find(key) == flyweights.end()) {
            flyweights[key] = new ConcreteFlyweight();
        }
        return flyweights[key];
    }
    ~FlyweightFactory() {
        for (auto& entry : flyweights) {
            delete entry.second;
        }
    }
};

int main() {
    FlyweightFactory factory;
    Flyweight *flyweight1 = factory.getFlyweight(1);
    flyweight1->operation(10);
    Flyweight *flyweight2 = factory.getFlyweight(2);
    flyweight2->operation(20);
    return 0;
}
    </int,></unordered_map></iostream>

三、行为型设计模式

行为型模式关注对象之间的交互和通信，旨在通过对象之间的交互来实现新的功能。以下是11种常见的行为型设计模式，包括每个模式的示例代码和解释。

1. 模板方法模式（Template Method）

模板方法模式定义了一个操作中的算法的骨架，而将一些步骤延迟到子类中。子类可以在不改变算法结构的情况下重新定义该步骤。

#include <iostream>
using namespace std;

// 抽象类，定义模板方法
class AbstractClass {
public:
    // 模板方法，定义算法的骨架
    void templateMethod() {
        stepOne();
        stepTwo();
        stepThree();
    }

    virtual void stepOne() = 0;  // 抽象方法，必须由子类实现
    virtual void stepTwo() = 0;  // 抽象方法，必须由子类实现
    virtual void stepThree() {
        cout << "Step Three: Default implementation." << endl;  // 可选的默认实现
    }
};

// 子类1，具体实现步骤
class ConcreteClassA : public AbstractClass {
public:
    void stepOne() override {
        cout << "ConcreteClassA Step One" << endl;
    }
    void stepTwo() override {
        cout << "ConcreteClassA Step Two" << endl;
    }
};

// 子类2，具体实现步骤
class ConcreteClassB : public AbstractClass {
public:
    void stepOne() override {
        cout << "ConcreteClassB Step One" << endl;
    }
    void stepTwo() override {
        cout << "ConcreteClassB Step Two" << endl;
    }
    void stepThree() override {
        cout << "ConcreteClassB Step Three" << endl;  // 自定义实现
    }
};

int main() {
    AbstractClass* classA = new ConcreteClassA();
    classA->templateMethod();

    cout << endl;

    AbstractClass* classB = new ConcreteClassB();
    classB->templateMethod();

    delete classA;
    delete classB;
    return 0;
}
</iostream>

2. 策略模式（Strategy）

策略模式定义一系列的算法，将它们一个个封装起来，并使它们可互相替换。策略模式使得算法可独立于使用它的客户而变化。

#include <iostream>
using namespace std;

// 策略接口
class Strategy {
public:
    virtual void execute() const = 0;
};

// 具体策略1
class ConcreteStrategyA : public Strategy {
public:
    void execute() const override {
        cout << "Executing Strategy A" << endl;
    }
};

// 具体策略2
class ConcreteStrategyB : public Strategy {
public:
    void execute() const override {
        cout << "Executing Strategy B" << endl;
    }
};

// 上下文类
class Context {
private:
    Strategy* strategy;  // 持有一个策略对象
public:
    Context(Strategy* strat) : strategy(strat) {}

    void setStrategy(Strategy* strat) {
        strategy = strat;
    }

    void executeStrategy() {
        strategy->execute();
    }
};

int main() {
    Strategy* strategyA = new ConcreteStrategyA();
    Context context(strategyA);
    context.executeStrategy();

    Strategy* strategyB = new ConcreteStrategyB();
    context.setStrategy(strategyB);
    context.executeStrategy();

    delete strategyA;
    delete strategyB;
    return 0;
}
</iostream>

3. 命令模式（Command）

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

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

// 命令接口
class Command {
public:
    virtual void execute() = 0;
    virtual void undo() = 0;
};

// 具体命令1
class ConcreteCommandA : public Command {
private:
    string receiver;
public:
    ConcreteCommandA(string receiver) : receiver(receiver) {}

    void execute() override {
        cout << "Command A executed by " << receiver << endl;
    }

    void undo() override {
        cout << "Undo Command A for " << receiver << endl;
    }
};

// 具体命令2
class ConcreteCommandB : public Command {
private:
    string receiver;
public:
    ConcreteCommandB(string receiver) : receiver(receiver) {}

    void execute() override {
        cout << "Command B executed by " << receiver << endl;
    }

    void undo() override {
        cout << "Undo Command B for " << receiver << endl;
    }
};

// 命令调用者
class Invoker {
private:
    vector<command*> commandList;
public:
    void addCommand(Command* command) {
        commandList.push_back(command);
    }

    void executeCommands() {
        for (auto& command : commandList) {
            command->execute();
        }
    }

    void undoCommands() {
        for (auto& command : commandList) {
            command->undo();
        }
    }
};

int main() {
    Invoker invoker;
    Command* commandA = new ConcreteCommandA("Receiver1");
    Command* commandB = new ConcreteCommandB("Receiver2");

    invoker.addCommand(commandA);
    invoker.addCommand(commandB);
    invoker.executeCommands();

    cout << "Undoing commands..." << endl;
    invoker.undoCommands();

    delete commandA;
    delete commandB;
    return 0;
}
</command*></vector></iostream>

4. 责任链模式（Chain of Responsibility）

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

#include <iostream>
using namespace std;

// 处理请求的抽象类
class Handler {
protected:
    Handler* nextHandler;
public:
    Handler() : nextHandler(nullptr) {}

    void setNextHandler(Handler* handler) {
        nextHandler = handler;
    }

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

// 具体处理者1
class ConcreteHandlerA : public Handler {
public:
    void handleRequest(int request) override {
        if (request < 10) {
            cout << "ConcreteHandlerA handled request " << request << endl;
        } else if (nextHandler) {
            nextHandler->handleRequest(request);
        }
    }
};

// 具体处理者2
class ConcreteHandlerB : public Handler {
public:
    void handleRequest(int request) override {
        if (request >= 10 && request < 20) {
            cout << "ConcreteHandlerB handled request " << request << endl;
        } else if (nextHandler) {
            nextHandler->handleRequest(request);
        }
    }
};

int main() {
    ConcreteHandlerA handlerA;
    ConcreteHandlerB handlerB;
    handlerA.setNextHandler(&handlerB);

    handlerA.handleRequest(5);  // 由handlerA处理
    handlerA.handleRequest(15); // 由handlerB处理
    handlerA.handleRequest(25); // 无人处理，直接退出

    return 0;
}
</iostream>

5. 状态模式（State）

状态模式允许一个对象在其内部状态改变时改变它的行为。

#include <iostream>
using namespace std;

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

// 具体状态1
class ConcreteStateA : public State {
public:
    void handle() override {
        cout << "Handling state A" << endl;
    }
};

// 具体状态2
class ConcreteStateB : public State {
public:
    void handle() override {
        cout << "Handling state B" << endl;
    }
};

// 环境类，持有当前状态
class Context {
private:
    State* currentState;
public:
    Context(State* state) : currentState(state) {}

    void setState(State* state) {
        currentState = state;
    }

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

int main() {
    ConcreteStateA stateA;
    ConcreteStateB stateB;

    Context context(&stateA);
    context.request();

    context.setState(&stateB);
    context.request();

    return 0;
}
</iostream>

6. 观察者模式（Observer）

观察者模式定义对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。

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

// 观察者接口
class Observer {
public:
    virtual void update(int state) = 0;
};

// 具体观察者
class ConcreteObserver : public Observer {
private:
    string name;
public:
    ConcreteObserver(string name) : name(name) {}

    void update(int state) override {
        cout << name << " received update with state " << state << endl;
    }
};

// 被观察者（主题）
class Subject {
private:
    vector<observer*> observers;
    int state;
public:
    void addObserver(Observer* observer) {
        observers.push_back(observer);
    }

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

    void setState(int newState) {
        state = newState;
        notifyObservers();
    }

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

int main() {
    Subject subject;
    ConcreteObserver observer1("Observer1");
    ConcreteObserver observer2("Observer2");

    subject.addObserver(&observer1);
    subject.addObserver(&observer2);

    subject.setState(10); // 所有观察者都会收到通知

    return 0;
}
</observer*></vector></iostream>

7. 中介者模式（Mediator）

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

#include <iostream>
using namespace std;

// 中介者接口
class Mediator {
public:
    virtual void sendMessage(string message, string colleagueName) = 0;
};

// 具体中介者
class ConcreteMediator : public Mediator {
private:
    class Colleague* colleague1;
    class Colleague* colleague2;
public:
    ConcreteMediator(class Colleague* c1, class Colleague* c2) : colleague1(c1), colleague2(c2) {}

    void sendMessage(string message, string colleagueName) override {
        if (colleagueName == "Colleague1") {
            colleague2->receiveMessage(message);
        } else {
            colleague1->receiveMessage(message);
        }
    }
};

// 同事类
class Colleague {
private:
    Mediator* mediator;
    string name;
public:
    Colleague(Mediator* med, string n) : mediator(med), name(n) {}

    void sendMessage(string message) {
        cout << name << " sends: " << message << endl;
        mediator->sendMessage(message, name);
    }

    void receiveMessage(string message) {
        cout << name << " receives: " << message << endl;
    }
};

int main() {
    ConcreteMediator* mediator;
    Colleague colleague1(mediator, "Colleague1");
    Colleague colleague2(mediator, "Colleague2");

    mediator = new ConcreteMediator(&colleague1, &colleague2);

    colleague1.sendMessage("Hello from Colleague1");
    colleague2.sendMessage("Hello from Colleague2");

    delete mediator;
    return 0;
}
</iostream>

8. 迭代器模式（Iterator）

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

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

// 迭代器接口
template <typename t="">
class Iterator {
public:
    virtual bool hasNext() = 0;
    virtual T next() = 0;
};

// 聚合类（容器）
template <typename t="">
class Aggregate {
public:
    virtual Iterator<t>* createIterator() = 0;
};

// 具体聚合类
template <typename t="">
class ConcreteAggregate : public Aggregate<t> {
private:
    vector<t> items;
public:
    void addItem(T item) {
        items.push_back(item);
    }

    Iterator<t>* createIterator() override {
        return new ConcreteIterator<t>(items);
    }

private:
    class ConcreteIterator : public Iterator<t> {
    private:
        vector<t> items;
        int position;
    public:
        ConcreteIterator(vector<t>& items) : items(items), position(0) {}

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

        T next() override {
            return items[position++];
        }
    };
};

int main() {
    ConcreteAggregate<int> aggregate;
    aggregate.addItem(1);
    aggregate.addItem(2);
    aggregate.addItem(3);

    Iterator<int>* iterator = aggregate.createIterator();
    while (iterator->hasNext()) {
        cout << iterator->next() << " ";
    }
    cout << endl;

    delete iterator;
    return 0;
}
</int></int></t></t></t></t></t></t></t></typename></t></typename></typename></vector></iostream>

9. 访问者模式（Visitor）

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

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

// 访问者接口
class Visitor {
public:
    virtual void visit(class ElementA&) = 0;
    virtual void visit(class ElementB&) = 0;
};

// 元素接口
class Element {
public:
    virtual void accept(Visitor& visitor) = 0;
};

// 具体元素1
class ElementA : public Element {
public:
    void accept(Visitor& visitor) override {
        visitor.visit(*this);
    }
};

// 具体元素2
class ElementB : public Element {
public:
    void accept(Visitor& visitor) override {
        visitor.visit(*this);
    }
};

// 具体访问者
class ConcreteVisitor : public Visitor {
public:
    void visit(ElementA& element) override {
        cout << "Visiting ElementA" << endl;
    }

    void visit(ElementB& element) override {
        cout << "Visiting ElementB" << endl;
    }
};

int main() {
    vector<element*> elements;
    elements.push_back(new ElementA());
    elements.push_back(new ElementB());

    ConcreteVisitor visitor;
    for (auto& element : elements) {
        element->accept(visitor);
    }

    // 清理
    for (auto& element : elements) {
        delete element;
    }
    return 0;
}
</element*></vector></iostream>

10. 备忘录模式（Memento）

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

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

// 备忘录类
class Memento {
private:
    string state;
public:
    Memento(const string& state) : state(state) {}

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

// 发起人类
class Originator {
private:
    string state;
public:
    void setState(const string& state) {
        this->state = state;
    }

    string getState() const {
        return state;
    }

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

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

// 管理员类
class Caretaker {
private:
    Memento* memento;
public:
    void saveMemento(Memento* memento) {
        this->memento = memento;
    }

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

int main() {
    Originator originator;
    originator.setState("State1");

    Caretaker caretaker;
    caretaker.saveMemento(originator.saveToMemento());

    originator.setState("State2");
    cout << "Current state: " << originator.getState() << endl;

    originator.restoreFromMemento(caretaker.getMemento());
    cout << "Restored state: " << originator.getState() << endl;

    return 0;
}
</string></iostream>

11. 解释器模式（Interpreter）

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

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

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

// 数字类
class Number : public Expression {
private:
    int number;
public:
    Number(int number) : number(number) {}

    int interpret() override {
        return number;
    }
};

// 加法表达式类
class Add : public Expression {
private:
    Expression* left;
    Expression* right;
public:
    Add(Expression* left, Expression* right) : left(left), right(right) {}

    int interpret() override {
        return left->interpret() + right->interpret();
    }
};

// 解析器
class Context {
private:
    string expression;
public:
    Context(const string& expression) : expression(expression) {}

    Expression* parse() {
        stringstream ss(expression);
        string token;
        ss >> token;

        if (token == "+") {
            int left, right;
            ss >> left >> right;
            return new Add(new Number(left), new Number(right));
        }

        return new Number(stoi(token));
    }
};

int main() {
    string expression = "+ 3 5";
    Context context(expression);

    Expression* exp = context.parse();
    cout << "Result: " << exp->interpret() << endl;

    delete exp;
    return 0;
}
</sstream></string></iostream>

上面是常见的3类共23种设计模式，如果你还觉得不过瘾，那么请点击开这个：101种设计模式，加油哦！学习愉快。

阅读完毕，很棒哦！

上一篇：面向对象和面向函数之争

下一篇：分布式场景下的资损防控