devbox
IT小白
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

设计模式3-分类

作者：IT小白 | 2024-06-26 15:00:33

赞

踩

设计模式3-分类

设计模式-分类

模式的分类

从目的来分

设计模式（Design Patterns）是一种解决特定问题的通用解决方案，通常分为以下三类：

  1. 创建型模式（Creational Patterns）：

    • 主要关注对象的创建过程，旨在将对象的创建过程与使用过程分离，以提高代码的灵活性和可维护性。

  2. 结构型模式（Structural Patterns）：

    • 主要关注类和对象的组合，旨在通过不同的方式将类或对象组合在一起，以形成更大的结构，从而解决设计中的一些问题。

  3. 行为型模式（Behavioral Patterns）：

    • 主要关注类和对象之间的交互，旨在通过合理安排类和对象之间的职责和通信方式，来提高系统的灵活性和可扩展性。

创建型模式（Creational Patterns）

  1. 工厂方法模式（Factory Method）：

    • 定义一个接口用于创建对象，但由子类决定实例化哪一个类。使得一个类的实例化延迟到其子类。
    class Product {
public:
    virtual void use() = 0;
};

class ConcreteProductA : public Product {
public:
    void use() override {
        // Implementation for Product A
    }
};

class ConcreteProductB : public Product {
public:
    void use() override {
        // Implementation for Product B
    }
};

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

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

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

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37

  2. 抽象工厂模式（Abstract Factory）：

    • 提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。
    class AbstractProductA {
public:
    virtual void use() = 0;
};

class AbstractProductB {
public:
    virtual void consume() = 0;
};

class ConcreteProductA1 : public AbstractProductA {
public:
    void use() override {
        // Implementation for Product A1
    }
};

class ConcreteProductA2 : public AbstractProductA {
public:
    void use() override {
        // Implementation for Product A2
    }
};

class ConcreteProductB1 : public AbstractProductB {
public:
    void consume() override {
        // Implementation for Product B1
    }
};

class ConcreteProductB2 : public AbstractProductB {
public:
    void consume() override {
        // Implementation for Product B2
    }
};

class AbstractFactory {
public:
    virtual AbstractProductA* createProductA() = 0;
    virtual AbstractProductB* createProductB() = 0;
};

class ConcreteFactory1 : public AbstractFactory {
public:
    AbstractProductA* createProductA() override {
        return new ConcreteProductA1();
    }

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

class ConcreteFactory2 : public AbstractFactory {
public:
    AbstractProductA* createProductA() override {
        return new ConcreteProductA2();
    }

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

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65

  3. 单例模式（Singleton）：

    • 确保一个类只有一个实例，并提供一个全局访问点。
    class Singleton {
private:
    static Singleton* instance;
    Singleton() {}  // Private constructor

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

Singleton* Singleton::instance = nullptr;

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15

  4. 生成器模式（Builder）：

    • 将一个复杂对象的构建过程与它的表示分离，使得同样的构建过程可以创建不同的表示。
    class Product {
private:
    std::string partA;
    std::string partB;
    std::string partC;

public:
    void setPartA(const std::string& part) { partA = part; }
    void setPartB(const std::string& part) { partB = part; }
    void setPartC(const std::string& part) { partC = part; }
    void show() {
        // Implementation to show the product
    }
};

class Builder {
public:
    virtual void buildPartA() = 0;
    virtual void buildPartB() = 0;
    virtual void buildPartC() = 0;
    virtual Product* getResult() = 0;
};

class ConcreteBuilder : public Builder {
private:
    Product* product;

public:
    ConcreteBuilder() { product = new Product(); }
    void buildPartA() override { product->setPartA("Part A"); }
    void buildPartB() override { product->setPartB("Part B"); }
    void buildPartC() override { product->setPartC("Part C"); }
    Product* getResult() override { return product; }
};

class Director {
private:
    Builder* builder;

public:
    void setBuilder(Builder* b) { builder = b; }
    void construct() {
        builder->buildPartA();
        builder->buildPartB();
        builder->buildPartC();
    }
};

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47

  5. 原型模式（Prototype）：

    • 用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象。
    class Prototype {
public:
    virtual Prototype* clone() const = 0;
};

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

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11

结构型模式（Structural Patterns）

