【重走编程路】设计模式概述（十二） -- 访问者模式、中介者模式、解释器模式

  • 开发
  • 15

文章目录

前言

行为型模式关注对象之间的交互以及如何分配职责，提供了一种定义对象之间的行为和职责的最佳方式。本章介绍创建型模式中的访问者模式、中介者模式和解释器模式。

21. 访问者模式（Visitor）

定义

访问者模式是一种将数据操作与数据结构分离的设计模式。它定义了一个作用于某对象结构中的各元素的操作，它可以在不修改各元素的类的前提下定义作用于这些元素的新操作。访问者模式使得用户可以在不修改现有类层次结构的情况下，增加新的操作。

问题

在软件设计中，经常需要在不修改现有类结构的情况下，为对象结构中的元素添加新的操作。如果直接在元素类中增加新的方法，会违反开闭原则（对扩展开放，对修改关闭），因为每增加一个新的操作，都需要修改所有元素类。

解决方案

访问者模式通过将操作封装在访问者类中，并将接受访问者访问的元素类设计为可接受访问者访问的接口，从而实现操作的增加不依赖于元素类的修改。具体地，访问者模式定义了一个访问者接口，该接口声明了所有要作用于元素类上的操作；同时，每个元素类都包含一个接受访问者对象的accept方法，该方法将访问者对象作为参数传入，并调用访问者对象中的相应方法来执行操作。

#include <iostream>
#include <string>

class Cat;
class Dog;

// 访问者接口
class AnimalVisitor {
public:
    virtual void Visit(Cat& cat) = 0;
    virtual void Visit(Dog& dog) = 0;
    virtual ~AnimalVisitor() {}
};

// 具体访问者：喂食
class FeedVisitor : public AnimalVisitor {
public:
    void Visit(Cat& cat) override {
        std::cout << "Feeding cat with fish." << std::endl;
    }

    void Visit(Dog& dog) override {
        std::cout << "Feeding dog with bone." << std::endl;
    }
};

// 动物基类，包含接受访问者的方法
class Animal {
public:
    virtual void Accept(AnimalVisitor& visitor) = 0;
    virtual ~Animal() {}
};

// 具体动物类：猫
class Cat : public Animal {
public:
    void Accept(AnimalVisitor& visitor) override {
        visitor.Visit(*this);
    }
};

// 具体动物类：狗
class Dog : public Animal {
public:
    void Accept(AnimalVisitor& visitor) override {
        visitor.Visit(*this);
    }
};

int main() {
    Cat cat;
    Dog dog;
    FeedVisitor feeder;

    cat.Accept(feeder);
    dog.Accept(feeder);

    return 0;
}

应用场景

  1. 当一个对象结构包含很多类对象，它们有不同的接口，而你想对这些对象实施一些依赖于其具体类的操作。
  2. 需要对对象结构中的对象进行很多不同的并且不相关的操作，而你想避免让这些操作“污染”这些对象的类。
  3. 当对象结构中的对象经常被修改，但调用这些对象的操作却不应该被修改时。

优缺点

优点：

  • 增加新的操作很容易：无需修改现有的类层次结构，只需要增加一个新的访问者类即可。
  • 将有关的行为集中到一个访问者对象中：使得相关的操作更加容易理解和维护。
  • 灵活性：可以在运行时动态地改变对象的行为。

缺点：

  • 增加新的元素类时较为困难：每增加一个新的元素类，都需要修改访问者接口，增加一个新的访问方法。
  • 破坏封装：访问者可以访问并修改元素的状态，这可能会破坏元素的封装性。
  • 性能问题：如果访问者对象访问的元素非常多，那么访问者的效率可能会成为问题。

22. 中介者模式（Mediator）

定义

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

要解决的问题

在软件系统中，对象之间的直接交互可能会导致类的职责过多，进而增加代码的复杂性和维护难度。特别是当多个对象之间存在复杂的交互关系时，如果它们直接相互引用和通信，会使得系统的结构变得混乱，难以理解和维护。

解决方案

中介者模式通过引入一个中介者对象来管理对象之间的交互，各个对象通过中介者对象来间接地与其他对象通信。这样，对象之间不再需要显式地相互引用，降低了它们之间的耦合度，使得系统更加灵活和易于维护。

#include <iostream>  
#include <vector>  
#include <string>  

// 聊天者接口  
class Chatter {
public:
    virtual ~Chatter() {}
    virtual void Send(const std::string& message) = 0;
    virtual void Receive(const std::string& from, const std::string& message) = 0;
    virtual std::string GetName() const = 0;
};

// 中介者接口  
class ChatMediator {
public:
    virtual ~ChatMediator() {}
    virtual void RegisterChatter(Chatter* chatter) = 0;
    virtual void SendMessage(Chatter* sender, const std::string& message) = 0;
};

