目录
解释器模式（Interpreter Pattern）
解释器模式是一种行为设计模式，它定义了一种语言的文法表示，并使用解释器来解释这些文法。该模式适用于那些有特定语法规则的场景，比如编译器、正则表达式引擎和计算器。
实际应用
算术表达式解释器
算术表达式解释器 -- 可以解析和计算包含加法和减法的算术表达式。
#include <iostream>
#include <string>
#include <stack>
#include <memory>
#include <unordered_map>
// 抽象表达式
class Expression {
public:
virtual ~Expression() = default;
virtual int interpret(const std::unordered_map<char, int>& context) = 0;
};
// 终结符表达式（变量）
class VariableExpression : public Expression {
private:
char name;
public:
VariableExpression(char name) : name(name) {}
int interpret(const std::unordered_map<char, int>& context) override {
return context.at(name);
}
};
// 非终结符表达式（加法）
class AddExpression : public Expression {
private:
std::shared_ptr<Expression> left, right;
public:
AddExpression(std::shared_ptr<Expression> left, std::shared_ptr<Expression> right)
: left(left), right(right) {}
int interpret(const std::unordered_map<char, int>& context) override {
return left->interpret(context) + right->interpret(context);
}
};
// 非终结符表达式（减法）
class SubtractExpression : public Expression {
private:
std::shared_ptr<Expression> left, right;
public:
SubtractExpression(std::shared_ptr<Expression> left, std::shared_ptr<Expression> right)
: left(left), right(right) {}
int interpret(const std::unordered_map<char, int>& context) override {
return left->interpret(context) - right->interpret(context);
}
};
// 客户端代码：解析并计算表达式
int main() {
std::string expr = "a+b-c";
std::unordered_map<char, int> context = {{'a', 5}, {'b', 3}, {'c', 2}};
std::stack<std::shared_ptr<Expression>> stack;
for (char token : expr) {
if (isalpha(token)) {
stack.push(std::make_shared<VariableExpression>(token));
} else if (token == '+') {
auto right = stack.top(); stack.pop();
auto left = stack.top(); stack.pop();
stack.push(std::make_shared<AddExpression>(left, right));
} else if (token == '-') {
auto right = stack.top(); stack.pop();
auto left = stack.top(); stack.pop();
stack.push(std::make_shared<SubtractExpression>(left, right));
}
}
auto expression = stack.top();
int result = expression->interpret(context);
std::cout << "Result: " << result << std::endl;
return 0;
}
布尔表达式解释器
布尔表达式解释器 -- 可以解析和计算包含与（AND）和或（OR）的布尔表达式。
#include <iostream>
#include <string>
#include <stack>
#include <memory>
#include <unordered_map>
// 抽象表达式
class Expression {
public:
virtual ~Expression() = default;
virtual bool interpret(const std::unordered_map<std::string, bool>& context) = 0;
};
// 终结符表达式（变量）
class VariableExpression : public Expression {
private:
std::string name;
public:
VariableExpression(const std::string& name) : name(name) {}
bool interpret(const std::unordered_map<std::string, bool>& context) override {
return context.at(name);
}
};
// 非终结符表达式（与操作）
class AndExpression : public Expression {
private:
std::shared_ptr<Expression> left, right;
public:
AndExpression(std::shared_ptr<Expression> left, std::shared_ptr<Expression> right)
: left(left), right(right) {}
bool interpret(const std::unordered_map<std::string, bool>& context) override {
return left->interpret(context) && right->interpret(context);
}
};
// 非终结符表达式（或操作）
class OrExpression : public Expression {
private:
std::shared_ptr<Expression> left, right;
public:
OrExpression(std::shared_ptr<Expression> left, std::shared_ptr<Expression> right)
: left(left), right(right) {}
bool interpret(const std::unordered_map<std::string, bool>& context) override {
return left->interpret(context) || right->interpret(context);
}
};
// 客户端代码：解析并计算布尔表达式
int main() {
std::string expr = "a AND b OR c";
std::unordered_map<std::string, bool> context = {{"a", true}, {"b", false}, {"c", true}};
std::stack<std::shared_ptr<Expression>> stack;
std::istringstream iss(expr);
std::string token;
while (iss >> token) {
if (token == "a" || token == "b" || token == "c") {
stack.push(std::make_shared<VariableExpression>(token));
} else if (token == "AND") {
auto right = stack.top(); stack.pop();
auto left = stack.top(); stack.pop();
stack.push(std::make_shared<AndExpression>(left, right));
} else if (token == "OR") {
auto right = stack.top(); stack.pop();
auto left = stack.top(); stack.pop();
stack.push(std::make_shared<OrExpression>(left, right));
}
}
auto expression = stack.top();
bool result = expression->interpret(context);
std::cout << "Result: " << std::boolalpha << result << std::endl;
return 0;
}
总结
解释器模式可以帮助我们定义和解释特定语言的语法规则，并将这些规则应用于不同的上下文。