行为型 - 解释器(Interpreter)

Interpreter 模式的目的就是使用一个解释器为用户提供一个一门定义语言的语法表示的解释器，然后通过这个解释器来解释语言中的句子。

​[[toc]]

概念

Interpreter 模式提供了这样的一个实现语法解释器的框架, Interpreter 模式典型的结构图为：

Interpreter 模式中，提供了 TerminalExpression 和 NonterminalExpression 两种表达式的解释方式，Context 类用于为解释过程提供一些附加的信息（例如全局的信息）

代码实现

模型代码实现

#ifndef _CONTEXT_H_
#define _CONTEXT_H_
class Context
{
public:
	Context();
	~Context();

protected:
private:
};
#endif //~_CONTEXT_H_

#include "Context.h"
Context::Context()
{
}
Context::~Context()
{
}

#ifndef _INTERPRET_H_
#define _INTERPRET_H_

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

class AbstractExpression
{
public:
    virtual ~AbstractExpression();
    virtual void Interpret(const Context &c);

protected:
    AbstractExpression();

private:
};

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

protected:
private:
    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_

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

AbstractExpression::AbstractExpression()
{
}

AbstractExpression::~AbstractExpression()
{
}

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

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

TerminalExpression::~TerminalExpression()
{
}

void TerminalExpression::Interpret(const Context &c)
{
    cout << this->_statement << "TerminalExpression " << 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);
    }
}

#include "Context.h"
#include "Interpreter.h"
#include <iostream>

using namespace std;
int main(int argc, char *argv[])
{
	Context *c = new Context();
	AbstractExpression *te = new TerminalExpression("hello");
	te->Interpret(*c);

	AbstractExpression *nte = new NonterminalExpression(te, 2);
	nte->Interpret(*c);
	return 0;
}

符号运算实现

#include <iostream>
#include <map>
#include <stack>
using namespace std;

class Expression
{
public:
	virtual int interpreter(map<char, int> var) = 0;
	virtual ~Expression() {}
};

//变量表达式
class VarExpression : public Expression
{
	char key;

public:
	VarExpression(const char &key)
	{
		this->key = key;
	}
	int interpreter(map<char, int> var) override
	{
		return var[key];
	}
};
//符号表达式
class SymbolExpression : public Expression
{
	// 运算符左右两个参数
protected:
	Expression *left;
	Expression *right;

public:
	SymbolExpression(Expression *left, Expression *right) : left(left), right(right)
	{
	}
};
//加法运算
class AddExpression : public SymbolExpression
{
public:
	AddExpression(Expression *left, Expression *right) : SymbolExpression(left, right)
	{
	}
	int interpreter(map<char, int> var) override
	{
		return left->interpreter(var) + right->interpreter(var);
	}
};

//减法运算
class SubExpression : public SymbolExpression
{

public:
	SubExpression(Expression *left, Expression *right) : SymbolExpression(left, right)
	{
	}
	int interpreter(map<char, int> var) override
	{
		return left->interpreter(var) - right->interpreter(var);
	}
};

Expression *analyse(const string &expStr)
{
	stack<Expression *> expStack;
	Expression *left = nullptr;
	Expression *right = nullptr;
	for (int i = 0; i < expStr.size(); i++)
	{
		switch (expStr[i])
		{
		case '+':
			// 加法运算
			left = expStack.top();
			right = new VarExpression(expStr[++i]);
			expStack.push(new AddExpression(left, right));
			break;
		case '-':
			// 减法运算
			left = expStack.top();
			right = new VarExpression(expStr[++i]);
			expStack.push(new SubExpression(left, right));
			break;
		default:
			// 变量表达式
			expStack.push(new VarExpression(expStr[i]));
		}
	}
	Expression *expression = expStack.top();
	return expression;
}

int main()
{
	string expStr = "a+b-c+d-e";
	map<char, int> var;
	var.insert(make_pair('a', 1));
	var.insert(make_pair('b', 2));
	var.insert(make_pair('c', 3));
	var.insert(make_pair('d', 4));
	var.insert(make_pair('e', 5));

	Expression *expression = analyse(expStr);
	int result = expression->interpreter(var);
	cout << result << endl;
	return 0;
}