  1. 适配器模式（Adapter）：

    • 将一个类的接口转换成客户希望的另外一个接口，使得原本由于接口不兼容而不能一起工作的类可以一起工作。
    class Target {
public:
    virtual void request() = 0;
};

class Adaptee {
public:
    void specificRequest() {
        // Specific implementation
    }
};

class Adapter : public Target {
private:
    Adaptee* adaptee;

public:
    Adapter(Adaptee* a) : adaptee(a) {}
    void request() override {
        adaptee->specificRequest();
    }
};

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22

  2. 桥接模式（Bridge）：

    • 将抽象部分与它的实现部分分离，使它们都可以独立地变化。
    class Implementor {
public:
    virtual void operationImpl() = 0;
};

class ConcreteImplementorA : public Implementor {
public:
    void operationImpl() override {
        // Implementation A
    }
};

class ConcreteImplementorB : public Implementor {
public:
    void operationImpl() override {
        // Implementation B
    }
};

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();
    }
};

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35

  3. 组合模式（Composite）：

    • 将对象组合成树形结构以表示“部分-整体”的层次结构。组合模式使得用户对单个对象和组合对象的使用具有一致性。
    class Component {
public:
    virtual void operation() = 0;
    virtual void add(Component* component) {}
    virtual void remove(Component* component) {}
    virtual Component* getChild(int index) { return nullptr; }
};

class Leaf : public Component {
public:
    void operation() override {
        // Implementation of leaf node
    }
};

class Composite : public Component {
private:
    std::vector<Component*> children;

public:
    void operation() override {
        for (Component* child : children) {
            child->operation();
        }
    }

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

    void remove(Component* component) override {
        children.erase(std::remove(children.begin(), children.end(), component), children.end());
    }

    Component* getChild(int index) override {
        return children.at(index);
    }
};

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38

  4. 装饰模式（Decorator）：

    • 动态地给一个对象添加一些额外的职责，就增加功能来说，装饰模式比生成子类更为灵活。
    class Component {
public:
    virtual void operation() = 0;
};

class ConcreteComponent : public Component {
public:
    void operation() override {
        // Basic implementation
    }
};

class Decorator : public Component {
protected:

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14

行为型模式（Behavioral Patterns）

行为型模式（Behavioral Patterns）关注对象之间的责任分配以及对象之间的通信。它们帮助实现对象之间的灵活通信和职责分配，从而提高系统的可扩展性和可维护性。以下是一些常见的行为型设计模式及其 C++ 示例：

