题目：求4+4/2-9*3的值；
　　①：用一个字符型数组存放了表达式《4+4/2-9*3》；
1 char val[9] = {'4','+','4','/','2','-','9','*','3'};
　　②：定义两个栈，一个存放数字，一个存放符号；
1 //定义存储整型的栈
2 typedef struct node
int data[MAXSIZE];
7 //定义存储字符型的栈
8 typedef struct nodeb
char data[MAXSIZE];
　　③：定义符号的优先级；
1 //获取优先级
2 int youxianquan(char c)
default: printf("error");
return(x);
　　④：确定运算思路&&自左扫描表达式的每一个字符时，若当前字符是运算数值，入整型栈。是运算符时，若这个运算符比栈顶运算符高则入栈，继续向后处理，若这个运算符比栈顶运算符低，则从对象栈出栈两个运算量，从运算符栈出栈一个运算符进行运算，将其运算结果入对象栈。然后继续判断当前字符串是否高于栈顶运算符，如果比栈顶运算符高，则入栈，否则则继续运算。
1 //表达式求值
2 int result(SeqStack *a, SeqStackchar *b)
char val[9] = {'4','+','4','/','2','-','9','*','3'};
//创建表达式
int n = sizeof(val);
for(i = 0; i & i++)
c = val[i];
//获取表达式第i个值
if(i%2 == 0)
//把数字和符号区分开来，
a-&data[a-&top] = c - '0';
//存放数值的
//存放符号的
if(b-&top == -1)
//如果b为空则直接存入符号
b-&data[b-&top] =
x = youxianquan(c);
//求出当前符号的优先级
y = youxianquan(b-&data[b-&top]);
//求b栈顶的符号优先级
//如果当前优先级大于栈顶优先级，则进栈
b-&data[b-&top] =
resultval = abyunsuan(a,b);
//否则a的前两个出栈，b的栈顶出栈，然后进行运算，运算结果再进栈a；
y = youxianquan(b-&data[b-&top]);
//继续判断表达式第i个值的优先级是否大于栈顶符号的优先级
//如果当前优先级大于栈顶优先级，则进栈
b-&data[b-&top] =
//否则重复上面的操作对a的前两个出栈值和b的栈顶出栈并且运算
resultval = abyunsuan(a,b);
//由于每次循环都会对b的栈顶符号的优先级做对比，所以优先级的对比只做一次即可
//把当前的符号进b栈
b-&data[b-&top] =
while(i == n - 1 && a-&top != -1 && b-&top != -1)
//当运算符输入完时
resultval = abyunsuan(a,b);
1 //a出栈两个值 b出栈栈顶运算符，进行运算
2 int abyunsuan(SeqStack *a, SeqStackchar *b)
int fir,sec,
fir = a-&data[a-&top];
sec = a-&data[a-&top];
topchar = b-&data[b-&top];
//b的栈顶出栈
resultval = yunsuan(sec,fir,topchar);
a-&data[a-&top] =
return(resultval);
全部代码如下：
1 #include&stdio.h&
2 #include&stdlib.h&
3 #include&string.h&
5 #define MAXSIZE 1024
7 //定义存储整型的栈
8 typedef struct node
int data[MAXSIZE];
13 //定义存储字符型的栈
14 typedef struct nodeb
char data[MAXSIZE];
20 //创建整型栈
21 SeqStack *creat_sa()
SeqStack *s;
s = (SeqStack *)malloc(sizeof(SeqStack));
s-&top = -1;
return(s);
28 //创建字符串栈
29 SeqStackchar *creat_sb()
SeqStackchar *s;
s = (SeqStackchar *)malloc(sizeof(SeqStackchar));
s-&top = -1;
return(s);
37 //函数声明
38 int youxianquan(char c);
39 int yunsuan(int a, int b, char c);
40 int result(SeqStack *a, SeqStackchar *b);
41 int abyunsuan(SeqStack *a, SeqStackchar *b);
43 //获取优先级
44 int youxianquan(char c)
default: printf("error");
return(x);
62 //开始运算
63 int yunsuan(int a, int b, char c)
result = a *
result = a /
result = a +
result = a -
return(result);
84 //a出栈两个值 b出栈栈顶运算符，进行运算
85 int abyunsuan(SeqStack *a, SeqStackchar *b)
int fir,sec,
fir = a-&data[a-&top];
sec = a-&data[a-&top];
topchar = b-&data[b-&top];
//b的栈顶出栈
resultval = yunsuan(sec,fir,topchar);
a-&data[a-&top] =
return(resultval);
101 //表达式求值
102 int result(SeqStack *a, SeqStackchar *b)
char val[9] = {'4','+','4','/','2','-','9','*','3'};
//创建表达式
int n = sizeof(val);
for(i = 0; i & i++)
c = val[i];
//获取表达式第i个值
if(i%2 == 0)
//把数字和符号区分开来，
a-&data[a-&top] = c - '0';
//存放数值的
//存放符号的
if(b-&top == -1)
//如果b为空则直接存入符号
b-&data[b-&top] =
x = youxianquan(c);
//求出当前符号的优先级
y = youxianquan(b-&data[b-&top]);
//求b栈顶的符号优先级
//如果当前优先级大于栈顶优先级，则进栈
b-&data[b-&top] =
resultval = abyunsuan(a,b);
//否则a的前两个出栈，b的栈顶出栈，然后进行运算，运算结果再进栈a；
b-&data[b-&top] =
while(i == n - 1 && a-&top != -1 && b-&top != -1)
//当运算符输入完时 即当所有的字符全部输入完时才执行此循环
resultval = abyunsuan(a,b);
}　　　　　//也可以把上面的一个while循环注释掉，然后加上下面的循环；　　　　/*　　　　　　while(a=&top != -1 && b-&top != -1)　　　　　　　　resultval = abyunsuan(a,b);　　　　*/
149 void main()
SeqStack *a;
SeqStackchar *b;
a = creat_sa();
//创建链表a
b = creat_sb();
//创建链表b
resultval = result(a,b);
printf("%d",resultval);
阅读(...) 评论()2011全国二级C++考试new_图文_百度文库
两大类热门资源免费畅读
续费一年阅读会员，立省24元！
2011全国二级C++考试new
上传于||暂无简介
阅读已结束，如果下载本文需要使用1下载券
想免费下载本文？
定制HR最喜欢的简历
下载文档到电脑，查找使用更方便
还剩26页未读，继续阅读
定制HR最喜欢的简历
你可能喜欢逻辑表达式“a∧b∨c∧(b∨x＞0)”的后缀式为______(其中，∧、∨分别表示逻辑与、逻辑或，＞表示关系运算“大于”，对逻辑表达式进行短路求值)。_考试资料网
hot热门搜索
单项选择题A．abcbx0＞∨∧∧∨ B．ab∧c∨b∧x0＞∨C．ab∧cb∧x＞0∨∨ D．ab∧cbx0＞∨∧∨
你可能喜欢
单项选择题A．M1的单元测试 B．M2的单元测试C．M1和M2的集成测试 D．确认测试单项选择题
A．软件功能数
B．源代码行数
C．每单位成本数
单项选择题A．容错性 B．成熟性 C．易恢复性 D．易操作性单项选择题
A、处理器的编译器能够产生可重入代码&
B、在程序中可以找开或者关闭中断&
C、处理器支持中断，并且能产生定时中断&
D、有大量的存储空间
单项选择题
A．单元测试&
B．集成测试&
C．确认测试&
D．系统测试一、问题描述
表达式求值是数学中的一个基本问题，也是程序设计中的一个简单问题。我们所涉及的表达式中包含数字和符号，本实验中处理的符号包括&+&、&-&、&*&、&/&、&（&和&）&，要求按照我们所习惯的计算顺序，正确计算出表达式的值，并输出至屏幕上。
本实验采用的数据结构是栈，表达式求值的问题用栈来实现是十分合适的。本实验用两个栈分别保存表达式中的数字和符号，以确定每对符号相遇时的优先级来决定当前应该进行什么操作。符号栈的操作分为三种：一是直接入栈；一是直接出栈；一是将当前栈顶符号出栈并计算，然后根据新的栈顶符号与当前符号的优先级关系重复操作类型的判断。
根据栈的特点以及实验操作的要求，本实验采用的是顺序栈实现。相比链栈来说，顺序栈的访问更方便，但其本质是没有差别的。
二、数据结构&&栈
栈的本质是一个仅在队尾进行操作的线性表。相比于一般的线性表来说，栈的操作是受限制的。一般的栈仅有四个基本操作：初始化（InitStack()）、取栈顶元素（GetTop()）、入栈（Push()）和出栈（Pop()），本实验多定义了一个操作函数ChangeTop()，用于更改栈顶元素的值，当然这个操作也等价于先出栈后入栈一个新的值。
栈的顺序表示类似于线性表的顺序表示，用一段地址连续的区域存储一个顺序栈，用物理存储位置的连表示栈的逻辑关系。与顺序表示的线性表类似，这也要求元素之间维持严格的物理位置关系，但正如上文所说，栈的操作都是限制在栈顶元素处，所以修改操作的有限突出了访问的便捷，因此栈的实现通常使用顺序表示而不是链式表示。
具体实现时，先申请一段连续的空间，当空间不够时，需要新申请一段更大的空间，把之前的所有数据移到新的位置。这样的操作确实十分耗时且无法避免，所以需要在实现之前更好地估计程序所需要的空间大小，减少此类操作的次数，同时最大化地利用空间。
三、算法的设计和实现
1、建立两个栈：一个是数字栈，一个是算符栈，首先向算符栈内添加一个符号&#&。对于具体的符号栈的实现，可以通过编号的形式使用数字编号，也可以直接保存char类型的字符。
2、读取一个字符，自动滤掉空格、换行符等无关字符，当出现非法字符时结束程序并输出&表达式包含未被识别的符号。&
3、如果当前字符c是数字字符，即c满足条件&c&=&0&&&c&=&9&&，则继续读取，并由一个新的变量Num保存这个数字的真实值，具体实现是Num的初值为0，然后每次执行语句Num=Num*10+c-&0&，直到读取到非数字字符为止；如果当前字符c不是数字字符，调用函数OptrType(char c)得到该符号的编号。
4、当读到一个算符，考虑其入栈时，有三种情况：
（1）算符栈的栈顶元素优先级低于当前算符时，当前算符入栈；
（2）当两者优先级相同时，当前算符不入栈，算符栈的栈顶元素弹出；
（3）算符栈的栈顶元素优先级高于当前算符时，算符栈的栈顶元素弹出，数字栈弹出两个元素，按照顺序进行弹出的符号所对应的运算执行运算操作，将得到的结果压入数字栈。再将待入栈元素继续进行步骤4的判断。
5、当&#&都弹出之后，计算结束。如果算式没有错误，则数字栈只剩一个元素，该元素就是算式的计算结果，输出即可。
注：步骤4中提到的优先级是相对的，本实验中的实现方式是编号之后使用一个二维数组保存一个序对的关系的。比如Cmp[&+&][&-&]=1，而同样的有Cmp[&-&][&+&]=1。这样的规定方式是为了让四则运算中同级的运算能够先出现的先计算，从而避免了错误。具体关系见下表，其中值为-2的位置表示表达式有错误。
数组Cmp[][]的值
四、预期结果和实验中的问题
1、预期结果是程序可以正确计算出一个表达式的值，并判断出表达式的错误，包含&表达式中包含无法识别的字符&和&表达式输入错误&两种错误。比如输入的表达式为&2*(3+5)&，则能够得到的输出为&原式=16&；如果输入为&2x+3&，则输出为&表达式包含未被识别的符号&；如果输入为&1 1+1&，则输出为&表达式输出有误&。
2、实验中的问题及解决方案：
（1）map或者set解决算符映射问题
对于所出现的算符，我都编了一个数字号码以便访问。这样有一个弊端在于，当符号变多的时候，这样的没有特殊意义的数字编码映射显得十分累赘且不方便，即使每次访问一个专门编码、解码的函数，也显得很笨拙。
所以我想到的解决方法是，利用c++的STL标准库中的map或者set进行映射，这样在编码的时候可以直接以char类型的数据作为下标进行访问，十分方便。map和set这两个容器的原理都是基于红黑树，红黑树简单地说是一种二叉平衡查找树，具体维护操作这里不再赘述。
（2）template解决通用程序设计问题
本实验中涉及到的两个栈，一个是数字栈，一个是算符栈。正如上文所说，我将算符编号了，相当于说算符栈是一个维护int型元素的栈，而且其中的元素需要用作下标访问Cmp[][]数组以得到两个算符的优先级；而由于计算的必要，数字栈需要是一个维护double型元素的栈。一种暴力有效的方式是，建立两个几乎一模一样的栈，一个维护int型的元素，另一个维护double型的元素。当然我不愿意这样暴力，所以我使用了c++中的模板的程序设计，也就是template，简单地说这是c++程序设计语言中采用类型作为参数的程序设计，支持通用程序设计。于是这个问题就完美解决了。
（3）关于链栈
关于链栈的实现，我认为实现很容易。正如上文所说，栈可以看作一个有特殊操作限制的线性表，所以实现几乎与链栈无异。个人觉得栈这种数据结构没有必要使用链式表示，频繁的申请空间的时间且多出的链域空间都是不必要的浪费。
附：c++源代码：
2 项目：顺序栈实现表达式求值
3 作者：张译尹
5 #include &iostream&
6 #include &cstdio&
8 using namespace
10 #define STACK_INIT_SIZE 100 //栈存储空间的初始分配量
11 #define STACKINCREMENT 10 //栈存储空间的分配增量
13 #define MaxLen 120 //表达式长度
15 template &class T& class MyStack
17 private:
T *base; //栈底指针，构造之前和销毁之后为NULL
T * //栈顶指针
int StackS //当前栈分配的空间大小
22 public:
void InitStack() //构造一个空的栈
base = new T(STACK_INIT_SIZE);
top = base;
StackSize = STACK_INIT_SIZE;
void DestroyStack() //销毁栈
delete base;
StackSize = 0;
void ClearStack() //清空栈
top = base;
bool StackEmpty() //判断栈空
return (base == top);
int StackLength() //返回当前栈内元素个数
return (top - base);
bool GetTop(T &Elem) //取栈顶元素，用Elem返回，失败返回true
if(StackEmpty())
return true;
Elem = *(top - 1);
return false;
void Push(T Elem) //将Elem加入栈顶
int Len = StackLength();
if(Len + 1 & StackSize) //当前栈的空间不够
T *NewBase = new T(StackSize + STACKINCREMENT);
for(i = 0; i & L i++)
NewBase[i] = *(base + i);
delete base;
base = NewB
StackSize += STACKINCREMENT;
bool Pop(T &Elem) //出栈栈顶元素，用Elem返回，失败时返回true
if(StackEmpty())
return true;
return false;
bool ChangeTop(T Elem) //将栈顶元素的值改为Elem，失败时返回true
if(StackEmpty())
return true;
*(top - 1) = E
return false;
86 int Cmp[10][10] = {{},
1, -1, -1, -1,
1, -1, -1, -1,
{0,-1, -1, -1, -1, -1,
{0,-1, -1, -1, -1, -1, -2,
94 //保存运算符之间的优先关系
96 void Check()
MyStack&int&
s.InitStack();
scanf("%d", &n);
for(int i = 1; i &= i++)
scanf("%d", &tmp);
s.Push(tmp);
printf("Length = %d\n", s.StackLength());
printf("====================================\n");
while(!s.StackEmpty())
s.GetTop(tmp);
printf("%d\t", tmp);
s.Pop(tmp);
printf("%d\n", tmp);
printf("====================================\n");
120 inline int OptrType(char ch) //返回运算符编号
switch(ch)
case ' ': case '\n': return 0;
case '+': return 1;
case '-': return 2;
case '*': return 3;
case '/': return 4;
case '(': return 5;
case ')': return 6;
case '#': return 7;
case '.': return 8;
return -1;
137 double Cal(double x, double y, int Op) //x Op y
switch(Op)
case 1: return (x + y);
case 2: return (x - y);
case 3: return (x * y);
case 4: return (x / y);
return 0x3f;
149 void EvaluateExpression()
int cnt, t, tmp, pE
double x, //用于计算的数，x符号y
bool OK = false; //表示算式是否完成计算，完成为true
//+:1 -:2 *:3 /:4 (:5 ):6 #:7
MyStack&int& O //运算符栈
MyStack&double& O //运算数栈
Optr.InitStack();
Opnd.InitStack();
Optr.Push(7); //在起初压入'#'以便最后的清栈
printf("请输入一个算式，以\'#\'结束。\n");
while(c = getchar())
if((c &= '0' && c &= '9') || c == '.')
Num = 0.0;
while(c &= '0' && c &= '9')
Num = Num * 10 + c - '0';
c = getchar();
if(c == '.')
c = getchar();
while(c &= '0' && c &= '9')
Num = Num * 10 + c - '0';
c = getchar();
while(cnt--)
Num /= 10.0;
Opnd.Push(Num);
t = OptrType(c);
if(!t) //空格符、换行符
if(t == -1) //其他符号
printf("表达式包含未被识别的符号。\n");
Optr.GetTop(tmp);
if(Cmp[tmp][t] == -1)
Optr.Push(t);
if(Cmp[tmp][t] == 0)
if(t == 7) //'#'表示结束
Optr.Pop(pElem);
OK = true;
else //遇到左右括号配对了
Optr.Pop(pElem);
//Cmp[tmp][t] == 1
Optr.Pop(pElem);
Opnd.Pop(y);
Opnd.GetTop(x);
x = Cal(x, y, pElem);
Opnd.ChangeTop(x);
Optr.GetTop(tmp);
tmp = Opnd.StackLength();
if(tmp != 1)
printf("表达式输入有误。\n");
Opnd.GetTop(x);
printf("原式 = %lf\n", x);
242 int main()
//Check();
EvaluateExpression();
阅读(...) 评论()下次自动登录
现在的位置:
& 综合 & 正文
经典算法-算术表达式求值
经典-算术表达式求值
转载请保留此行
　　表达式的计算应用相当广泛，比如电力调度系统中的计算遥测、车站票务系统中的票价类型计算公式等。　　本文讲述中置表达式转换为后置表达式和后置表达式的求值算法，并给出实现的C++，同时给出一个相当简洁的堆栈C++模板类。
中缀表达式到后缀表达式的转换　　要把表达式从中缀表达式的形式转换成用后缀表示法表示的等价表达式，必须了解操作符的优先级和结合性。优先级或者说操作符的强度决定求值顺序；优先级高的操作符比优先级低的操作符先求值。 如果所有操作符优先级一样，那么求值顺序就取决于它们的结合性。操作符的结合性定义了相同优先级操作符组合的顺序（从右至左或从左至右）。 转换过程包括用下面的算法读入中缀表达式的操作数、操作符和括号：1. 初始化一个空堆栈，将结果字符串变量置空。2. 从左到右读入中缀表达式，每次一个字符。3. 如果字符是操作数，将它添加到结果字符串。4. 如果字符是个操作符，弹出（pop）操作符，直至遇见开括号（opening parenthesis）、优先级较低的操作符或者同一优先级的右结合符号。把这个操作符压入（push）堆栈。5. 如果字符是个开括号，把它压入堆栈。6. 如果字符是个闭括号（closing parenthesis），在遇见开括号前，弹出所有操作符，然后把它们添加到结果字符串。7. 如果到达输入字符串的末尾，弹出所有操作符并添加到结果字符串。
后缀表达式求值　　对后缀表达式求值比直接对中缀表达式求值简单。在后缀表达式中，不需要括号，而且操作符的优先级也不再起作用了。您可以用如下算法对后缀表达式求值：1. 初始化一个空堆栈2. 从左到右读入后缀表达式3. 如果字符是一个操作数，把它压入堆栈。4. 如果字符是个操作符，弹出两个操作数，执行恰当操作，然后把结果压入堆栈。如果您不能够弹出两个操作数，后缀表达式的语法就不正确。5. 到后缀表达式末尾，从堆栈中弹出结果。若后缀表达式格式正确，那么堆栈应该为空。
数据结构　　在这两个算法中都要利用堆栈。因此这里首先给出一个堆栈的C++模板类，这个模板相当间接，只包含了表达式计算中必须要的功能。Pop Push Getsize 如下：template &class T,int SIZE& class CArrayStackTemp
CArrayStackTemp (){top= -1;}; //缺省构造函数,构造一个空堆栈
~CArrayStackTemp (){};//析构函数
bool Push(T element); //入栈
bool Pop(T& element);//出栈
int GetSize(){return top+1;};//取元素个数
T Buffer[SIZE];
template &class T, int SIZE& bool CArrayStackTemp&T, SIZE&:: Push (T element)
if (top&SIZE-1) {top--;}//满
Buffer[top]=
template &class T, int SIZE& bool CArrayStackTemp&T, SIZE&:: Pop (T& element)
if (top==-1)//空
element=Buffer[top];
　　本文重在讲述原理和实现，因此以下算法只包含了+-*/()的处理，操作数自动转换为double型浮点数。是y=f(x)函数的计算，因此表达式中支持'X'字符，不分大小写，比如：y=(x-5)+2/(x+1)，下面的算法就是计算y值。
中缀表达式到后缀表达式的转换代码 LPCTSTR lpszS:表达式字串CString &szD:结果return =0:ok int g_Mid2Behind(LPCTSTR lpszS,CString &szD)//中置-&后置 只支持() + - * / 和X变量
CArrayStackTemp &char, 256&//堆栈
CString szs=lpszS,szt="";
szs.TrimLeft(); szs.TrimRight();szs.MakeUpper();//大写
int i,len=szs.GetLength();
char c,cc,buf[256];;
for(i=0;i&i++)
if((c&'9')&&(c!='X')) return 1;//含有非法字符
if((c==' ')||(c=='/t')||(c==0x0d)||(c==0x0a))
len=szt.GetLength();
if(len & 255) return 2;//太长
sprintf(buf,"%s",szt);
buf[len]=0;
char *p=(char *)
szt=""; szD="";
while(*p != 0)
if( ((c&='0')&&(c&='9'))|| (c=='X')|| (c=='.') ){szt+=c;p++;}
if(!szt.IsEmpty())//操作数,添加到结果字符串
len=szt.GetLength();
for(i=0;i&i++) szD+=szt[i];
if((c == '+')||(c=='-'))
{ if(!stk.Pop(cc)) cc=0;
if((cc!=0)&&(cc!='(')) szD +=
}while((cc!=0)&&(cc!='('));
if(cc=='(') stk.Push(cc);
stk.Push(c);
else if((c == '*')||(c=='/'))
{ if(!stk.Pop(cc)) cc=0;
if((cc!=0)&&(cc!='(')&&(cc!='+')&&(cc!='-')) szD +=
}while((cc!=0)&&(cc!='(')&&(cc!='+')&&(cc!='-'));
if((cc=='(')||(cc=='-')||(cc=='+')) stk.Push(cc);
stk.Push(c);
else if(c == '(') stk.Push(c);
else if(c == ')')
{ if(!stk.Pop(cc)) cc=0;
if((cc!=0)&&(cc!='(')) szD +=
}while((cc!=0)&&(cc!='('));
if(cc=='(') stk.Push(cc);
else return 3;//操作符错误
if(!szt.IsEmpty())//操作数,添加到结果字符串
len=szt.GetLength();
for(i=0;i&i++) szD+=szt[i];
while(stk.GetSize())
bret=stk.Pop(cc);
if((bret==true)&&(cc!='(')) szD +=
后缀表达式求值代码LPCTSTR lpszParse:后置表达式double xval:变量X的值double *pResult:计算结果无错时返回TRUEBOOL CalBehindParse(LPCTSTR lpszParse,double xval,double *pResult)
const char *pc=lpszP
double v1,v2;
CArrayStackTemp &double, 256&//堆栈
CString szt="";
while(*pc != NULL)
if(c=='X') stk.Push(xval);
else if( ((c&='0')&&(c&='9')) || (c=='.') ) {szt+=c;pc++;}
if(!szt.IsEmpty()){ stk.Push(atof(szt));szt=""; }
if(!stk.Pop(v2)) return FALSE;
if(!stk.Pop(v1)) return FALSE;
if(c=='+') stk.Push(v1+v2);
else if(c=='-') stk.Push(v1-v2);
else if(c=='*') stk.Push(v1*v2);
else if(c=='/') stk.Push(v1/v2);
else return FALSE;//非法运算符
if(!szt.IsEmpty()){ stk.Push(atof(szt));szt=""; }
if(stk.GetSize()!=1) return FALSE;
return stk.Pop(*pResult);
把 CalBehindParse()稍作修改就可以得到后置表达式正确性检查的函数，如下：BOOL CheckBehindParse(LPCTSTR lpszParse)//检查后置表达式
const char *pc=lpszP
double v1,v2;
CArrayStackTemp &double, 256&
CString szt="";
while(*pc != NULL)
if(c=='X') stk.Push(1);
else if( ((c&='0')&&(c&='9')) || (c=='.') ) {szt+=c;pc++;}
if(!szt.IsEmpty()){stk.Push(atof(szt)); szt=""; }
if(!stk.Pop(v2)) return FALSE;
if(!stk.Pop(v1)) return FALSE;
if((c=='+')||(c=='-')||(c=='*')||(c=='/')) stk.Push(1);
else return FALSE;//非法运算符
if(stk.GetSize()!=1) return FALSE;
return TRUE;
综合以上这些函数，可以得到中置表达式的直接计算和检查函数：BOOL CheckParse(LPCTSTR lpszParse)//检查中置表达式是否正确
if(0!=g_Mid2Behind(lpszParse,szb))
return FALSE;
if(szb.IsEmpty()) return TRUE;
return CheckBehindParse(szb);
BOOL CalParse(LPCTSTR lpszParse,double dblVar,double *pResult)//计算中置表达式
if(0!=g_Mid2Behind(lpszParse,szb))
return FALSE;
if(szb.IsEmpty()){*pResult=0; return TRUE;}
return CalBehindParse(szb,dblVar,pResult);
你可以用下面的测试例子去测试上面的函数：double dblRBOOL bret=CalParse("X / 2 * (X + 2.5)",2,&dblResult);//计算中置表达式
注：本文的代码在windows xp，VC++6 + vcsp5环境下验证通过。
&&&&推荐文章:
【上篇】【下篇】}