设计模式的 C++ 实现---解释器模式
前文回顾
单例模式(一)
单例模式(二)
观察者模式
简单工厂模式
工厂方法模式(一)
工厂方法模式(二)
抽象工厂模式(一)
抽象工厂模式(二)
原型模式
外观模式
中介者模式
代理模式
装饰者模式
策略模式
状态模式
命令模式
建造者模式
桥接模式
前言
解释器模式的本质就是把一个依据确定规则组成的一个字符串翻译为计算机可执行的语句。
实现举例
- 场景描述
输入一个四则运算的字符串，比如：a-10+b*(c+5) ，解析并返回计算结果。 - 表达式抽象基类
#include - 变量表达式
#include "expression.h"
class Variable : public Expression
{
public:
Variable(const string &m_name):virname(m_name){
}
virtual double interpret(Context *ctx) override;
string getName() const {
return virname ;}
void display(Context *ctx) override;
private:
string virname;//变量名称
};
#include "variable.h"
#include "context.h"
double Variable::interpret(Context *ctx)
{
return ctx->lookUpValue(this->virname);
}
void Variable::display(Context *ctx)
{
cout << ctx->lookUpValue(this->virname);
}
- 解析字典类
#include "variable.h"
#include
using namespace std;
class Context
{
public:
void registerVariable(string var,double value)
{
m_map.insert(make_pair(var,value));
}
double lookUpValue(string var )
{
auto iter = m_map.find(var);
if( iter != m_map.end() )
{
return iter->second;
}
return 0;
}
bool findVariable(string var)
{
auto iter = m_map.find(var);
if( iter != m_map.end() )
{
return true;
}
return false;
}
private:
map<string ,double> m_map;
};
- 常量表达式
#include "expression.h"
class Constant : public Expression
{
public:
Constant(double value):m_value(value){
}
double interpret(Context *) override
{
return m_value;
}
void display(Context *) override
{
cout << m_value;
}
private:
double m_value;
};
- 二元表达式
①．二元表达式基类
#include "expression.h"
#include "memory"
using namespace std;
class BinaryExpression : public Expression
{
public:
BinaryExpression(shared_ptr<Expression> left,shared_ptr<Expression> right):leftExpression(left),rightExpression(right){
}
protected:
shared_ptr<Expression> leftExpression;
shared_ptr<Expression> rightExpression;
};
②．加法表达式类
#include "binaryexpression.h"
class AddBinaryExpression : public BinaryExpression
{
public:
using BinaryExpression::BinaryExpression;
double interpret(Context *ctx) override
{
return leftExpression->interpret(ctx) + rightExpression->interpret(ctx);
}
void display(Context * ctx) override
{
leftExpression->display(ctx);
cout << "+";
rightExpression->display(ctx);
}
};
③．减法表达式类
#include "binaryexpression.h"
class SubBinaryExpression : public BinaryExpression
{
public:
using BinaryExpression::BinaryExpression;
double interpret(Context *ctx) override
{
return leftExpression->interpret(ctx) - rightExpression->interpret(ctx);
}
void display(Context * ctx) override
{
leftExpression->display(ctx);
cout << "-";
rightExpression->display(ctx);
}
};
④．乘法表达式类
#include "binaryexpression.h"
class MulBinaryExpression : public BinaryExpression
{
public:
using BinaryExpression::BinaryExpression;
double interpret(Context *ctx) override
{
return leftExpression->interpret(ctx) * rightExpression->interpret(ctx);
}
void display(Context * ctx) override
{
leftExpression->display(ctx);
cout << "*";
rightExpression->display(ctx);
}
};
⑤．除法表达式类
#include "binaryexpression.h"
class DivBinaryExpression : public BinaryExpression
{
public:
using BinaryExpression::BinaryExpression;
double interpret(Context *ctx) override
{
return leftExpression->interpret(ctx) / rightExpression->interpret(ctx);
}
void display(Context * ctx) override
{
leftExpression->display(ctx);
cout << "/";
rightExpression->display(ctx);
}
};
- 一元表达式
①．一元表达式基类
#include "expression.h"
#include ②．正运算类
#include "unaryexpression.h"
class PositiveUnaryExpression : public UnaryExpression
{
public:
using UnaryExpression::UnaryExpression;
double interpret(Context *ctx) override
{
return mExpression->interpret(ctx);
}
void display(Context * ctx) override
{
cout << "+";
mExpression->display(ctx);
}
};
③．负运算类
#include "unaryexpression.h"
class NegativeUnaryExpression : public UnaryExpression
{
public:
using UnaryExpression::UnaryExpression;
double interpret(Context *ctx) override
{
return - mExpression->interpret(ctx);
}
void display(Context * ctx) override
{
cout << "-";
mExpression->display(ctx);
}
};
- 解析类
#include "context.h"
#include - 客户端调用
#include "calculator.h"
#include