第27章解释器模式
一 概念
- 解释器模式，给定一个语言，定义它的文法的一种表示，并定义一个解释器，这个解释器使用该表示来解释语言中的句子。
- 解释器要解决的问题是，如果一种特定类型的问题发生的频率足够高，那么可能就值得将该问题的各个实例表述为一个简单语言中的句子，这样就可以构建一个解释器，该解释器通过解释这些句子来解决该问题。
二 UML图
- Context 包含解释器之外的一些全局信息，对全局的一些内容进行描述
- AbstractExpression 抽象表达式，声明一个抽象的解释操作，这个接口为抽象语法树中所有的节点所共享。
- TerminalExpression 终结符表达式，实现与文法中的终结符相关联的解释操作。
- NonterminalExpression 非终结符表达式，为文法中的非终结符实现解释操作，对文法中每一条规则R1,R2，。。。Rn都需要一个具体的非终结符表达式类。
三 C++代码实现
#include "pch.h"
#include <iostream>
#include <string>
#include <vector>
#include <sstream>
using namespace std;
template <typename elemType>
elemType stringToNum(const string& str)
{
istringstream iss(str);
elemType num;
iss >> num;
return num;
}
//包含解释器之外的一些全局信息
class PlayContext
{
public:
void SetPlayContext(const string text)
{
this->str_text = text;
}
string GetPlayContext() const
{
return this->str_text;
}
private:
string str_text;
};
//表达式类 AbstractExpression
//抽象表达式，声明一个抽象的解释操作，这个接口为抽象语法树中所有的节点所共享
class Expression
{
public:
virtual void Interpret(PlayContext* context)
{
string buf;
string s2;
if (context->GetPlayContext().size() == 0)
{
return;
}
else
{
vector<string> vec;
stringstream ss(context->GetPlayContext());
while (ss >> buf)
{
vec.push_back(buf);
}
//这里是C++的字符串处理
string playKey = vec[0];
double playValue = stringToNum<double>(vec[1]);
this->Excute(playKey, playValue);
vec.erase(vec.begin(), vec.begin() + 2);
vector<string>::iterator it;
for (it = vec.begin(); it != vec.end(); it++)
{
s2 += *it;
if (it != vec.end() - 1)
s2 += " ";
}
context->SetPlayContext(s2);
}
}
virtual void Excute(string key, double value) = 0;
};
//音符类
//TerminalExpression 终结符表达式，实现与文法中的终结符相关联的解释操作
class Note : public Expression
{
void Excute(string key, double value) override
{
string note = "";
switch (key[0])
{
case 'C':
note = "1";
break;
case 'D':
note = "2";
break;
case 'E':
note = "3";
break;
case 'F':
note = "4";
break;
case 'G':
note = "5";
break;
case 'A':
note = "6";
break;
case 'B':
note = "7";
break;
default:
break;
}
cout << note << " ";
}
};
class Scale : public Expression
{
public:
void Excute(string key, double value) override
{
string scale = "";
switch (static_cast<int>(value))
{
case 1:
scale = "低音";
break;
case 2:
scale = "中音";
break;
case 3:
scale = "高音";
break;
default:
break;
}
cout << scale << " ";
}
};
int main()
{
PlayContext* context = new PlayContext();
cout << "上海滩: " << endl;
context->SetPlayContext("O 2 E 0.5 G 0.5 A 3 E 0.5 G 0.5 D 3 E 0.5 G 0.5 A 0.5 O 3 C 1 O 2 A 0.5 G 1 C 0.5 E 0.5 D 3 ");
while (context->GetPlayContext().size() > 0)
{
Expression* expression = nullptr;
char c = context->GetPlayContext()[0];
switch (c)
{
case 'O':
//当首字段是O时，则表达式实例化为音阶
expression = new Scale();
break;
case 'C':
case 'D':
case 'E':
case 'F':
case 'G':
case 'A':
case 'B':
case 'P':
//当首字母是CDEFGAB，以及休止符P时，则实例化为音符
expression = new Note();
break;
}
expression->Interpret(context);
delete expression;
}
system("pause");
}
补充的另外一个例子
- 一个简单加减法运算器的实例
//一个简单加减法运算器的实例
#include "pch.h"
#include <iostream>
#include <string>
#include <vector>
using namespace std;
//抽象的表达式对象以及Context对象
//用于保存计算的中间结果以及当前执行的操作符
class Context
{
public:
Context()
:m_value(0), m_operator('\0')
{}
void SetOperator(char type)
{
this->m_operator = type;
}
char GetOperator() const
{
return this->m_operator;
}
void SetValue(int number)
{
this->m_value = number;
}
int GetValue() const
{
return this->m_value;
}
private:
int m_value;
char m_operator;
};
//表示所有表达式的抽象接口
class IExpression
{
public:
virtual void Eval(Context* p) = 0;
};
//拆分表达式的元素
class Operator : public IExpression
{
public:
Operator(char op)
{
this->m_op = op;
}
void Eval(Context* pContext) override
{
pContext->SetOperator(this->m_op);
}
private:
char m_op;
};
//拆分操作数
class Operand : public IExpression
{
public:
Operand(int number)
{
this->m_num = number;
}
void Eval(Context* pContext) override
{
switch (pContext->GetOperator())
{
case '\0':
pContext->SetValue(this->m_num);
break;
case '+':
pContext->SetValue(this->m_num + pContext->GetValue());
break;
case '-':
pContext->SetValue(pContext->GetValue() - this->m_num);
break;
default:
break;
}
}
private:
int m_num;
};
class Calculator
{
public:
Calculator()
{}
int Calc(string expression)
{
Context* pContext = new Context;
vector<IExpression*> tree; //语法解析树
for (int ix = 0; ix < expression.size(); ++ix)
{
if (expression[ix] == '+' || expression[ix] == '-')
{
tree.push_back(new Operator(expression[ix]));
cout << "第" << ix << "次压入的符号是" << expression[ix] << endl;
}
else
{
tree.push_back(new Operand(static_cast<int>(expression[ix] - 48)));
cout << "第" << ix << "次压入的数字是" << static_cast<int>(expression[ix] - 48) << endl;
}
}
for (vector<IExpression*>::iterator iter = tree.begin(); iter != tree.end(); ++iter)
{
(*iter)->Eval(pContext);
}
return pContext->GetValue();
}
};
int main()
{
Calculator* pc = new Calculator();
cout << "1+4-2+6+9-5-2-1+1+2= " << pc->Calc("1+4-2+6-9-5-2-1+1+2") << endl;
system("pause");
return 0;
}
运行结果
参考资料：
1 https://blog.csdn.net/xiqingnian/article/details/42222369 《大话设计模式C++实现-第27章-解释器模式》
2 https://www.cnblogs.com/hjj-fighting/p/10514935.html 《c++ string 转double》
