算术表达式的合法性判断与求值（上）

在写一个计算器时遇到了一个问题，就是对字符串表示的算术表达式的合法性判断与求值。下面记录一下我的解决方案。

一、问题描述

问题：给定一个字符串，只包含 +,  -,  *,  / ,  数字,  小数点,  ( ,  )。

要求：(1) 判断该算术表达式是否合法； (2) 如果合法，计算该表达式的值。

二、判断表达式的合法性

相信学过《编译原理》的人都知道，利用里面讲的分析方法可以对源代码进行解析。而算术表达式也是源代码的一部分，所以利用编译方法也可以很容易地判断表达式的合法性。

与源代码相比，算术表达式只包含有很少的字符，所以解析起来也简单很多。下面从词法分析和语法分析两个方面来说明。

1）词法分析

下面先定一下表达式涉及到的单词的种别编码：

识别上表所列的单词的状态转换图：

C++实现：

#include <iostream>
#include <vector>
#include <string>
#include <utility>
using namespace std;

int word_analysis(vector<pair<string, int>>& word, const string expr)
{
	for(int i=0; i<expr.length(); ++i)
	{
		// 如果是 + - * / ( )
		if(expr[i] == '(' || expr[i] == ')' || expr[i] == '+' 
			|| expr[i] == '-' || expr[i] == '*' || expr[i] == '/')
		{
			string tmp;
			tmp.push_back(expr[i]);
			switch (expr[i])
			{
				case '+':
					word.push_back(make_pair(tmp, 1));
					break;
				case '-':
					word.push_back(make_pair(tmp, 2));
					break;
				case '*':
					word.push_back(make_pair(tmp, 3));
					break;
				case '/':
					word.push_back(make_pair(tmp, 4));
					break;
				case '(':
					word.push_back(make_pair(tmp, 6));
					break;
				case ')':
					word.push_back(make_pair(tmp, 7));
					break;
			}
		}
		// 如果是数字开头
		else if(expr[i]>='0' && expr[i]<='9')
		{
			string tmp;
			while(expr[i]>='0' && expr[i]<='9')
			{
				tmp.push_back(expr[i]);
				++i;
			}
			if(expr[i] == '.')
			{
				++i;
				if(expr[i]>='0' && expr[i]<='9')
				{
					tmp.push_back('.');
					while(expr[i]>='0' && expr[i]<='9')
					{
						tmp.push_back(expr[i]);
						++i;
					}
				}
				else  
				{
					return -1;  // .后面不是数字，词法错误
				}
			}
			word.push_back(make_pair(tmp, 5));
			--i;
		}
		// 如果以.开头
		else  
		{
			return -1;  // 以.开头，词法错误
		}
	}
	return 0;
}

int main()
{    
    vector<pair<string, int>> word;
    string expr = "(1.5+5.789)*82-10/2";

    int err_num = word_analysis(word, expr);
    if (-1 == err_num)
        cout << "Word Error!" << endl;
    else
        cout << "No Word Error!" << endl;
    return 0;
}

上面的代码将识别出的单词-种别编码对 (单词, 种别编码) 存入一个vector<pair<string, int>> 中。

2）语法分析

算术表达式的文法 G[E] 如下：

E → E+T | E-T | T
T → T*F | T/F | F
F → (E) | d

消去非终结符E和T的左递归后，改写 G[E] 文法如下：

E → TE'
E' → +TE' | -TE' | ε
T → FT'
T' → *FT' | /FT' | ε
F → (E) | d

可以证明上述无递归文法是 LL(1) 文法，可以使用 递归下降分析法。递归下降分析法是确定的自上而下分析法，这种分析法要求文法是 LL(1) 文法。它的基本思想是：对文法中的每一个非终结符编写一个函数（或子程序），每个函数（或子程序）的功能是识别由该非终结符所表示的语法成分。

构造递归下降分析程序时，每个函数名是相应的非终结符，函数体是根据规则右部符号串的结构编写：

• 当遇到终结符 a 时，则编写语句
  if（当前读来的输入符号 == a）读下一个输入符号；

• 当遇到非终结符 A 时，则编写语句调用 A( )；

• 当遇到 A->ε 规则时，则编写语句
  if（当前读来的输入符号 不属于 FOLLOW(A)）error()；

