基于词法分析的中缀表达式计算
基于词法分析的中缀表达式计算
前面我们对中缀表达式的词法处理进行了讲解并给出了程序示例《四则运算的词法分析》，之前我们也对中缀表达式的计算进行了一系列的分析，诸如《检测中缀表达式的合法性》。在之前的中缀表达式的计算中，我们是利用了空白符来间隔操作符和操作数，这属于一种硬分割。
本文我们利用上一篇中对中缀表达式进行词法分析，进而通过中缀表达式转换为后缀表达式，进而计算后缀表达式来实现基于词法分析的中缀表达式计算。
程序的处理过程主要是包括3个部分：
1.对中缀表达式进行词法分析
2.中缀表达式转化为后缀表达式
3.后缀表达式的计算
我们的程序也是按照以上三个步骤进行的，具体的程序如下：
// 基于词法分析的中缀表达式计算 #include <iostream> #include <sstream> #include <vector> #include <string> #include <stack> #include <map> #include <cassert> using namespace std; string& replace_all_distinct(string& str, const string& src, const string& des) { for (string::size_type i = 0; i != string::npos; i += des.size()) { i = str.find(src, i); if (i != string::npos) { str.replace(i, src.size(), des); } else { break; } } return str; } string& n_replace(string& str, const vector<string>& src, const vector<string>& des) { assert(src.size() > 0 && src.size() == des.size()); for (vector<string>::size_type i = 0; i != src.size(); ++i) { replace_all_distinct(str, src[i], des[i]); } return str; } void get_infix(vector<string>& inf, const vector<string>& src, const vector<string>& des) { inf.clear(); string line; getline(cin, line); n_replace(line, src, des); istringstream sin(line); string tmp; while (sin >> tmp) { inf.push_back(tmp); } } // 加入词法分析 BEGIN struct TI { string token; int id; }; bool is_blank(char ch) { return ch == ' ' || ch == ' '; } void get_exp(string& exp) { getline(cin, exp); } void init_keys(map<string, int>& keys) { keys.clear(); keys["+"] = 1; keys["-"] = 2; keys["*"] = 3; keys["/"] = 4; keys["("] = 5; keys[")"] = 6; keys["__NUM__"] = 7; } void lex(const string& exp, vector<TI>& to_id, const map<string, int>& keys) { to_id.clear(); char ch; for (string::size_type pos = 0; pos < exp.size(); /* ++pos */) { TI ti; ch = exp[pos]; if (is_blank(ch)) { ++pos; continue; } if (ch >= '0' && ch <= '9' || ch == '.') { ti.token += ch; ++pos; if (pos >= exp.size()) { ti.id = keys.size(); to_id.push_back(ti); return; } ch = exp[pos]; while (ch >= '0' && ch <= '9' || ch == '.') { ti.token += ch; ++pos; if (pos >= exp.size()) { ti.id = keys.size(); to_id.push_back(ti); return; } ch = exp[pos]; } ti.id = keys.size(); to_id.push_back(ti); } else { map<string, int>::const_iterator cit; switch (ch) { case '+': case '-': case '*': case '/': case '(': case ')': ti.token += ch; cit = keys.find(ti.token); if (cit == keys.end()) { cout << "test" << endl; } ti.id = cit->second; to_id.push_back(ti); ++pos; break; default: // ti.token += string("Unknown:") + ch; ti.token += string("未知字符：") + ch; ti.id = -1; to_id.push_back(ti); ++pos; break; } } } } // 基于词法分析读取中缀表达式 void get_infix_lex(vector<string>&inf, const map<string, int>& keys) { inf.clear(); string line; getline(cin, line); vector<TI> to_id; lex(line, to_id, keys); for (vector<TI>::size_type i = 0; i != to_id.size(); ++i) { inf.push_back(to_id[i].token); } } // 加入词法分析 END void show(const vector<string>& hs) { for (vector<string>::size_type i = 0; i != hs.size(); ++i) { cout << hs[i] << ' '; } cout << endl; } void init_op(map<string, int>& ops) { ops.clear(); ops["+"] = 100; ops["-"] = 100; ops["*"] = 200; ops["/"] = 200; ops["("] = 1000; ops[")"] = 0; } bool is_operator(const string& hs, const map<string, int>& ops) { map<string, int>::const_iterator cit = ops.find(hs); if (cit != ops.end()) { return true; } else { return false; } } // 判断操作数是否合法 bool op_legal(const string& str, int& ill_id) { assert(str.size() > 0); string::size_type i = 0; if (str[i] == '+' || str[i] == '-') { ++i; if (i == str.size()) { ill_id = 3001; return false; } } int dot_num = 0; for (; i != str.size(); ++i) { // if (isdigit(static_cast<int>(str[i]))) if (str[i] >= '0' && str[i] <= '9') { ; } else if (str[i] == '.') { ++dot_num; } else { ill_id = 3002; return false; } } if (dot_num > 1) { ill_id = 3003; return false; } return true; } void in2post(const vector<string>& inf, vector<string>& postf, map<string, int>& ops, bool& leg, int& ill_id) { if (inf.size() == 0) { leg = false; ill_id = 6001; return; } postf.clear(); stack<string> op_st; // 记录左括号和右括号之间的数量关系 int brac = 0; int op_op = 0; for (vector<string>::size_type i = 0; i != inf.size(); ++i) { if (!is_operator(inf[i], ops)) { // 判断是否是正确的操作数 int tmp = 0; if (!op_legal(inf[i], tmp)) { leg = false; ill_id = tmp; return; } ++op_op; if (op_op > 1) { leg = false; ill_id = 5001; return; } postf.push_back(inf[i]); } else { if (inf[i] == "(") { ++brac; op_st.push(inf[i]); } else if (inf[i] == ")") { --brac; if (brac < 0) { leg = false; ill_id = 4001; return; } while (!op_st.empty()) { if (op_st.top() == "(") { op_st.pop(); break; } else { postf.push_back(op_st.top()); op_st.pop(); } } } else // 若为其他运算符 { --op_op; if (op_op < 0) { leg = false; ill_id = 5002; return; } if (op_st.empty()) // 若为空栈，则直接入栈 { op_st.push(inf[i]); } else { if (ops[inf[i]] > ops[op_st.top()]) { // 如果当前操作符优先级高于站定操作符优先级 // 则直接入栈 op_st.push(inf[i]); } else { // 否则弹出栈中优先级大于等于当前操作符优先级 // 的操作符，并最后将当前操作符压栈 while (!op_st.empty() && ops[op_st.top()] >= ops[inf[i]] && op_st.top() != "(") { postf.push_back(op_st.top()); op_st.pop(); } op_st.push(inf[i]); } } } } } if (brac > 0) { leg = false; ill_id = 4002; return; } if (op_op != 1) { leg = false; ill_id = 5003; return; } while (!op_st.empty()) { postf.push_back(op_st.top()); op_st.pop(); } leg = true; return; } double cal_post(const vector<string>& postf, const map<string, int>& ops, bool& leg, int& ill_id) { stack<double> or_st; double operand = 0.0, a = 0.0, b = 0.0, c = 0.0; for (vector<string>::size_type i = 0; i != postf.size(); ++i) { if (!is_operator(postf[i], ops)) { operand = static_cast<double>(atof(postf[i].c_str())); or_st.push(operand); } else { switch (postf[i][0]) { case '+': // 检测后缀表达式的合法性：操作数是否足够 if (or_st.size() < 2) { leg = false; ill_id = 1001; return -10000000000000.0; } b = or_st.top(); or_st.pop(); a = or_st.top(); or_st.pop(); c = a + b; or_st.push(c); break; case '-': // 检测后缀表达式的合法性：操作数是否足够 if (or_st.size() < 2) { leg = false; ill_id = 1002; return -10000000000000.0; } b = or_st.top(); or_st.pop(); a = or_st.top(); or_st.pop(); c = a - b; or_st.push(c); break; case '*': // 检测后缀表达式的合法性：操作数是否足够 if (or_st.size() < 2) { leg = false; ill_id = 1003; return -10000000000000.0; } b = or_st.top(); or_st.pop(); a = or_st.top(); or_st.pop(); c = a * b; or_st.push(c); break; case '/': // 检测后缀表达式的合法性：操作数是否足够 if (or_st.size() < 2) { leg = false; ill_id = 1004; return -10000000000000.0; } b = or_st.top(); or_st.pop(); a = or_st.top(); or_st.pop(); c = a / b; or_st.push(c); break; default: break; } } } if (or_st.size() == 1) { leg = true; return or_st.top(); } else // 检测后缀表达式的合法性：操作数是否有多余 { leg = false; ill_id = 2001; return -10000000000000.0; } } void init_src_des(vector<string>& src, vector<string>& des) { src.push_back("+"); src.push_back("-"); src.push_back("*"); src.push_back("/"); src.push_back("("); src.push_back(")"); des.push_back(" + "); des.push_back(" - "); des.push_back(" * "); des.push_back(" / "); des.push_back(" ( "); des.push_back(" ) "); } // 将中缀表达式转换后缀表达式和计算后缀表达式封装合并 double cal_inf(const vector<string>& inf, map<string, int>& ops, bool& leg_trans, bool& leg_cal, int& ill_id) { leg_trans = true; ill_id = 0; vector<string> postf; in2post(inf, postf, ops, leg_trans, ill_id); if (leg_trans) { show(postf); } else { cout << "Trans illegal: " << ill_id << '!' << endl << endl; return -10000000000000.0; } leg_cal = true; ill_id = 0; double ret = cal_post(postf, ops, leg_cal, ill_id); if (leg_cal) { return ret; } else { cout << "Cal illegal: " << ill_id << '!' << endl << endl; return -10000000000000.0; } } int main() { map<string, int> ops; init_op(ops); vector<string> inf; vector<string> src, des; init_src_des(src, des); map<string, int> keys; init_keys(keys); while (1) { // 原来读取后缀表达式的方法(加空格处理) // get_infix(inf, src, des); get_infix_lex(inf, keys); bool leg_trans = true; bool leg_cal = true; int ill_id = 0; double ret = cal_inf(inf, ops, leg_trans, leg_cal, ill_id); if (leg_trans && leg_cal) { cout << ret << endl << endl; } } return 0; }
目前我们关于四则运算表达式的计算到此结束。主要分为3大块：
1.对输入的中缀表达式进行词法分析
2.将中缀表达式转换为后缀表达式
3.计算后缀表达式
四则运算的相关处理已基本介绍完毕。接下来会涉及一些前缀表达式、中缀表达式、后缀表达式之间的一些相互转换。
关于中缀表达式的计算我们是利用了两个栈——操作符栈和操作数栈进行的。对于中缀表达式另外的计算方法有待我们以后进一步探讨。