//ConsoleApplication14.cpp:

　　//

　　#include“stdafx.h“

　　#include

　　#include

　　#include

　　#include

　　#include

　　#include

　　#include

　　usingnamespac

　　#defineMAXSIZE0xffff

　　intip=0;

　　intN=0;

　　intn=0;//stacknumber

　　boolflag=1;

　　inttop=0;//变量存储

　　structnode{

　　node*i

　　node*bro=

　　node*child=

　　i

　　string

　　boolhasval=

　　doubl

　　}S，A，B，C，D，E，F，G，H，I，J，*sheet，*p，*s

　　structvariable{

　　string

　　doubl

　　}var[20];

　　intfind_var(stringa){

　　for(inti=0;i

　　if(var[i].name==a)

　　ret

　　return-1;

　　}

　　template

　　classmy_stack

　　{

　　in

　　type*

　　intmax

　　public:

　　my_stack():top(-1)，maxsize(MAXSIZE)

　　{

　　my_s=newtype[maxsize];

　　if(my_s==NULL)

　　{

　　cerr<“动态存储分配失败!“<

　　exit(1);

　　}

　　}

　　my_stack(intsize):top(-1)，maxsize(size)

　　{

　　my_s=newtype[maxsize];

　　if(my_s==NULL)

　　{

　　cerr<“动态存储分配失败!“<

　　exit(1);

　　}

　　}

　　~my_stack()

　　{

　　delete[]

　　}

　　//是否为空

　　boolEmpty();

　　//压栈

　　node*Push(typetp);

　　//返回栈顶元素

　　typeTop();

　　//返回第n个栈顶元素

　　typeTop(intn);

　　//出栈

　　voidPop();

　　//栈大小

　　intSize();

　　stringShow();

　　stringshow();

　　intNum();

　　};

　　template

　　boolmy_stack::Empty()

　　{

　　if(top==-1){

　　return

　　}

　　else

　　returnf

　　}

　　template

　　typemy_stack::Top()

　　{

　　if(top!=-1)

　　{

　　returnmy_s[top];

　　}

　　else

　　{

　　cout<“栈空“;

　　exit(1);

　　}

　　}

　　template

　　typemy_stack::Top(intn)

　　{

　　if((top-n)>-1)

　　{

　　returnmy_s[top-n];

　　}

　　else

　　{

　　cout<“栈空“;

　　exit(1);

　　}

　　}

　　node*my_stack::Push(nodetp)

　　{

　　node*temp=new

　　*temp=tp;

　　temp->index=

　　n++;

　　if(top+1

　　{

　　my_s[++top]=*

　　}

　　else

　　{

　　cout<“栈满“;

　　exit(1);

　　}

　　return

　　}

　　template

　　intmy_stack::Num(){

　　retur

　　}

　　template

　　voidmy_stack::Pop()

　　{

　　if(top>=0)

　　{

　　top--;

　　}

　　else

　　{

　　cout<“栈空“;

　　exit(1);

　　}

　　}

　　template

　　intmy_stack::Size()

　　{

　　returntop+1;

　　}

　　template

　　stringmy_stack::Show(){

　　str

　　for(inti=0;i<=top;i++)

　　s+=my_s[i].

　　ret

　　}

　　stringmy_stack::show(){

　　str

　　for(inti=0;i<=top;i++)

　　s+=(my_s[i].index->text)+““;

　　ret

　　}

　　voidS_P(node*sheet，node*a，my_stack&stack){

　　cout<“pop(S)，“;

　　nodet10=sheet[10];

　　nodet9=sheet[9];

　　switch(a[ip].id){

　　case10:

　　stack.Push(t9);

　　stack.Push(B);

　　stack.Push(t10);

　　stack.Push(A);

　　cout<“push(AB;)“;

　　b

　　case17:

　　stack.Push(t9);

　　stack.Push(B);

　　stack.Push(t10);

　　stack.Push(A);

　　cout<“push(AB;)“;

　　b

　　case21:

　　b

　　default:

　　cout<“error:NOPATTERNFORS!“;

　　flag=0;

　　b

　　}

　　}

　　voidA_P(node*sheet，node*a，my_stack&stack){

　　cout<“pop(A)，“;

　　nodet9=sheet[9];

　　switch(a[ip].id){

　　case10:

　　b

　　case17:

　　stack.Push(A);

　　stack.Push(t9);

　　stack.Push(C);

　　cout<“push(C;A)“;

　　b

　　default:

　　cout<“error:NOPATTERNFORA!“;

　　flag=0;

　　b

　　}

　　}

　　voidB_P(node*sheet，node*a，my_stack&stack){

　　cout<“pop(B)，“;

　　switch(a[ip].id){

　　case0:

　　stack.Push(E);

　　stack.Push(D);

　　cout<“push(DE)“;

　　b

　　case1:

　　stack.Push(E);

　　stack.Push(D);

　　cout<“push(DE)“;

　　b

　　case2:

　　stack.Push(E);

　　stack.Push(D);

　　cout<“push(DE)“;

　　b

　　case3:

　　stack.Push(E);

　　stack.Push(D);

　　cout<“push(DE)“;

　　b

　　case4:

　　stack.Push(E);

　　stack.Push(D);

　　cout<“push(DE)“;

　　b

　　case5:

　　stack.Push(E);

　　stack.Push(D);

　　cout<“push(DE)“;

　　b

　　case6:

　　stack.Push(E);

　　stack.Push(D);

　　cout<“push(DE)“;

　　b

　　case7:

　　stack.Push(E);

　　stack.Push(D);

　　cout<“push(DE)“;

　　b

　　case12:

　　stack.Push(E);

　　stack.Push(D);

　　cout<“push(DE)“;

　　b

　　case17:

　　stack.Push(E);

　　stack.Push(D);

　　cout<“push(DE)“;

　　b

　　case18:

　　stack.Push(E);

　　stack.Push(D);

　　cout<“push(DE)“;

　　b

　　case19:

　　stack.Push(E);

　　stack.Push(D);

　　cout<“push(DE)“;

　　b

　　case20:

　　stack.Push(E);

　　stack.Push(D);

　　cout<“push(DE)“;

　　b

　　default:

　　cout<“error:NOPATTERNFORB!“;

　　flag=0;

　　b

　　}

　　}

　　voidC_P(node*sheet，node*a，my_stack&stack)

　　{

　　cout<“pop(C)，“;

　　nodet17=sheet[17];

　　nodet15=sheet[15];

　　switch(a[ip].id){

　　case17:

　　stack.Push(B);

　　stack.Push(t15);

　　stack.Push(t17);

　　cout<“push(var=B)“;

　　b

　　default:

　　cout<“error:NOPATTERNFORC!“;

　　flag=0;

　　b

　　}

　　}

　　voidD_P(node*sheet，node*a，my_stack&stack){

　　cout<“pop(D)，“;

　　switch(a[ip].id){

　　case0:

　　stack.Push(G);

　　stack.Push(F);

　　cout<“push(FG)“;

　　b

　　case1:

　　stack.Push(G);

　　stack.Push(F);

　　cout<“push(FG)“;

　　b

　　case2:

　　stack.Push(G);

　　stack.Push(F);

　　cout<“push(FG)“;

　　b

　　case3:

　　stack.Push(G);

　　stack.Push(F);

　　cout<“push(FG)“;

　　b

　　case4:

　　stack.Push(G);

　　stack.Push(F);

　　cout<“push(FG)“;

　　case5:

　　stack.Push(G);

　　stack.Push(F);

　　cout<“push(FG)“;

　　b

　　case6:

　　stack.Push(G);

　　stack.Push(F);

　　cout<“push(FG)“;

　　b

　　case7:

　　stack.Push(G);

　　stack.Push(F);

　　cout<“push(FG)“;

　　b

　　case12:

　　stack.Push(G);

　　stack.Push(F);

　　cout<“push(FG)“;

　　b

　　case17:

　　stack.Push(G);

　　stack.Push(F);

　　cout<“push(FG)“;

　　b

　　case18:

　　stack.Push(G);

　　stack.Push(F);

　　cout<“push(FG)“;

　　b

　　case19:

　　stack.Push(G);

　　stack.Push(F);

　　cout<“push(FG)“;

　　case20:

　　stack.Push(G);

　　stack.Push(F);

　　b

　　cout<“push(FG)“;

　　b

　　b

　　default:

　　flag=0;

　　cout<“error:NOPATTERNFORD!“;

　　b

　　}

　　}

　　voidE_P(node*sheet，node*a，my_stack&stack){

　　cout<“pop(E)，“;

　　nodet11=sheet[11]，t12=sheet[12];

　　switch(a[ip].id){

　　case8:

　　b

　　case9:

　　b

　　case11:

　　stack.Push(E);

　　stack.Push(D);

　　stack.Push(sheet[11]);

　　cout<“push(+DE)“;

　　b

　　case12:

　　stack.Push(E);

　　stack.Push(D);

　　stack.Push(sheet[12]);

　　cout<“push(-DE)“;

　　b

　　default:

　　flag=0;

　　cout<“error:NOPATTERNFORE!“;

　　b

　　}

　　}

　　voidF_P(node*sheet，node*a，my_stack&stack){

　　cout<“pop(F)，“;

　　switch(a[ip].id){

　　case0:

　　stack.Push(sheet[8]);

　　stack.Push(H);

　　stack.Push(sheet[7]);

　　stack.Push(sheet[0]);

　　cout<“push(sin(H))“;

　　b

　　case1:

　　stack.Push(sheet[8]);

　　stack.Push(H);

　　stack.Push(sheet[7]);

　　stack.Push(sheet[1]);

　　cout<“push(cos(H))“;

　　b

　　case2:

　　stack.Push(sheet[8]);

　　stack.Push(H);

　　stack.Push(sheet[7]);

　　stack.Push(sheet[2]);

　　cout<“push(tg(H))“;

　　b

　　case3:

　　stack.Push(sheet[8]);

　　stack.Push(H);

　　stack.Push(sheet[7]);

　　stack.Push(sheet[3]);

　　cout<“push(ctg(H))“;

　　b

　　case4:

　　stack.Push(sheet[8]);

　　stack.Push(H);

　　stack.Push(sheet[7]);

　　stack.Push(sheet[4]);

　　cout<“push(log(H))“;

　　b

　　case5:

　　stack.Push(sheet[8]);

　　stack.Push(H);

　　stack.Push(sheet[7]);

　　stack.Push(sheet[5]);

　　cout<“push(lg(H))“;

　　b

　　case6:

　　stack.Push(sheet[8]);

　　stack.Push(H);

　　stack.Push(sheet[7]);

　　stack.Push(sheet[6]);

　　cout<“push(ln(H))“;

　　b

　　case7:

　　stack.Push(I);

　　stack.Push(H);

　　cout<“push(HI)“;

　　b

　　case12:

　　stack.Push(I);

　　stack.Push(H);

　　cout<“push(HI)“;

　　b

　　case17:

　　stack.Push(I);

　　stack.Push(H);

　　cout<“push(HI)“;

　　b

　　case18:

　　stack.Push(I);

　　stack.Push(H);

　　cout<“push(HI)“;

　　b

　　case19:

　　stack.Push(I);

　　stack.Push(H);

　　cout<“push(HI)“;

　　b

　　case20:

　　stack.Push(I);

　　stack.Push(H);

　　cout<“push(HI)“;

　　b

　　default:

　　cout<“error:NOPATTERNFORF!“;

　　flag=0;

　　b

　　}

　　}

　　voidG_P(node*sheet，node*a，my_stack&stack){

　　cout<“pop(G)，“;

　　switch(a[ip].id){

　　case8:

　　b

　　case9:

　　b

　　case11:

　　b

　　case12:

　　b

　　case13:

　　stack.Push(G);

　　stack.Push(F);

　　stack.Push(sheet[13]);

　　cout<“push(*FG)“;

　　b

　　case14:

　　stack.Push(G);

　　stack.Push(F);

　　stack.Push(sheet[14]);

　　cout<“push(/FG)“;

　　b

　　default:

　　cout<“error:NOPATTERNFORG!“;

　　flag=0;

　　b

　　}

　　}

　　voidH_P(node*sheet，node*a，my_stack&stack){

　　cout<“pop(H)，“;

　　switch(a[ip].id){

　　case7:

　　stack.Push(sheet[8]);

　　stack.Push(B);

　　stack.Push(sheet[7]);

　　cout<“push((B))“;

　　b

　　case12:

　　stack.Push(H);

　　stack.Push(sheet[12]);

　　cout<“push(-H)“;

　　b

　　case17:

　　stack.Push(sheet[17]);

　　cout<“push(var)“;

　　b

　　case18:

　　stack.Push(sheet[18]);

　　cout<“push(con)“;

　　b

　　case19:

　　stack.Push(sheet[18]);

　　cout<“push(con)“;

　　b

　　case20:

　　stack.Push(sheet[18]);

　　cout<“push(con)“;

　　b

　　default:

　　cout<“error:NOPATTERNFORH!“;

　　flag=0;

　　b

　　}

　　}

　　voidI_P(node*sheet，node*a，my_stack&stack){

　　cout<“pop(I)，“;

　　switch(a[ip].id){

　　case8:

　　b

　　case9:

　　b

　　case11:

　　b

　　case12:

　　b

　　case13:

　　b

　　case14:

　　b

　　case16:

　　stack.Push(H);

　　stack.Push(sheet[16]);

　　cout<“push(^H)“;

　　b

　　default:

　　cout<“error:NOPATTERNFORI!“;

　　flag=0;

　　b

　　}

　　}

　　voidJ_P(node*sheet，node*a，my_stack&stack){

　　cout<“pop(J)，“;

　　switch(a[ip].id){

　　case8:

　　stack.Push(sheet[8]);

　　cout<“push())“;

　　b

　　case22:

　　stack.Push(sheet[8]);

　　stack.Push(H);

　　stack.Push(sheet[22]);

　　cout<“push(，H))“;

　　default:

　　cout<“error:NOPATTERNFORJ!“;

　　flag=0;

　　b

　　}

　　}

