C++二十三种设计模式之表明器模式

一、组成

抽象表达式类：声明表明接口。
终结符表达式类：实现表明接口，代表语言中的终结符（数字、变量）。
抽象非终结符表达式类：实现非终结符获取左表达式和获取右表达式接口。
具体非终结符表达式类：实现非终结符的表明接口，代表语言中的非终结符。
解析函数：使用表达式类解析表达式字符串。
二、特点

1、解析函数充当表达式类的使用者身份。
2、解析函数使用表达式栈来存储逐步解析的表达式。
3、表明器模式逐步解析得到的是一个个表达式。
三、目的

提供表明器，根据语言的语法规则，将表达式表示为一个抽象的语法树来解析。
四、缺点

1、性能问题，复杂语句包罗大量的循环和递归时会影响系统的性能。
2、类膨胀问题，语言文法规则复杂时，需要大量的表达式类，会导致类急剧膨胀。
五、示例代码

1. #include<iostream>
2. #include <vector>
3. #include <list>
4. #include <string>
5. #include <mutex>
6. #include <map>
7. #include<stack>
9. using namespace std;
11. class Expression;//抽象表达式类
12. class VarExpression;//终结符表达式类
13. class SymbolExpression;//抽象非终结符表达式类
14. class AddExpression;//具体非终结符表达式类
15. class SubExpression;//具体非终结符表达式类
16. Expression* analyse(string strExp);//解析函数
18. class Expression {
19. public:
20.         Expression(int num, char sign) : m_num_dbg(num), m_sign_dbg(sign) {}
21.         virtual int interpret(map <char, int> var) = 0;
22.         virtual ~Expression() {};
23.         int m_num_dbg;
24.         char m_sign_dbg;
25. };
27. class VarExpression : public Expression {
28. public:
29.         VarExpression(const char& key, int num, char sign) : Expression(num, sign), m_key(key) {}
30.         int interpret(map <char, int> var) {
31.                 return var[m_key];
32.         };
33.         ~VarExpression() {
34.                 cout << "delete VarExpression num:" << m_num_dbg << " sign:" << m_sign_dbg << endl;
35.         };
36. private:
37.         char m_key;
38. };
40. class SymbolExpression : public Expression {
41. public:
42.         SymbolExpression(Expression* left, Expression* right, int num, char sign) : Expression(num, sign), m_left(left), m_right(right) {}
43.         Expression* GetLeft() {
44.                 return m_left;
45.         };
46.         Expression* GetRight() {
47.                 return m_right;
48.         };
49.         ~SymbolExpression() {
50.                 delete m_left;
51.                 delete m_right;
52.                 cout << "delete SymbolExpression num:" << m_num_dbg << " sign:" << m_sign_dbg << endl;
53.         }
54. protected:
55.         Expression* m_left;
56.         Expression* m_right;
57. };
59. class AddExpression : public SymbolExpression {
60. public:
61.         AddExpression(Expression* left, Expression* right, int num, char sign) : SymbolExpression(left, right, num, sign) {}
62.         int interpret(map <char, int> var) {
63.                 int value1 = m_left->interpret(var);
64.                 int value2 = m_right->interpret(var);
65.                 int result = value1 + value2;
66.                 return result;
67.         };
68.         ~AddExpression() {};
69. };
71. class SubExpression : public SymbolExpression {
72. public:
73.         SubExpression(Expression* left, Expression* right, int num, char sign) : SymbolExpression(left, right, num, sign) {}
74.         int interpret(map <char, int> var) {
75.                 int value1 = m_left->interpret(var);
76.                 int value2 = m_right->interpret(var);
77.                 int result = value1 - value2;
78.                 return result;
79.         };
80. };
82. Expression* analyse(string strExp) {
83.         stack<Expression*> expStack;
84.         Expression* left;
85.         Expression* right;
86.         int iCount = 0;
87.         for (size_t i = 0; i < strExp.size(); i++) {
88.                 switch (strExp[i]) {
89.                 case '+':
90.                         left = expStack.top();
91.                         ++i;
92.                         right = new VarExpression(strExp[i], iCount++, 'v');
93.                         expStack.push(new AddExpression(left, right, iCount++, '+'));
94.                         break;
95.                 case '-':
96.                         left = expStack.top();
97.                         ++i;
98.                         right = new VarExpression(strExp[i], iCount++, 'v');
99.                         expStack.push(new SubExpression(left, right, iCount++, '-'));
100.                         break;
101.                 default:
102.                         expStack.push(new VarExpression(strExp[i], iCount++, 'v'));
103.                         break;
104.                 }
105.         }
106.         return expStack.top();
107. }
108. int main() {
110.         string expStr = "a+b-c";
111.         map<char, int> var;
112.         var.insert({ 'a',1 });
113.         var.insert({ 'b',3 });
114.         var.insert({ 'c',2 });
115.         unique_ptr<Expression> exp(analyse(expStr));
116.         int result = (exp)->interpret(var);
117.         for (auto iter = var.begin(); iter != var.end(); iter++) {
118.                 cout << iter->first << ":" << iter->second << endl;
119.         }
120.         cout << expStr << "=" << result << endl;
121. }

复制代码

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。