  1. 策略模式（Strategy Pattern）
  2. 观察者模式（Observer Pattern）
  3. 命令模式（Command Pattern）
  4. 职责链模式（Chain of Responsibility Pattern）
  5. 状态模式（State Pattern）

1. 策略模式（Strategy Pattern）

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

示例代码：

#include <iostream>
#include <memory>

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

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

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

// 上下文类
class Context {
private:
    std::unique_ptr<Strategy> strategy;
public:
    void setStrategy(std::unique_ptr<Strategy> strategy) {
        this->strategy = std::move(strategy);
    }

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

int main() {
    Context context;
    context.setStrategy(std::make_unique<ConcreteStrategyA>());
    context.executeStrategy();

    context.setStrategy(std::make_unique<ConcreteStrategyB>());
    context.executeStrategy();

    return 0;
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49

2. 观察者模式（Observer Pattern）

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

示例代码：

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

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

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

    void update(int state) override {
        std::cout << "Observer " << name << " updated with state " << state << std::endl;
    }
};

// 主题接口
class Subject {
public:
    virtual void attach(std::shared_ptr<Observer> observer) = 0;
    virtual void detach(std::shared_ptr<Observer> observer) = 0;
    virtual void notify() = 0;
};

// 具体主题
class ConcreteSubject : public Subject {
private:
    std::vector<std::shared_ptr<Observer>> observers;
    int state;
public:
    void attach(std::shared_ptr<Observer> observer) override {
        observers.push_back(observer);
    }

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

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

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

int main() {
    auto subject = std::make_shared<ConcreteSubject>();

    auto observer1 = std::make_shared<ConcreteObserver>("Observer 1");
    auto observer2 = std::make_shared<ConcreteObserver>("Observer 2");

    subject->attach(observer1);
    subject->attach(observer2);

    subject->setState(1);
    subject->setState(2);

    subject->detach(observer1);
    subject->setState(3);

    return 0;
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73

3. 命令模式（Command Pattern）

命令模式将请求封装成对象，以便使用不同的请求、队列或者日志来参数化其他对象。命令模式也支持可撤销的操作。

示例代码：

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

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

// 具体命令A
class ConcreteCommandA : public Command {
public:
    void execute() const override {
        std::cout << "Executing Command A" << std::endl;
    }
};

// 具体命令B
class ConcreteCommandB : public Command {
public:
    void execute() const override {
        std::cout << "Executing Command B" << std::endl;
    }
};

// 调用者
class Invoker {
private:
    std::vector<std::unique_ptr<Command>> commands;
public:
    void setCommand(std::unique_ptr<Command> command) {
        commands.push_back(std::move(command));
    }

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

int main() {
    Invoker invoker;
    invoker.setCommand(std::make_unique<ConcreteCommandA>());
    invoker.setCommand(std::make_unique<ConcreteCommandB>());
    invoker.executeCommands();

    return 0;
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50

4. 职责链模式（Chain of Responsibility Pattern）

职责链模式为请求创建了一个接收对象的链。这种模式给予请求的类型，对请求的发送者和接收者进行解耦。通过这种模式，多个对象都有机会处理这个请求。

示例代码：

#include <iostream>
#include <memory>

// 处理者接口
class Handler {
public:
    virtual void setNext(std::shared_ptr<Handler> nextHandler) = 0;
    virtual void handleRequest(int request) = 0;
};

// 具体处理者A
class ConcreteHandlerA : public Handler {
private:
    std::shared_ptr<Handler> next;
public:
    void setNext(std::shared_ptr<Handler> nextHandler) override {
        next = nextHandler;
    }

    void handleRequest(int request) override {
        if (request < 10) {
            std::cout << "ConcreteHandlerA handled request " << request << std::endl;
        } else if (next) {
            next->handleRequest(request);
        }
    }
};

// 具体处理者B
class ConcreteHandlerB : public Handler {
private:
    std::shared_ptr<Handler> next;
public:
    void setNext(std::shared_ptr<Handler> nextHandler) override {
        next = nextHandler;
    }

    void handleRequest(int request) override {
        if (request >= 10 && request < 20) {
            std::cout << "ConcreteHandlerB handled request " << request << std::endl;
        } else if (next) {
            next->handleRequest(request);
        }
    }
};

int main() {
    auto handlerA = std::make_shared<ConcreteHandlerA>();
    auto handlerB = std::make_shared<ConcreteHandlerB>();
    
    handlerA->setNext(handlerB);

    handlerA->handleRequest(5);
    handlerA->handleRequest(15);

    return 0;
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57

5. 状态模式（State Pattern）

状态模式允许对象在其内部状态改变时改变它的行为。对象看起来似乎修改了它的类。

示例代码：

#include <iostream>
#include <memory>

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

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

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

// 上下文类
class Context {
private:
    std::shared_ptr<State> state;
public:
    Context(std::shared_ptr<State> state) : state(state) {}

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

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

int main() {
    auto stateA = std::make_shared<ConcreteStateA>();
    auto stateB = std::make_shared<ConcreteStateB>();

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

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

    return 0;
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53

以上示例展示了行为型设计模式的基本概念和如何使用 C++ 实现这些模式。通过这些模式，可以更好地组织代码，实现更灵活和可维护的系统。

从范围来分

设计模式还可以根据范围分为两类：

  1. 类模式（Class Patterns）：

    • 处理类与子类之间的静态关系，主要通过继承来完成。它们在编译时确定，通常是针对类的结构和行为进行定义和操作。

  2. 对象模式（Object Patterns）：

    • 处理对象间的动态关系，主要通过对象的组合和委托来完成。它们在运行时确定，通常是通过定义对象间的通信和协作来实现功能。

类模式（Class Patterns）

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

    • 定义一个操作中的算法骨架，而将一些步骤延迟到子类中。模板方法使得子类可以不改变算法的结构即可重新定义算法的某些步骤。
    class AbstractClass {
public:
    void templateMethod() {
        primitiveOperation1();
        primitiveOperation2();
    }

    virtual void primitiveOperation1() = 0;
    virtual void primitiveOperation2() = 0;
};

class ConcreteClass : public AbstractClass {
public:
    void primitiveOperation1() override {
        // Implementation of primitive operation 1
    }

    void primitiveOperation2() override {
        // Implementation of primitive operation 2
    }
};

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21

  2. 工厂方法模式（Factory Method）：

    • 定义一个用于创建对象的接口，让子类决定实例化哪一个类。工厂方法使一个类的实例化延迟到其子类。
    class Product {
public:
    virtual void use() = 0;
};

class ConcreteProduct : public Product {
public:
    void use() override {
        // Implementation
    }
};

class Creator {
public:
    virtual Product* factoryMethod() = 0;

    Product* create() {
        return factoryMethod();
    }
};

class ConcreteCreator : public Creator {
public:
    Product* factoryMethod() override {
        return new ConcreteProduct();
    }
};

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27

对象模式（Object Patterns）

  1. 观察者模式（Observer）：

    • 定义对象间的一对多依赖关系，使得每当一个对象改变状态，则所有依赖于它的对象都会得到通知并被自动更新。
    class Observer {
public:
    virtual void update() = 0;
};

class ConcreteObserver : public Observer {
public:
    void update() override {
        // Implementation of update
    }
};

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 (Observer* observer : observers) {
            observer->update();
        }
    }
};

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31

  2. 策略模式（Strategy）：

    • 定义一系列算法，把它们一个个封装起来，并且使它们可相互替换。本模式使得算法可独立于使用它的客户而变化。
    class Strategy {
public:
    virtual void algorithmInterface() = 0;
};

class ConcreteStrategyA : public Strategy {
public:
    void algorithmInterface() override {
        // Implementation of algorithm A
    }
};

class ConcreteStrategyB : public Strategy {
public:
    void algorithmInterface() override {
        // Implementation of algorithm B
    }
};

class Context {
private:
    Strategy* strategy;

public:
    Context(Strategy* s) : strategy(s) {}

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

    void contextInterface() {
        strategy->algorithmInterface();
    }
};

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34

类模式和对象模式的区别

  • 类模式：

    • 通过继承关系定义类的静态结构和行为。
    • 继承关系在编译时确定。
    • 类模式通常用来描述类与类之间的关系，主要通过类的继承、模板方法等实现。

  • 对象模式：

    • 通过组合或委托定义对象间的动态关系。
    • 对象间的关系在运行时确定。
    • 对象模式通常用来描述对象之间的协作，主要通过对象的组合、策略、观察者等实现。

通过合理使用类模式和对象模式，可以在设计中实现灵活性和可扩展性，解决复杂的软件设计问题。

从封装变化角度对模式分类

从封装变化的角度来看，设计模式可以分为以下几类：

  1. 组件协作：

    • 封装了对象之间的交互和协作方式。
    • 例子：观察者模式（Observer Pattern）、中介者模式（Mediator Pattern）。

  2. 单一职责：

    • 封装了一个类或对象应当只负责一项职责的原则。
    • 例子：单一职责原则（Single Responsibility Principle），但这更像是一种设计原则而非具体模式。

  3. 对象创建：

    • 封装对象实例化的过程，避免直接使用 new 操作符。
    • 例子：工厂方法模式（Factory Method Pattern）、抽象工厂模式（Abstract Factory Pattern）、生成器模式（Builder Pattern）、原型模式（Prototype Pattern）、单例模式（Singleton Pattern）。

  4. 对象性能：

    • 封装对象性能优化的方法，例如对象的复用、内存管理等。
    • 例子：享元模式（Flyweight Pattern）。

  5. 接口隔离：

    • 封装接口设计，使得接口尽量小而专注于单一职责。
    • 例子：接口隔离原则（Interface Segregation Principle），类似单一职责，这也是一种设计原则。

  6. 状态变化：

    • 封装对象的状态及其变化。
    • 例子：状态模式（State Pattern）、备忘录模式（Memento Pattern）。

  7. 数据结构：

    • 封装数据结构及其操作方法。
    • 例子：组合模式（Composite Pattern）、迭代器模式（Iterator Pattern）。

  8. 行为变化：

    • 封装算法或行为，使其可以在对象间独立变化。
    • 例子：策略模式（Strategy Pattern）、命令模式（Command Pattern）、职责链模式（Chain of Responsibility Pattern）、模板方法模式（Template Method Pattern）。

  9. 领域问题：

    • 封装特定领域的逻辑和问题。
    • 例子：领域驱动设计（Domain-Driven Design），其中包括各种聚合根、实体、值对象等。

以下是每种分类的 C++ 示例：

组件协作

观察者模式：

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

class ConcreteObserver : public Observer {
public:
    void update() override {
        // Implementation of update
    }
};

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 (Observer* observer : observers) {
            observer->update();
        }
    }
};

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31

单一职责

单一职责原则（示例化为类）：

class FileReader {
public:
    std::string read(const std::string& filePath) {
        // Read file content
    }
};

class FileWriter {
public:
    void write(const std::string& filePath, const std::string& content) {
        // Write content to file
    }
};

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13

对象创建

工厂方法模式：

class Product {
public:
    virtual void use() = 0;
};

class ConcreteProduct : public Product {
public:
    void use() override {
        // Implementation
    }
};

class Creator {
public:
    virtual Product* factoryMethod() = 0;

    Product* create() {
        return factoryMethod();
    }
};

class ConcreteCreator : public Creator {
public:
    Product* factoryMethod() override {
        return new ConcreteProduct();
    }
};

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27

对象性能

享元模式：

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

class ConcreteFlyweight : public Flyweight {
public:
    void operation() override {
        // Implementation
    }
};

class FlyweightFactory {
private:
    std::unordered_map<std::string, Flyweight*> flyweights;

public:
    Flyweight* getFlyweight(const std::string& key) {
        if (flyweights.find(key) == flyweights.end()) {
            flyweights[key] = new ConcreteFlyweight();
        }
        return flyweights[key];
    }
};

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24

接口隔离

接口隔离原则（示例化为类）：

class Printer {
public:
    virtual void print() = 0;
};

class Scanner {
public:
    virtual void scan() = 0;
};

class AllInOnePrinter : public Printer, public Scanner {
public:
    void print() override {
        // Implementation
    }

    void scan() override {
        // Implementation
    }
};

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20

状态变化

状态模式：

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

class ConcreteStateA : public State {
public:
    void handle() override {
        // Implementation of handle A
    }
};

class ConcreteStateB : public State {
public:
    void handle() override {
        // Implementation of handle B
    }
};

class Context {
private:
    State* state;

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

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

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

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34

数据结构

组合模式：

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

class Leaf : public Component {
public:
    void operation() override {
        // Implementation of leaf operation
    }
};

class Composite : public Component {
private:
    std::vector<Component*> children;

public:
    void operation() override {
        for (Component* 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());
    }
};

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31

行为变化

策略模式：

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

class ConcreteStrategyA : public Strategy {
public:
    void algorithmInterface() override {
        // Implementation of algorithm A
    }
};

class ConcreteStrategyB : public Strategy {
public:
    void algorithmInterface() override {
        // Implementation of algorithm B
    }
};

class Context {
private:
    Strategy* strategy;

public:
    Context(Strategy* s) : strategy(s) {}

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

    void contextInterface() {
        strategy->algorithmInterface();
    }
};

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34

领域问题

领域驱动设计（示例化为类）：

class ValueObject {
private:
    int value;

public:
    ValueObject(int v) : value(v) {}

    int getValue() const {
        return value;
    }

    bool operator==(const ValueObject& other) const {
        return value == other.value;
    }
};

class Entity {
private:
    int id;
    ValueObject valueObject;

public:
    Entity(int i, ValueObject v) : id(i), valueObject(v) {}

    int getId() const {
        return id;
    }

    ValueObject getValueObject() const {
        return valueObject;
    }
};

class AggregateRoot : public Entity {
public:
    using Entity::Entity;

    void doSomething() {
        // Implementation
    }
};

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41

这些示例展示了如何从封装变化的角度，使用C++实现不同的设计模式。

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/IT小白/article/detail/759699
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号