// 聊天者实现
class User : public Chatter {
private:
    std::string name;
    ChatMediator* mediator;

public:
    User(const std::string& name, ChatMediator* mediator) : name(name), mediator(mediator) {}

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

    void Receive(const std::string& from, const std::string& message) override {
        std::cout << from << ": " << message << std::endl;
    }

    std::string GetName() const override {
        return name;
    }
};

// 中介者实现  
class ConcreteChatMediator : public ChatMediator {
private:
    std::vector<Chatter*> chatters;

public:
    void RegisterChatter(Chatter* chatter) override {
        chatters.push_back(chatter);
    }

    void SendMessage(Chatter* sender, const std::string& message) override {
        for (auto chatter : chatters) {
            if (chatter != sender) {
                chatter->Receive(sender->GetName(), message);
            }
        }
    }
};

int main() {
    ConcreteChatMediator mediator;
    User alice("Alice", &mediator);
    User bob("Bob", &mediator);

    mediator.RegisterChatter(&alice);
    mediator.RegisterChatter(&bob);

    alice.Send("Hello, Bob!");
    bob.Send("Hi, Alice. How are you?");
    return 0;
}

应用场景

  1. 聊天室系统：中介者负责转发各个聊天者之间的消息。
  2. MVC框架：控制器（Controller）作为中介者，负责接收用户的输入，并调用模型和视图来完成相应的业务逻辑和界面更新。
  3. 事件处理系统：中介者负责管理和分发事件，各个事件监听者通过中介者来接收和处理事件。

优缺点

优点：

  • 降低耦合度：通过中介者对象来管理对象之间的交互，降低了对象之间的耦合度。
  • 易于维护：由于减少了对象之间的直接引用，系统的结构更加清晰，易于理解和维护。
  • 灵活：可以独立地改变对象之间的交互方式，而不需要修改对象的代码。

缺点：

  • 中介者可能会变得复杂：如果系统中对象之间的交互非常复杂，中介者对象可能会变得庞大和难以维护。
  • 增加了中介者类的负担：所有对象之间的交互都需要通过中介者来进行，这可能会增加中介者类的负担。

23. 解释器模式（Interpreter）

定义

解释器模式定义了一个语言的文法，并构建一个解释器来解释这个语言中的句子。这种模式允许程序通过定义一套规则（即文法）来解释一种特定类型的表达式或语句。在解释器模式中，每个表达式的组成部分都被表示为一个类，这些类共同工作来解析表达式。

解决方案

解释器模式通常使用递归的方式来实现表达式的解析，每个非终结符表达式都依赖于其他表达式来解析其组成部分。可以将语句表示为抽象语法树，然后通过解释器逐步执行和解释这个语法树。
解释器模式主要围绕以下几个角色和组件来构建：

  1. 抽象表达式（Abstract Expression）： 声明一个抽象的解释操作，该操作由具体的表达式角色实现。
  2. 终结符表达式（Terminal Expression）： 实现与文法中的终结符相关的操作，一个终结符是文法中最基本的单位，它不可再分。
  3. 非终结符表达式（Non-terminal Expression）： 为文法中的非终结符实现解释操作，非终结符需要进一步的解释。
  4. 环境（Context）： 包含解释器之外的全局信息，如变量值等。
#include <iostream>  
#include <map>  
#include <stack>  
#include <string>  

// 抽象表达式  
class Expression {
public:
    virtual int Interpret(const std::map<char, int>& vars) = 0;
    virtual ~Expression() {}
};

// 变量表达式  
class VarExpression : public Expression {
private:
    char var;
public:
    VarExpression(char var) : var(var) {}
    int Interpret(const std::map<char, int>& vars) override {
        return vars.at(var);
    }
};

// 抽象运算表达式  
class SymbolExpression : public Expression {
protected:
    Expression* left;
    Expression* right;

public:
    SymbolExpression(Expression* left, Expression* right)
        : left(left), right(right) {}

    ~SymbolExpression() {
        delete left;
        delete right;
    }
};

// 加法表达式  
class AddExpression : public SymbolExpression {
public:
    AddExpression(Expression* left, Expression* right)
        : SymbolExpression(left, right) {}

    int Interpret(const std::map<char, int>& vars) override {
        return left->Interpret(vars) + right->Interpret(vars);
    }
};

// 减法表达式  
class SubExpression : public SymbolExpression {
public:
    SubExpression(Expression* left, Expression* right)
        : SymbolExpression(left, right) {}

    int Interpret(const std::map<char, int>& vars) override {
        return left->Interpret(vars) - right->Interpret(vars);
    }
};

