设计模式【23】——解释器模式（Interpreter模式）

---

前言

一些应用提供了内建（Build-In）的脚本或者宏语言来让用户可以定义他们能够在系统中进行的操作。Interpreter模式的目的就是使用一个解释器为用户提供一个一门定义语言的语法表示的解释器，然后通过解释器来解释语言中的句子。 Interpreter模式提供了一个实现语法解释器的框架。
如果一种特定类型的问题发生的频率足够高，那么可能就值得将该问题的各个实例表述为一个简单语言中的句子。这样就可以构建一个解释器，该解释器通过解释这些句子来解决该问题。

---

一、解释器模式（Interpreter模式）

Interpreter 模式中，提供了 TerminalExpression 和 NonterminalExpression 两种表达式的解释方式，Context 类用于为解释过程提供一些附加的信息。UML图如下：

---

二、具体源码

1.Context.h

代码如下（示例）：

#ifndef _CONTEXT_H_ 
#define _CONTEXT_H_ 

#include 

class Context
{
public:
  Context();
  ~Context();
protected:
private:
};
#endif //_CONTEXT_H_

2.Context.cpp

代码如下（示例）：

#include "Context.h" 

Context::Context()
{
}

Context::~Context()
{
}

3.Interpret.h

#pragma once
#ifndef _INTERPRET_H_ 
#define _INTERPRET_H_ 

#include "Context.h" 
#include  

class AbstractExpression
{
public:

  virtual ~AbstractExpression();
  virtual void Interpret(const Context& c);

protected:
  AbstractExpression();
private:
};

class TerminalExpression :public AbstractExpression
{
public:
  TerminalExpression(const std::string& statement);
  ~TerminalExpression();
  void Interpret(const Context& c);

protected:
private:
  std::string _statement;
};

class NonterminalExpression :public AbstractExpression
{
public:
  NonterminalExpression(AbstractExpression* expression, int times);
  ~NonterminalExpression();
  void Interpret(const Context& c);

protected:
private:
  AbstractExpression* _expression;
  int _times;
};

#endif //_INTERPRET_H_

4.Interpret.cpp

#include "Interpret.h" 

AbstractExpression::AbstractExpression()
{
}

AbstractExpression::~AbstractExpression()
{
}

void AbstractExpression::Interpret(const Context& c)
{
}

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

TerminalExpression::~TerminalExpression()
{
}

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

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

NonterminalExpression::~NonterminalExpression()
{
}

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

5.main.cpp

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

int main(int argc, char* argv[])
{
  Context* c = new Context();
  AbstractExpression* te = new TerminalExpression("hello");
  AbstractExpression* nte = new NonterminalExpression(te, 2);

  nte->Interpret(*c);


  AbstractExpression* te1 = new TerminalExpression("world");
  AbstractExpression* nte1 = new NonterminalExpression(te1, 2);
  nte1->Interpret(*c);

  return 0;
}

---

三、运行结果

Interpreter模式运行结果如下:

总结

当有部分语句需要解释执行（经常使用），并且可以将该语句表示为一个抽象语法时，可以使用 Interpreter 模式。因此，该模式的可扩展性比较好，而且易于实现简单文法。但是对于复杂的文法，还是比较难维护，也会引起类膨胀。

---

本文参考《设计模式精解－GoF 23 种设计模式解析附 C++实现源码》，对内容进行整理，方便大家学习。如想学习详细内容，请参考此书。