　　stringshow(node*a){

　　str

　　for(inti=ip;i

　　{

　　s+=a[i].

　　}

　　ret

　　}

　　voidana(my_stack&stack，node*a){

　　inti=0;

　　while(flag){

　　p=stack.Top().i//当前指针

　　i++;

　　cout

　　cout

　　cout

　　switch(stack.Top().id){

　　case23:

　　stack.Pop();

　　S_P(sheet，a，stack);

　　b

　　case24:

　　stack.Pop();

　　A_P(sheet，a，stack);

　　b

　　case25:

　　stack.Pop();

　　B_P(sheet，a，stack);

　　b

　　case26:

　　stack.Pop();

　　C_P(sheet，a，stack);

　　b

　　case27:

　　stack.Pop();

　　D_P(sheet，a，stack);

　　b

　　case28:

　　stack.Pop();

　　E_P(sheet，a，stack);

　　b

　　case29:

　　stack.Pop();

　　F_P(sheet，a，stack);

　　b

　　case30:

　　stack.Pop();

　　G_P(sheet，a，stack);

　　b

　　case31:

　　stack.Pop();

　　H_P(sheet，a，stack);

　　b

　　case32:

　　stack.Pop();

　　I_P(sheet，a，stack);

　　b

　　case33:

　　stack.Pop();

　　J_P(sheet，a，stack);

　　b

　　default:

　　if(stack.Top().id==a[ip].id){

　　if(stack.Top().id==17)

　　stack.Top().index->text=a[ip].

　　elseif(stack.Top().id==1

　　{

　　if(a[ip].text==“PI“)

　　{

　　stack.Top().index->text=a[ip].

　　stack.Top().index->val=3.14

　　}

　　elseif(a[ip].text==“E“)

　　{

　　stack.Top().index->text=a[ip].

　　stack.Top().index->val=2.71

　　}

　　else{

　　stack.Top().index->text=a[ip].

　　stack.Top().index->val=stod(a[ip].text);

　　}

　　}

　　ip++;

　　if(stack.Top().id<23&&stack.Top().id>=0)

　　cout<“pop(“

　　else

　　cout<“pop(“

　　stack.Pop();

　　cout<“next(ip)“;

　　if(stack.Empty())cout<“Success“;

　　}

　　else{

　　cout<“error:Fail!“;

　　flag=0;

　　b

　　}

　　}

　　cout<

　　if(stack.Empty())b

　　if(n>0)

　　{p->child=stack.Top(0).i

　　node*temp=p->child->i

　　for(inti=1;i

　　{

　　temp->bro=stack.Top(i).i

　　temp=temp->bro;

　　}

　　}

　　n=0;

　　}

　　}

　　/********************************************************************/

　　/*语义分析*/

　　voidsemanti_ana(my_stack&stack，node*s)//主体部分，对后序遍历得到的后缀树进行栈操作，得出最后结果，放在后序遍历循环体中

　　{

　　stringout=““;

　　boolhasundefine=f

　　if(s->id>=0&&s->id<19)

　　{

　　if(s->id==10)

　　{

　　cout

　　cout<“ReturnTop[0].val“;

　　cout<

　　cout<“结果：“;

　　if(hasundefine)

　　cout

　　else

　　cout

　　}

　　elseif(s->id==0)

　　{

　　if(s->index->hasval)

　　stack.Top().index->val=sin(stack.Top().index->val);

　　else

　　{

　　out+=“sin(“+stack.Top().index->text+“)“;

　　stack.Top().index->text=out;

　　stack.Top().index->hasval=f

　　}

　　cout

　　cout<“Top[0].text=“

　　cout<“，Top[0].val=sin(Top[0].val)“;

　　}

　　elseif(s->id==1)

　　{

　　if(s->index->hasval)

　　stack.Top().index->val=cos(stack.Top().index->val);

　　else

　　{

　　out=“cos(“+stack.Top().index->text+“)“;

　　stack.Top().index->text=out;

　　stack.Top().index->hasval=f

　　}

　　cout

　　cout<“Top[0].text=“

　　cout<“，Top[0].val=cos(Top[0].val)“;

　　}

　　elseif(s->id==2)

　　{

　　if(s->index->hasval)

　　stack.Top().index->val=tan(stack.Top().index->val);

　　else

　　{

　　out=“tan(“+stack.Top().index->text+“)“;

　　stack.Top().index->text=out;

　　stack.Top().index->hasval=f

　　}

　　cout

　　cout<“Top[0].text=“

　　cout<“，Top[0].val=tg(Top[0].val)“;

　　}

　　elseif(s->id==3)

　　{

　　if(s->index->hasval)

　　stack.Top().index->val=tan(1.57-stack.Top().index->val);

　　else

　　{

　　out=“cot(“+stack.Top().index->text+“)“;

　　stack.Top().index->text=out;

　　stack.Top().index->hasval=f

　　}

　　cout

　　cout<“Top[0].text=“

　　cout<“，Top[0].val=ctg(Top[0].val)“;

　　}

　　elseif(s->id==4)

　　{

　　if(s->index->hasval)

　　stack.Top().index->val=log(stack.Top().index->val);

　　else

　　{

　　out=“log(“+stack.Top().index->text+“)“;

　　stack.Top().index->text=out;

　　stack.Top().index->hasval=f

　　}

　　cout

　　cout<“Top[0].text=“

　　cout<“，Top[0].val=log(Top[0].val)“;

　　}

　　elseif(s->id==5)

　　{

　　if(s->index->hasval)

　　stack.Top().index->val=log10(stack.Top().index->val);

　　else

　　{

　　out=“lg(“+stack.Top().index->text+“)“;

　　stack.Top().index->text=out;

　　stack.Top().index->hasval=f

　　}

　　cout

　　cout<“Top[0].text=“

　　cout<“，Top[0].val=lg(Top[0].val)“;

　　}

　　elseif(s->id==6)

　　{

　　if(s->index->hasval)

　　stack.Top().index->val=log(stack.Top().index->val);

　　else

　　{

　　out=“ln(“+stack.Top().index->text+“)“;

　　stack.Top().index->text=out;

　　stack.Top().index->hasval=f

　　}

　　cout

　　cout<“Top[0].text=“

　　cout<“，Top[0].val=ln(Top[0].val)“;

　　}

　　elseif(s->id==11)

　　{

　　if(stack.Top(0).index->hasval&&stack.Top(1).index->hasval)

　　{

　　doubletemp=stack.Top().index->val;

　　stack.Pop();

　　stack.Top().index->val+=

　　stack.Top().index->text=to_string(stack.Top().index->val);

　　}

　　else{

　　out=“(“+stack.Top(1).index->text+“+“+stack.Top(0).index->text+“)“;

　　stack.Top(1).index->text=out;

　　stack.Top(1).index->hasval=f

　　stack.Pop();

　　}

　　cout

　　cout<“Top[1].val+=Top[0].val，Pop()“;

　　}

　　elseif(s->id==12)

　　{

　　if(stack.Top(0).index->hasval&&stack.Top(1).index->hasval)

　　{

　　doubletemp=stack.Top().index->val;

　　stack.Pop();

　　stack.Top().index->val-=

　　stack.Top().index->text=to_string(stack.Top().index->val);

　　}

　　else{

　　out=“(“+stack.Top(1).index->text+“-“+stack.Top(0).index->text+“)“;

　　stack.Top(1).index->text=out;

　　stack.Top(1).index->hasval=f

　　stack.Pop();

　　}

　　cout

　　cout<“Top[1].val-=Top[0].val，Pop()“;

　　}

　　elseif(s->id==13)

　　{

　　if(stack.Top(0).index->hasval&&stack.Top(1).index->hasval)

　　{

　　doubletemp=stack.Top().index->val;

　　stack.Pop();

　　stack.Top().index->val*=

　　stack.Top().index->text=to_string(stack.Top().index->val);

　　}

　　else{

　　out=stack.Top(1).index->text+“*“+stack.Top(0).index->

　　stack.Top(1).index->text=out;

　　stack.Top(1).index->hasval=f

　　stack.Pop();

　　}

　　cout

　　cout<“Top[1].val*=Top[0].val，Pop()“;

　　}

　　elseif(s->id==14)

　　{

　　if(stack.Top(0).index->hasval&&stack.Top(1).index->hasval)

　　{

　　doubletemp=stack.Top().index->val;

　　stack.Pop();

　　stack.Top().index->val/=

　　stack.Top().index->text=to_string(stack.Top().index->val);

　　}

　　else{

　　out=stack.Top(1).index->text+“/“+stack.Top(0).index->

　　stack.Top(1).index->text=out;

　　stack.Top(1).index->hasval=f

　　stack.Pop();

　　}

　　cout

　　cout<“Top[1].val/=Top[0].val，Pop()“;

　　}

　　elseif(s->id==15)

　　{

　　var[top].val=stack.Top().index->val;

　　stack.Push(*s);

　　cout

　　stack.Pop();

　　cout<“Variable[top].val=“val;

　　stack.Pop();

　　top++;

　　}

　　elseif(s->id==16)

　　{

　　if(stack.Top(0).index->hasval&&stack.Top(1).index->hasval){

　　doubletemp=stack.Top().index->val;

　　stack.Pop();

　　stack.Top().index->val=pow(stack.Top().index->val，temp);

　　stack.Top().index->text=to_string(stack.Top().index->val);

　　}

　　else{

　　out=stack.Top(1).index->text+“^“+stack.Top(0).index->

　　stack.Top(1).index->text=out;

　　stack.Top(1).index->hasval=f

　　stack.Pop();

　　}

　　cout

　　cout<“Top[1].val=Top[1].val^Top[0].val，Pop()“;

　　}

　　elseif(s->id==1

　　{

　　stack.Push(*s);

　　cout

　　cout<“Push(“val<“)“;

　　}

　　elseif(s->id==17)

　　{

　　if(var[top-1].name==““)

　　{

　　var[top-1].name=s->index->

　　stringtemp=to_string(var[top-1].val)+“=“+s->index->

　　cout

　　cout<“Variable[Top].text=“index->text<“，Pop(3)“;

　　}

　　else

　　{

　　if(find_var(s->index->text)>=0)

　　{

　　s->index->val=var[find_var(s->index->text)].val;

　　stack.Push(*s);

　　cout

　　cout<“Find(“index->text<“)=“index->val;

　　}

　　else

　　{

　　s->index->hasval=f

　　hasundefine=

　　stack.Push(*s);

　　cout

　　cout<“NoDefine“index->

　　}

　　}

　　}

　　}

　　}

　　intcount_p=0;

　　voidpost(node*s)//对树的后序遍历

　　{

　　if(s!=NULL){

　　post(s->child);

　　post(s->bro);

　　if(s->id<23&&s->id!=7&&s->id!=8&&s->id!=9)cout

　　}

　　}

　　voidpost(my_stack&stack，node*s)//对树的后序遍历

　　{

　　if(s!=NULL){

　　post(stack，s->child);

　　post(stack，s->bro);

　　if(s->id<23&&s->id!=7&&s->id!=8&&s->id!=9)

　　{

　　cout

　　count_p++;

　　semanti_ana(stack，s);

　　cout<

　　}

　　}

　　}

　　intmain()

　　{

　　node*start=&S;

　　sheet=newnode[23];

　　sheet[0].text=“sin“;

　　sheet[1].text=“cos“;

　　sheet[2].text=“tg“;

　　sheet[3].text=“ctg“;

　　sheet[4].text=“log“;

　　sheet[5].text=“lg“;

　　sheet[6].text=“ln“;

　　sheet[7].text=“(“;

　　sheet[8].text=“)“;

　　sheet[9].text=“;“;

　　sheet[10].text=““;

　　sheet[11].text=“+“;

　　sheet[12].text=“-“;

　　sheet[13].text=“*“;

　　sheet[14].text=“/“;

　　sheet[15].text=“=“;

　　sheet[16].text=“^“;

　　sheet[17].text=“var“;

　　sheet[18].text=“con“;

　　sheet[19].text=“PI“;

　　sheet[20].text=“E“;

　　sheet[21].text=“#“;

　　sheet[22].text=“，“;

　　S.id=23;S.text=“S“;

　　A.id=24;A.text=“A“;

　　B.id=25;B.text=“B“;

　　C.id=26;C.text=“C“;

　　D.id=27;D.text=“D“;

　　E.id=28;E.text=“E“;

　　F.id=29;F.text=“F“;

　　G.id=30;G.text=“G“;

　　H.id=31;H.text=“H“;

　　I.id=32;I.text=“I“;

　　J.id=33;J.text=“J“;

　　for(inti=0;i<23;i++)

　　sheet[i].id=i;

　　ifstre

　　in.open(“D:\\词法.txt“);

　　node*a=newnode[MAXSIZE];//当前输入

　　charbuffer[256];

　　while(in.getline(buffer，100))//读取输入内容，既词法分析结果

　　{

　　a[N].text=bu

　　intc1=a[N].text.find(“<“);

　　intc2=a[N].text.find(“，“);

　　intc3=a[N].text.find(“>“);

　　a[N].id=stoi(a[N].text.substr(c2+1，c3-1).data());

　　if(a[N].id==19||a[N].id==20)a[N].id=18;

　　a[N].text=a[N].text.substr(c1+1，c2-1);

　　N++;

　　}

　　a[N].text=“#“;

　　a[N].id=-1;

　　a[N].child=

　　a[N].bro=

　　in.close();

　　N++;

　　my_stacks

　　stack.Push(a[N-1]);

　　stack.Push(S);

　　start=stack.Top().i

　　n-=2;

　　cout<“**************************************************语法分析***************************************************“;

　　cout<“步骤栈内容当前输入操作“;

　　stringc=“--------------------------------------------------------------------------------------------------------------“;

　　cout

　　ana(stack，a);

　　cout<“**************************************************语法分析***************************************************“;

　　cout<“**************************************************语义分析***************************************************“;

　　my_stackl//语义分析栈

　　cout<

　　cout<“后缀式：“;

　　post(start);

　　cout<

　　cout<

　　cout<“步骤栈内容操作“;

　　cout

　　post(lexme，start);

　　cout<“**************************************************语义分析***************************************************“;

　　ret

　　}