// 表达式解析器  
class Calculator {
private:
    Expression* root;

public:
    Calculator(const std::string& exp) {
        std::stack<Expression*> stack;
        for (char c : exp) {
            if (std::isdigit(c) || (c >= 'a' && c <= 'z')) {
                stack.push(new VarExpression(c));
            }
            else if (c == '+') {
                Expression* right = stack.top();
                stack.pop();
                Expression* left = stack.top();
                stack.pop();
                stack.push(new AddExpression(left, right));
            }
            else if (c == '-') {
                Expression* right = stack.top();
                stack.pop();
                Expression* left = stack.top();
                stack.pop();
                stack.push(new SubExpression(left, right));
            }
        }
        root = stack.top();
        stack.pop();
    }

    ~Calculator() {
        delete root;
    }

    int Run(const std::map<char, int>& vars) {
        return root->Interpret(vars);
    }
};

// 主函数，用于测试计算器  
int main() {
    // 使用逆波兰表示法输入计算式
    Calculator calc("ab+c-");
    // 定义变量值  
    std::map<char, int> vars = { {'a', 1}, {'b', 2}, {'c', 1} };
    // 执行计算  
    int result = calc.Run(vars);
    // 输出结果  
    std::cout << "Result: " << result << std::endl;
    return 0;
}

应用场景

解释器模式适用于以下场景：

  1. 需要将一个语言中的句子表示为一个抽象语法树（AST）时。
  2. 存在大量重复出现的表达式，这些表达式可以用一种简单的语言来表达。
  3. 当一种语言需要解释执行，并且这种语言可以通过构建抽象语法树来轻松扩展时。

例如，编译器设计、表达式计算器、正则表达式解析器、机器人指令解析等场景都适合使用解释器模式。

优缺点

优点：

  • 灵活性： 解释器模式使得语言易于扩展，因为新的表达式类型可以简单地通过添加新的类来实现。
  • 可重用性： 解释器模式可以重用语法和表达式对象，特别是在处理相似类型的表达式时。

缺点：

  • 复杂性： 对于复杂的文法，解释器模式可能会导致大量的类和接口，使得系统难以理解和维护。
  • 性能问题： 递归调用和大量的对象创建可能会导致性能问题，特别是在处理大量数据时。
  • 难以调试： 由于表达式的解析过程可能涉及多个类和方法的调用，因此调试可能变得复杂。

…

The end

阅读全部

相关推荐

  1. 【重走编程路】设计模式概述（十二） -- 访问者模式、中介者模式、解释器模式

    2024-07-19 14:12:03       16 阅读

  2. 设计模式(十二)：中介者模式（行为型模式）

    2024-07-19 14:12:03       44 阅读

  4. 【重走编程路】设计模式概述（七） -- 外观模式、组合模式、享元模式

    2024-07-19 14:12:03       17 阅读

  8. 设计模式——中介者模式

    2024-07-19 14:12:03       50 阅读

  9. 设计模式-中介者模式

    2024-07-19 14:12:03       52 阅读

  10. 设计模式：中介者模式

    2024-07-19 14:12:03       30 阅读

最近更新

  3. docker php8.1+nginx base 镜像 dockerfile 配置

    2024-07-19 14:12:03       67 阅读

  4. Could not load dynamic library ‘cudart64_100.dll‘

    2024-07-19 14:12:03       72 阅读

  9. 在Django里面运行非项目文件

    2024-07-19 14:12:03       58 阅读

  19. Python语言-面向对象

    2024-07-19 14:12:03       69 阅读

  20. 如何分清楚常见的 Git 分支管理策略Git Flow、GitHub Flow 和 GitLab Flow

    2024-07-19 14:12:03       64 阅读

热门阅读

  5. 邦芒贴士：和领导相处必须牢记的五个教训

    2024-07-19 14:12:03       19 阅读

  13. 解决警告Creating a tensor from a list of numpy.ndarrays is extremely slow.

    2024-07-19 14:12:03       20 阅读

  15. Binary Search

    2024-07-19 14:12:03       19 阅读

  16. C 语言实例 - 矩阵转换

    2024-07-19 14:12:03       21 阅读

  18. 升级TrinityCore 服务器硬件

    2024-07-19 14:12:03       20 阅读

  19. 风哥容器云平台架构师专题3.0（Docker+Kubernetes/K8s+KubeSphere）

    2024-07-19 14:12:03       20 阅读

  24. EasyExcel导入导出数据类型转换

    2024-07-19 14:12:03       20 阅读

  25. 第 4 课：Linux环境安装隐语Secretflow和Secretnote

    2024-07-19 14:12:03       19 阅读

  26. 音频播放：miniAudio 在QT框架使用， 数据源pcm

    2024-07-19 14:12:03       18 阅读

  28. Python常用的数据分析和可视化库

    2024-07-19 14:12:03       20 阅读