C语言 利用后缀表达式解析字符串（符合c98标准，很容易移植到计算器上）
最近用98标准的C语言写了个解析字符串，类似于JavaScript中的eval函数，感觉挺实用（移植到了计算器上，可以画F(X,Y)==0这种图像了），特此分享一下，大家可以使用。
有了这个函数，就能像js，python那样轻松解析字符串，移植到计算器上就能实现更好玩的功能了，更方便，特此分享。
感谢这篇文章给的启发，不会转后缀表达式的可以看看这篇，写的很详细
波兰式、逆波兰式与表达式求值 - 刺猬的温驯 - 博客园
源代码在最底下！
1、支持的函数
逻辑表达式：
>,<,==(注意是双等于号),<=,>=,&(and),|(or),~(not)
注意，在本解析字符串程序中，用户输入值0代表逻辑false，非0代表逻辑true（true默认为1，也就是2==2返回的值是1）
数学运算符：
+,-,*,/,%(求模),^(乘方),!(阶乘),#(负号，一般会自动区分负号和减号)
符号：
括号，逗号
函数：
三角函数 sin(x) cos(x) tan(x) asin(x) acos(x) atan(x)
如果不在定义域则返回0
随机数 rand(x,y)(返回[x,y]间的整数，需要srand)
弧度转角度 deg(x) 角度转弧度 rad(x)
条件表达式 if(条件,x,y),其中当条件计算结果非0，则返回表达式x的值，否则返回表达式y的值
对数 log(x,y)返回以x为底y的对数 ln(x)返回以e为底的自然对数
自然数的n次方 exp(x),返回e^x
最大最小值 max(x,y)返回表达式x和表达式y的较大的一个，min相反
取符号 sign(x) 如果x大于等于0，返回1，否则返回-1
四舍五入 round(x) 向下取整 floor(x)
绝对值 abs(x) 返回x的绝对值
开平方 sqrt(x) 返回x开平方的值
开n次方可以用运算符“ ^ ”代替
2、用法
#include<eval.c>
很简单，就一行：
直接调用
double eval(char* str);
其中str为表达式，以’ 0 '结束
3、效果
计算0.5+6+3*5的结果为21.5
中间两行分别是中缀表达式和后缀表达式
计算sin(1.57)+cos(if(1>0,0,1))的结果为2.0（三角函数的精度不太好，凑合吧）
其中if(1>0,0,1)，if函数接受3个参数，第一个参数是条件，显然条件成立，返回第二个参数（表达式）的结果的值，就是0，即计算sin(1.57)+cos(0)
注意到：sin在中缀表达式和后缀表达式被替换为了J
cos被替换为了K。
因为注意到单字符的方便性，就用replaceString()函数替换为单字符大写字符。所以，要注意不要让用户输入大写字母！
图中间两行输出可以在代码中注释掉。
附几张移植到计算器上的解析字符串效果图
（画复杂函数图像的，例如sin(X)<cos(Y)这种函数的图像）
4、思路
这里我用例子解释。
假如用户输入“-sin(12.57)-cos(-6)”
规定：如果减号“-”出现在符号后面（不包括右括号）或者出现在字符串开头，就替换为负号“#”，负号是一元运算符，减号是二元运算符，所以有必要区分。
故原字符串被替换为“#sin(12.57)-cos(#6)”
由于sin，cos是多字符不好处理，则替换为单字符（这里我用A-Z）,故替换为“#J(12.57)-K(#6)”
接下来只需要区分是符号还是数字即可。
读入#是符号
读入J是符号
读入(是符号（以上都是转后缀表达式的标准操作，不再赘述，详细可见开头推荐的博客）
读入1是数字，不确定是不是一个完整的数字，则存在number里，
读入2是数字，将原来的number*10+2。
读入.表明接下来的数字是小数部分了。
读入5，number+=pow(10,-1)*5
读入7，number+=pow(10,-2)*7
当读入符号或者到字符串末尾时，讲存的数字保存下来，并且清空。
以此类推
这样子符号和数字就被区分开了，并且转为后缀表达式了。
接下来就只需要运行后缀表达式的求值和控制好优先级了。
因为我这个算法的特殊性，以下的奇葩写法也能计算出正确结果：
sin7
7sin
(7)sin
如有需要，请读者自行编写语法分析。
5、源代码（符合c98标准）
详细请阅读代码中的注释
#include <stdio.h>
#include <math.h>
#include <string.h>
#include <stdlib.h>
/**
* Developed by sandyz987
* Function 'eval'
* @param Expression string (chars' length <= MAX_SIZE)
* @return Answer : double
* @isError 0:no error 1:wrong number of decimal points 2:can't get top item at an empty stack 3:can't pop item at an empty stack(number of brackets is invalid?)
* 4:can't get priority 5:too many arguments 6:unexpect character 7:wrong number of arguments 8:math error
*/
#define PI 3.141592653
#define MAX_SIZE 1024
#define MAX_SIGN_NUM 26
#define MIN_NUM 1.0e-7
char *functionName[MAX_SIGN_NUM] = {">=", "<=", "!=", "==", ">", "<", "asin", "acos", "atan","sin", "cos", "tan", "rand", "deg", "if", "rad", "log", "ln", "exp", "min", "max", "sign", "round", "floor", "abs", "sqrt"};
char nameTran[MAX_SIGN_NUM] = {'A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z'};
int namePriority[MAX_SIGN_NUM] = {2,2,2,2,2,2,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8};//function's priority
int nameArgNum[MAX_SIGN_NUM] = {2,2,2,2,2,2,1,1,1,1,1,1,2,1,3,1,2,1,1,2,2,1,1,1,1,1};//Number of arguments
char operator[] = {'+','-','*','/','^','!','%','(',')',',','&','|','~','#'};
int priority[] = {3,3,4,4,5,5,5,-4,-5,-1,1,0,5,8};//Operator' priority
int operatorArgNum[] = {2,2,2,2,2,1,2,0,0,1,2,2,1,1};//Number of arguments
//I didn't use the struct to build a stack because pointer can reduce readability.
char operatorS[MAX_SIZE] = {0};//Operator stack
int operatorSTop = -1;
int isError = 0;//0=no error
typedef struct sign{
int isOperator;//If isOperator == 0 use the num, else use the opera
double num;
char opera;
} SIGN;
SIGN signs[MAX_SIZE];int signsSize = 0;//To save the "infix expression" by using "struct SIGN"
SIGN reverseSigns[MAX_SIZE];int reverseSignsSize = 0;//To save the "Postfix Expression"
/*
* Example:
* if user input str = "1+2*3"
* the signs(Stack) store 5 item : [isOperator=0,num=1,opera='0'],[isOperator=1,num=0,opera='+'],[isOperator=0,num=2,opera='0'],[isOperator=1,num=0,opera='*'],[isOperator=0,num=3,opera='0']
* the reverseSigns(Stack) store 5 item : [isOperator=0,num=2,opera='0'],[isOperator=0,num=3,opera='0'],[isOperator=1,num=0,opera='*'],[isOperator=0,num=1,opera='0'],[isOperator=1,num=0,opera='+']
*/
int getPriority(char c){
int i;
for(i = 0; i < sizeof(operator); i++){
if(operator[i] == c){
return priority[i];
}
}
for(i = 0; i < sizeof(nameTran); i++){
if(nameTran[i] == c){
return namePriority[i];
}
}
isError = 4;
return 0;
}
void pushSignOpera(char c){
signs[signsSize].isOperator = 1;
signs[signsSize].opera = c;
signsSize++;
}
void pushSignNum(double n){
signs[signsSize].isOperator = 0;
signs[signsSize].num = n;
signsSize++;
}
void pushReverseOpera(char c){
reverseSigns[reverseSignsSize].isOperator = 1;
reverseSigns[reverseSignsSize].opera = c;
reverseSignsSize++;
}
void pushReverseNum(double n){
reverseSigns[reverseSignsSize].isOperator = 0;
reverseSigns[reverseSignsSize].num = n;
reverseSignsSize++;
}
void deleteReverseItem(int pos){
int i;
for (i = pos + 1; i < reverseSignsSize; i++) {
reverseSigns[i-1] = reverseSigns[i];
}
reverseSignsSize--;
}
void insertReverseNum(int pos, double n){
int i;
for (i = reverseSignsSize - 1; i >= pos; i--) {
reverseSigns[i+1] = reverseSigns[i];
}
reverseSigns[pos].isOperator = 0;
reverseSigns[pos].num = n;
reverseSignsSize++;
}
int isNumber(char c){
return (c>='0'&&c<='9')||(c=='.');
}
int isOperator(char c){
int flag = 0,i;
for(i = 0; i<sizeof(operator); i++){
if (c == operator[i]){
flag = 1;
}
}
for(i = 0; i<sizeof(nameTran); i++){
if (c == nameTran[i]){
flag = 1;
}
}
return flag;
}
void pushOpera(char opera){//Operator stack
operatorS[++operatorSTop] = opera;
}
int isNotEmptyOperaS(){
return operatorSTop != -1;
}
char popOpera(){
return operatorS[operatorSTop--];
}
char getTopOpera(){
if (operatorSTop != -1){
return operatorS[operatorSTop];
} else{
isError = 2;
return '0';
}
}
void replaceString(char s[], int pos, int len, char s1[]){//Replace the s from pos to len with s2
int i;
char s2[1000];
int lenS1 = (int)strlen(s1);
int lenS = (int)strlen(s);
int j;
//copy s to s2 and clear the s
for (i = 0; i < lenS; i++) {
s2[i] = s[i];
}
memset(s,'0',sizeof(*s));
for (i = 0; i < pos; ++i) {
s[i] = s2[i];
}
for (i = pos; i < pos + lenS1; i++) {
s[i] = s1[i - pos];
}
j = pos + lenS1;
for (i = pos + len; i < lenS; i++){
s[j++] = s2[i];
}
s[j] = '0';
}
void tranString(char s[]){//Format string. For example "sin(3.14)+abs(-1)" is format to "J(3.14)+Y(-1)"
int pos = 0;
int i;
while (pos < strlen(s)){
for (i = 0; i < MAX_SIGN_NUM; i++) {
if(pos + (int)strlen(functionName[i]) <= (int)strlen(s)){
char tmp[20];
memset(tmp,'0',sizeof(tmp));
strncpy(tmp,s + pos ,strlen(functionName[i]));
if(strcmp(functionName[i], tmp) == 0){
char tmpChar[2] = {'0', '0'};
tmpChar[0] = nameTran[i];
replaceString(s, pos, (int)strlen(functionName[i]), tmpChar);
}
}
}
pos++;
}
if(s[0] == '-'){//decide whether the '-' is '#'
char tmpChar[2] = {'#', '0'};
replaceString(s, 0, 1, tmpChar);
}
pos = 1;
while (pos < strlen(s)){//decide whether the '-' is '#'
if(isOperator(s[pos - 1]) && s[pos] == '-' && s[pos-1]!=')'){
char tmpChar[2] = {'#', '0'};
replaceString(s, pos, 1, tmpChar);
}
pos++;
}
}
int getOperaArgNum(char op){//Get operator's number of arguments.
int i;
for (i = 0; i < sizeof(nameTran); ++i) {
if(nameTran[i] == op){
return nameArgNum[i];
}
}
for (i = 0; i < sizeof(operator); ++i) {
if(operator[i] == op){
return operatorArgNum[i];
}
}
isError = 6;
return 0;
}
int long fact(int n){//return the number's factor
if (n < 0)
return -1;
if (n > 1)
return fact(n - 1) * n;
else
return n;
}
double calculate(double *n, char op, int num){//Arguments are in *n. op is the operator. num is the number of arguments
switch (op) {
case ',':
return n[num - 1];
case '#':
return -n[num - 1];
case '+':
return n[num - 1] + n[num - 2];
case '-':
return n[num - 1] - n[num - 2];
case '*':
return n[num - 1] * n[num - 2];
case '/':
return n[num - 2] != 0 ? n[num - 1] / n[num - 2] : (isError = 8, 0);
case '%':
return (double)((int)n[num - 1] % (int)n[num - 2]);
case '^':
return pow(n[num - 1] , n[num - 2]);
case '!':
return fact((int)n[num - 1]);
case '&':
return fabs(n[num - 1]) >= MIN_NUM && fabs(n[num - 2]) >= MIN_NUM;
case '|':
return fabs(n[num - 1]) >= MIN_NUM || fabs(n[num - 2]) >= MIN_NUM;
case '~':
return fabs(n[num - 1]) <= MIN_NUM;
case 'A':
return n[num - 1] >= n[num - 2];
case 'B':
return n[num - 1] <= n[num - 2];
case 'C':
return fabs(n[num - 1] - n[num - 2]) >= MIN_NUM;
case 'D':
return fabs(n[num - 1] - n[num - 2]) <= MIN_NUM;
case 'E':
return n[num - 1] > n[num - 2];
case 'F':
return n[num - 1] < n[num - 2];
case 'G':
return n[num - 1] <= 1 && n[num - 1] >= -1 ? asin(n[num - 1]) : (isError = 8, 0);
case 'H':
return n[num - 1] <= 1 && n[num - 1] >= -1 ? acos(n[num - 1]) : (isError = 8, 0);
case 'I':
return atan(n[num - 1]);
case 'J':
return sin(n[num - 1]);
case 'K':
return cos(n[num - 1]);
case 'L':
return tan(n[num - 1]);
case 'M':
return n[num - 1] >= 0 && n[num - 2] >= 0 && n[num - 2] - n[num - 1] >= 1 ? (rand() % ((int)n[num - 2] - (int)n[num - 1]) + 1) + (int)n[num - 1] : (isError = 8, 0);
case 'N':
return n[num - 1] / PI * 180.0;
case 'O':
return fabs(n[num - 1]) >= MIN_NUM ? n[num - 2] : n[num - 3] ;
case 'P':
return n[num - 1] / 180.0 * PI;
case 'Q':
return n[num - 1] != 1 && n[num - 1] > 0 && n [num - 2] > 0 ? log(n[num - 2]) / log(n[num - 1]) : (isError = 8, 0);
case 'R':
return n[num - 1] > 0 ? log(n[num - 1]) : (isError = 8, 0);
case 'S':
return exp(n[num - 1]);
case 'T':
return n[num - 1] <= n[num - 2] ? n[num - 1] : n[num - 2];
case 'U':
return n[num - 1] <= n[num - 2] ? n[num - 2] : n[num - 1];
case 'V':
return n[num - 1] >= 0 ? 1 : -1;
case 'W':
return (double)(int)(n[num - 1] + 0.5);
case 'X':
return (double)(int)(n[num - 1]);
case 'Y':
return n[num - 1] >= 0 ? n[num - 1] : - n[num - 1];
case 'Z':
return n[num - 1] >= 0 ? sqrt(n[num - 1]) : (isError = 8, 0) ;
default://not find the operator
isError = 6;
return 0.0f;
}
}
void calculateOpera(char op, int pos){//Change the reverseSigns(stack) when calculating
int num = getOperaArgNum(op);
int i;
double n[10] = {0};
int size = 0;
double ans;
if (pos >= num){
for (i = 0; i < num; ++i) {
if(reverseSigns[pos - 1 - i].isOperator != 1){
n[size++] = reverseSigns[pos - 1 - i].num;
} else{
isError = 7;
break;
}
deleteReverseItem(pos - i);
}
deleteReverseItem(pos - i);
ans = calculate(n, op, num);
insertReverseNum(pos - num, ans);
}else {
isError = 7;
}
}
double eval(char s[]){
double number = 0;
int numberUsed = 0;
int numberPoint = 0;
int i;
operatorSTop = -1;
signsSize = 0;
reverseSignsSize = 0;
srand(0);//set srand!
isError = 0;
//tranString(s); !!!!You must decide whether use "tranString" function here or before eval() execute. Because tranString() use too much time.
while(*s != '0'){
if (isNumber(*s)){
numberUsed = 1;
if (*s == '.'){
if (numberPoint != 0){
isError = 1;
}
numberPoint = 1;
s++;
continue;
}
if(numberPoint == 0){
number *= 10.0;
number += *s - '0';
}else{
number += pow(10,-(numberPoint++)) * (*s - '0');
}
}
if (isOperator(*s)){
if (numberUsed == 1){
numberUsed = 0;
pushSignNum(number);
number = 0;
numberPoint = 0;
}
pushSignOpera(*s);
}
s++;
}
if(numberUsed != 0){
pushSignNum(number);
}
if(isError){
return 0.0f;
}
//start calculating the sign stack
for(i = 0; i < signsSize; i++){
SIGN sign = signs[i];
if(sign.isOperator != 1){
//is number
pushReverseNum(sign.num);
}else{
//is operator
if(sign.opera == '('){
pushOpera(sign.opera);
}else if(sign.opera == ')'){
while(getTopOpera() != '('){
if(isNotEmptyOperaS()){
pushReverseOpera(popOpera());
} else{
isError = 3;
break;
}
}
if(isNotEmptyOperaS()){
popOpera();
}
}else{
while(isNotEmptyOperaS() && getPriority(getTopOpera()) >= getPriority(sign.opera)){
pushReverseOpera(popOpera());
}
pushOpera(sign.opera);
}
}
}
while (isNotEmptyOperaS()){
char tmp = popOpera();
if(tmp != '(' && tmp != ')'){
pushReverseOpera(tmp);
}
}
//===========================up --This code block is to test print the "infix expression" and the "Postfix Expression"
// for(i = 0; i < signsSize; i++){
// if(!signs[i].isOperator){
// printf("%f,",signs[i].num);
// }else{
// printf("%c,",signs[i].opera);
// }
// }
// printf("n");
// for(i = 0; i < reverseSignsSize; i++){
// if(!reverseSigns[i].isOperator){
// printf("%f,",reverseSigns[i].num);
// }else{
// printf("%c,",reverseSigns[i].opera);
// }
// }
// printf("n");
//============================down --This code block is to test print the "infix expression" and the "Postfix Expression"
//start calculate the expression by reverse (Postfix) expression
while(!isError){
int pos = -1;
for (i = 0; i < reverseSignsSize; i++) {
if(reverseSigns[i].isOperator == 1){
pos = i;
break;
}
}
if(pos == -1){
break;
}else{
calculateOpera(reverseSigns[i].opera, pos);
}
}
if(isError){
return 0.0f;
}
if(reverseSignsSize != 1){
isError = 5;
return 0.0f;
} else{
return reverseSigns[0].num;
}
}
int main(){
char s[100];
scanf("%s",s);
tranString(s);
printf("%f",eval(s));
return 0;
}
原文链接：C语言 科学计算器 仿JS的eval函数 解析字符串 后缀表达式