设计模式-解释器模式

^Moon^

已于 2023-03-31 14:15:14 修改

阅读量254

点赞数

CC 4.0 BY-SA版权

分类专栏：设计模式 c++ 文章标签：设计模式

于 2016-11-10 12:04:27 首次发布

本文链接：https://blog.youkuaiyun.com/yelede2009/article/details/53114475

c++ 同时被 2 个专栏收录

59 篇文章

订阅专栏

设计模式

28 篇文章

订阅专栏

本文介绍了解释器模式的基本概念，并通过一个具体的应用实例展示了如何使用该模式来处理类似于语言翻译的问题。文中定义了Context、AbstractExpression、TerminalExpression及NonterminalExpression等关键类，用以实现解释器模式。

适用情境 : 一些指令需要类似语言翻译方式来执行的方式的应用场景.

这里写图片描述

// context.h
#ifndef CONTEXT_H
#define CONTEXT_H

#include <string>

class Context
{
public:
    Context(std::string input);
public:
    std::string m_input;
    std::string m_output;
};

#endif // CONTEXT_H

// context.cpp
#include "context.h"

Context::Context(std::__cxx11::string input)
{
    m_input = input;
    m_output = "";
}

// abstractexpression.h
#ifndef ABSTRACTEXPRESSION_H
#define ABSTRACTEXPRESSION_H

#include "context.h"

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

#endif // ABSTRACTEXPRESSION_H

// terminalexpression.h
#ifndef TERMINALEXPRESSION_H
#define TERMINALEXPRESSION_H

#include "abstractexpression.h"

class TerminalExpression : public AbstractExpression
{
public:
    virtual void Interpret(Context* context);
};

#endif // TERMINALEXPRESSION_H

// terminalexpression.cpp
#include "terminalexpression.h"
#include <iostream>

void TerminalExpression::Interpret(Context *context)
{
    std::cout << " brefore interpret : " << context->m_input << std::endl;
    context->m_output = context->m_input;
    std::cout << " after interpret : " << context->m_output << std::endl;
}

// nonterminalexpression.h
#ifndef NONTERMINALEXPRESSION_H
#define NONTERMINALEXPRESSION_H

#include "abstractexpression.h"

class NonterminalExpression : public AbstractExpression
{
public:
    virtual void Interpret(Context *context);
};

#endif // NONTERMINALEXPRESSION_H

// nonterminalexpression.cpp
#include "nonterminalexpression.h"
#include <iostream>

void NonterminalExpression::Interpret(Context *context)
{
    std::cout << " brefore interpret : " << context->m_input << std::endl;
    context->m_output = "plaintext";
    std::cout << " after interpret : " << context->m_output << std::endl;
}

客户端:

// main.cpp
#include <iostream>
#include <vector>
#include "terminalexpression.h"
#include "nonterminalexpression.h"
#include "context.h"

using namespace std;

int main(int argc, char *argv[])
{
    Context* context = new Context("ciphertext");
    AbstractExpression* expression1 = new TerminalExpression();
    AbstractExpression* expression2 = new NonterminalExpression();

    std::vector<AbstractExpression*> expression_list;
    expression_list.push_back(expression1);
    expression_list.push_back(expression2);

    for(std::vector<AbstractExpression*>::iterator it = expression_list.begin();
        it != expression_list.end();
        it++)
    {
        (*it)->Interpret(context);
    }

    return 0;
}