• 当某个非终结符的规则有多个候选式时，按 LL(1) 文法的条件能唯一地选择一个候选式进行推导。

所以我们需要求出 FOLLOW(E') 和 FOLLOW(T')：

FOLLOW( E' )= FOLLOW(E)={ )，#}
FOLLOW( T' ) = FOLLOW( T ) ={+，−，)，#}

好了，下面直接上代码，在词法分析的基础上进行语法分析：

#include <iostream>
#include <vector>
#include <string>
#include <utility>
using namespace std;

vector<pair<string, int>> word;
string expr = "(1.5+5.789)*82-10/2";
int idx = 0;
int sym;
int err = 0; // 错误

void E();
void E1();
void T();
void T1();
void F();
/*--------------------------------词法分析----------------------------*/
int word_analysis(vector<pair<string, int>>& word, const string expr)
{
	for(int i=0; i<expr.length(); ++i)
	{
		// 如果是 + - * / ( )
		if(expr[i] == '(' || expr[i] == ')' || expr[i] == '+' 
			|| expr[i] == '-' || expr[i] == '*' || expr[i] == '/')
		{
			string tmp;
			tmp.push_back(expr[i]);
			switch (expr[i])
			{
			case '+':
				word.push_back(make_pair(tmp, 1));
				break;
			case '-':
				word.push_back(make_pair(tmp, 2));
				break;
			case '*':
				word.push_back(make_pair(tmp, 3));
				break;
			case '/':
				word.push_back(make_pair(tmp, 4));
				break;
			case '(':
				word.push_back(make_pair(tmp, 6));
				break;
			case ')':
				word.push_back(make_pair(tmp, 7));
				break;
			}
		}
		// 如果是数字开头
		else if(expr[i]>='0' && expr[i]<='9')
		{
			string tmp;
			while(expr[i]>='0' && expr[i]<='9')
			{
				tmp.push_back(expr[i]);
				++i;
			}
			if(expr[i] == '.')
			{
				++i;
				if(expr[i]>='0' && expr[i]<='9')
				{
					tmp.push_back('.');
					while(expr[i]>='0' && expr[i]<='9')
					{
						tmp.push_back(expr[i]);
						++i;
					}
				}
				else  
				{
					return -1;  // .后面不是数字，词法错误
				}
			}
			word.push_back(make_pair(tmp, 5));
			--i;
		}
		// 如果以.开头
		else  
		{
			return -1;  // 以.开头，词法错误
		}
	}
	return 0;
}
/*--------------------------------语法分析----------------------------*/
// 读下一单词的种别编码
void Next()
{
	if(idx < word.size())
		sym = word[idx++].second;
	else
		sym = 0;
}

// E → TE' 
void E()
{
	T();
	E1();
}

// E' → +TE' | -TE' | ε 
void E1()
{
	if(sym == 1)
	{
		Next();
		T();
		E1();
	}
	else if(sym == 2)
	{
		Next();
		T();
		E1();
	}
	else if(sym != 7 && sym != 0)
	{
		err = -1;
	}
}

// T → FT' 
void T()
{
	F();
	T1();
}

// T' → *FT' | /FT' | ε 
void T1()
{
	if(sym == 3)
	{
		Next();
		F();
		T1();
	}
	else if(sym == 4)
	{
		Next();
		F();
		T1();
	}
	else if(sym != 1 && sym != 2 && sym != 7 && sym != 0)
	{
		err = -1;
	}
}

// F → (E) | d
void F()
{
	if(sym == 5)
	{
		Next();
	}
	else if(sym == 6)
	{
		Next();
		E();
		if(sym == 7)
		{
			Next();
		}
		else
		{
			err = -1;
		}
	}
	else
	{
		err = -1;
	}
}

int main()
{	
	int err_num = word_analysis(word, expr);
	cout << expr << endl << "Word Analysis:" << endl;
	if (-1 == err_num)
	{
		cout << "Word Error!" << endl;
	}
	else
	{
		// 测试输出
		vector<pair<string, int>>::iterator beg = word.begin();
		for(;beg!=word.end(); ++beg)
			cout << "   (" << beg->first << ", " << beg->second << ")" << endl;

		// 词法正确，进行语法分析
		Next();
		E();
		if (sym == 0 && err == 0)  // 注意要判断两个条件
			cout << "Right Expression." << endl;
		else
			cout << "Wrong Expression." << endl;
	}
	return 0;
}

另外，还有一种更简单的形式，将文法 G(E) 用扩充BNF表示法进行改写：

E → T { +T | -T }
T → F { *F | /F }
F → (E) | d

然后对这种变形文法使用递归下降分析法：

#include <iostream>
#include <vector>
#include <string>
#include <utility>
using namespace std;

vector<pair<string, int>> word;
string expr = "(1.5+5.789)*82-10/2";
int idx = 0;
int sym;
int err = 0; // 错误

void T();
void F();
/*--------------------------------词法分析----------------------------*/
int word_analysis(vector<pair<string, int>>& word, const string expr)
{
	for(int i=0; i<expr.length(); ++i)
	{
		// 如果是 + - * / ( )
		if(expr[i] == '(' || expr[i] == ')' || expr[i] == '+' 
			|| expr[i] == '-' || expr[i] == '*' || expr[i] == '/')
		{
			string tmp;
			tmp.push_back(expr[i]);
			switch (expr[i])
			{
			case '+':
				word.push_back(make_pair(tmp, 1));
				break;
			case '-':
				word.push_back(make_pair(tmp, 2));
				break;
			case '*':
				word.push_back(make_pair(tmp, 3));
				break;
			case '/':
				word.push_back(make_pair(tmp, 4));
				break;
			case '(':
				word.push_back(make_pair(tmp, 6));
				break;
			case ')':
				word.push_back(make_pair(tmp, 7));
				break;
			}
		}
		// 如果是数字开头
		else if(expr[i]>='0' && expr[i]<='9')
		{
			string tmp;
			while(expr[i]>='0' && expr[i]<='9')
			{
				tmp.push_back(expr[i]);
				++i;
			}
			if(expr[i] == '.')
			{
				++i;
				if(expr[i]>='0' && expr[i]<='9')
				{
					tmp.push_back('.');
					while(expr[i]>='0' && expr[i]<='9')
					{
						tmp.push_back(expr[i]);
						++i;
					}
				}
				else  
				{
					return -1;  // .后面不是数字，词法错误
				}
			}
			word.push_back(make_pair(tmp, 5));
			--i;
		}
		// 如果以.开头
		else  
		{
			return -1;  // 以.开头，词法错误
		}
	}
	return 0;
}
/*--------------------------------语法分析----------------------------*/
// 读下一单词的种别编码
void Next()
{
	if(idx < word.size())
		sym = word[idx++].second;
	else
		sym = 0;
}

// E → T { +T | -T } 
void E()
{
	T();
	while(sym == 1 || sym == 2)
	{
		Next();
		T();
	}
}

// T → F { *F | /F } 
void T()
{
	F();
	while(sym == 3 || sym == 4)
	{
		Next();
		F();
	}
}

// F → (E) | d
void F()
{
	if (sym == 5)
	{
		Next();
	}
	else if(sym == 6)
	{
		Next();
		E();
		if (sym == 7)
		{
			Next();
		}
		else
		{
			err = -1;
		}
	}
	else
	{
		err = -1;
	}
}

int main()
{	
	int err_num = word_analysis(word, expr);
	cout << expr << endl << "Word Analysis:" << endl;
	if (-1 == err_num)
	{
		cout << "Word Error!" << endl;
	}
	else
	{
		// 测试输出
		vector<pair<string, int>>::iterator beg = word.begin();
		for(;beg!=word.end(); ++beg)
			cout << "   (" << beg->first << ", " << beg->second << ")" << endl;

		// 词法正确，进行语法分析
		Next();
		E();
		if (sym == 0 && err == 0)  // 注意要判断两个条件
			cout << "Right Expression." << endl;
		else
			cout << "Wrong Expression." << endl;
	}
	return 0;
}

推荐这种文法形式！因为基于这种文法形式写程序，只需要写3个函数（因为只有3个非终结符），而且不需要求 FOLLOW 集合。

测试结果：

                                                                                      算术表达式的合法性判断与求值（下）>>