解释器模式

前言

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

解释器模式需要解决的是，如果一种特定类型的问题发生的频率足够高，那么可能就值得将该问题的各个实例表述为一个简单语言中的句子。这样就可以构建一个解释器，该解释器通过解释这些句子来解决该问题。

用解释器模式，就如同你开发了一个编程语言或脚本给自己或别人用。

举例

• 正则表达式
• 浏览器（解析HTML、CSS、JS等）

应用场景

代码

Context.h

#ifndef CONTEXT_H
#define CONTEXT_H

class Context {
public:
    Context() = default;
    ~Context() = default;
};

#endif //CONTEXT_H

Interpret.h

#ifndef INTERPRET_H
#define INTERPRET_H
#include "Context.h"
#include <string>
using namespace std;

class AbstractExpression {
public:
    virtual ~AbstractExpression() = default;
    virtual void interpert(const Context& c);
protected:
    AbstractExpression() = default;
};

class TerminalExpression: public AbstractExpression {
public:
    explicit TerminalExpression(const string& statement);
    ~TerminalExpression() = default;
    void interpert(const Context& c) override;
private:
    string _statement;
};

class NonterminalExpression: public AbstractExpression {
public:
    explicit NonterminalExpression(AbstractExpression* expression, int times);
    ~NonterminalExpression() = default;
    void interpert(const Context& c) override;
private:
    AbstractExpression* _expression;
    int _times;
};
#endif //INTERPRET_H

Interpret.cpp

#include "Interpret.h"
#include <iostream>
using namespace std;

void AbstractExpression::interpert(const Context &c) {

}

TerminalExpression::TerminalExpression(const string &statement) {
    this->_statement = statement;
}

void TerminalExpression::interpert(const Context &c) {
    cout<<this->_statement<<"TerminalExpression"<<endl;
}


NonterminalExpression::NonterminalExpression(AbstractExpression *expression, int times) {
    this->_expression = expression;
    this->_times = times;
}

void NonterminalExpression::interpert(const Context &c) {
    for (int i = 0; i < _times; ++i) {
        this->_expression->interpert(c);
    }
}

main.cpp

#include "Context.h"
#include "Interpret.h"

using namespace std;

int main() {
    Context *c = new Context();
    AbstractExpression *te = new TerminalExpression("Hello");
    AbstractExpression *nte = new NonterminalExpression(te, 2);
    nte->interpert(*c);

    return 0;
}