算符优先文法的一个实现

最新推荐文章于 2020-04-07 11:24:24 发布
最新推荐文章于 2020-04-07 11:24:24 发布
阅读量389 收藏
点赞数
文章标签： string iterator token vector 编译器 algorithm
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/symbol68688/article/details/5625847
版权

#ifndef EXPRESSION_H
#define EXPRESSION_H
#include <string>
#include <iostream>
#include <list>
#include <vector>
#include <QTextStream>//cin/cout 必须用的。
//#include "algorithm"
#include <algorithm>
using namespace std;//vector是属于std命名域的，因此需要通过命名限定
class Expression
{
public :
    bool execCmp(string expression);
    int execCalculator(string expression);
    list<string> strsplit(string expression,string token);//表达式，分隔符
    string strval;
    int intval;
    Expression()
    {
     strval="";
     intval=0;
    };
    ~Expression()
    {

    };
};
list<string>Expression::strsplit(string expression,string seps1)//表达式，分隔符
{
      list<string> listtoken;
      char   str1[expression.length()];
      sprintf(str1,"%s",expression.c_str());
      //char   seps[]       =   " /t/n";
      char   seps[seps1.length()];
      sprintf(seps,"%s",seps1.c_str());
      char   *token;
      string strtoken;
      QTextStream cout(stdout, QIODevice::WriteOnly);
     // printf(   "%s/n/nTokens:/n",   str1   );
              /*   Establish   string   and   get   the   first   token:   */
              token   =   strtok(   str1,   seps   );
              while(   token   !=   NULL   )
              {
                    /*   While   there   are   tokens   in   "string"   */
                    strtoken=token;
                    //cout<<"aaa"<<strtoken.c_str()<<endl;
                    listtoken.push_back(strtoken);
                    //printf(   "   %s/n",   token   );
                    /*   Get   next   token:   */
                    token   =   strtok(   NULL,   seps   );
              }
      listtoken.push_back("#");
      return listtoken;

}
/*
auther:symbol

*/
int Expression::execCalculator(string expression)//使用标准C++ string
{
    //第一步:表达式分解，分类存储,例表达式:"Title1 > '3'",分解Title1,>,'3'。
    QTextStream cout(stdout, QIODevice::WriteOnly);
     cout<<expression.c_str()<<endl;
     vector<string> Stack1;//变量及数字栈 //vector末端看为栈顶
     vector<string> Stack2;//运算符栈 //vector末端看为栈顶
     vector<string> Stack3;//运算符优先级栈 //
    try
    {
        while(expression.find("  ")>0)//替换多余的空格
        {
          int ll_pos=expression.find("  ");
          //printf(   "   %s/n",   expression.c_str()   );
          expression=expression.replace(ll_pos,2," ");
        }
    }catch(...){}
    Stack3.push_back(")");//优先级由高到底//0
    Stack3.push_back("*");//1
    Stack3.push_back("/");//1
    Stack3.push_back("+");//3
    Stack3.push_back("-");//3
    Stack3.push_back("(");//5
    Stack3.push_back("#");//结束符优先级低//6
    list<string> Expressionlist;
    Expressionlist=strsplit(expression," ");
    cout<<"表达式已分解为TOKEN"<<endl;
    for(list <string>::iterator it = Expressionlist.begin (); it != Expressionlist.end (); it ++)//解析后的字符串
    {
       cout<<"Token="<<it->c_str()<<endl;
       if(strcmp(it->c_str(),"(")==0 || strcmp(it->c_str(),")")==0 || strcmp(it->c_str(),"+")==0 ||strcmp(it->c_str(),"-")==0 ||strcmp(it->c_str(),"*")==0||strcmp(it->c_str(),"/")==0||strcmp(it->c_str(),"#")==0)
       {
          //先和运算符栈栈顶进行优先级比较
           //cout<<"RUN HERE 1"<<endl;
           if(Stack2.empty())
           {
                 Stack2.push_back(it->c_str());
                 continue;
           }

           cout<<"Stack2="<<Stack2.at(Stack2.size()-1).c_str()<<endl;//vector  Stack2.end()最后指针指向空
          // vector<string>::iterator f1 = find( Stack3.begin( ), Stack3.end( ), Stack2.at(Stack2.size()-1).c_str() ); //查找Stack2.end()栈顶优先级
         // vector<string>::iterator f2 = find( Stack3.begin( ), Stack3.end( ), it->c_str() ); //查找it当前运算符优先级
          int li_yxj_f1=6;//初始优先级//栈顶运算符
          int li_yxj_f2=6;//初始优先级//当前运算符

          switch(Stack2.at(Stack2.size()-1).c_str()[0])//运算符号都是单字符.switch只判断一次，必须加break;
          {
              case ')':
              li_yxj_f1=0;
              break;
              case '*':
              li_yxj_f1=1;
              break;
              case '/':
              li_yxj_f1=1;
              break;
              case '+':
              li_yxj_f1=3;
              break;
              case '-':
              li_yxj_f1=3;
              break;
              case '(':
              li_yxj_f1=5;
              break;
              case '#':
              li_yxj_f1=6;
              break;
          }
          switch(it->c_str()[0])//运算符号都是单字符
          {
              case ')':
              li_yxj_f2=0;
              break;
              case '*':
              li_yxj_f2=1;
              break;
              case '/':
              li_yxj_f2=1;
              break;
              case '+':
              li_yxj_f2=3;
              break;
              case '-':
              li_yxj_f2=3;
              break;
              case '(':
              li_yxj_f2=5;
              break;
              case '#':
              li_yxj_f2=6;
              break;
          }
          cout<<"Stack2.at(Stack2.size()-1).c_str()[0]="<<Stack2.at(Stack2.size()-1).c_str()[0]<<"       it->c_str()[0]="<<it->c_str()[0]<<endl;
          cout<<"li_yxj_f2="<<li_yxj_f2<<"   li_yxj_f1="<<li_yxj_f1<<endl;
           if(strcmp(it->c_str(),"(")==0)//扫描到左括号时无条件压入符号栈
          {
               Stack2.push_back(it->c_str());//
               cout<<"PUSH Stack2"<<it->c_str()<<endl;
               continue;
          }

          //if(f2<f1)//数字越小优先级越大,f1找不到的话Stack2就是空栈,f1指向迭代器的尾部
          if(li_yxj_f2<li_yxj_f1)//数字越小优先级越大,f1找不到的话Stack2就是空栈,f1指向迭代器的尾部
          {
              if(strcmp(it->c_str(),")")!=0)
              {
                  Stack2.push_back(it->c_str());//当前优先级高，运算符压栈
                  cout<<"PUSH Stack2"<<it->c_str()<<endl;
              }
              else
              {
                  string ls_pop1="";
                  string ls_pop2="";
                  while(strcmp(Stack2.at(Stack2.size()-1).c_str(),"(")!=0)//弹栈直到遇到'('
                  {
                      double result=0;
                      ls_pop1=Stack1.at(Stack1.size()-2);
                      ls_pop2=Stack1.at(Stack1.size()-1);
                      cout<<"ls_pop1="<<ls_pop1.c_str()<<endl;
                      cout<<"ls_pop2="<<ls_pop2.c_str()<<endl;
                      cout<<"Stack2.at(Stack2.size()-1).c_str()[0]="<<Stack2.at(Stack2.size()-2).c_str()[0]<<endl;
                      switch(Stack2.at(Stack2.size()-1).c_str()[0])//括号内做运算
                      {
                          case '*':
                          result=atof(ls_pop1.c_str())*atof(ls_pop2.c_str());
                          break;
                          case '/':
                          result=atof(ls_pop1.c_str())/atof(ls_pop2.c_str());
                          break;
                          case '+':
                          result=atof(ls_pop1.c_str())+atof(ls_pop2.c_str());
                          cout<<"run here temp()="<<result<<endl;
                          break;
                          case '-':
                          result=atof(ls_pop1.c_str())-atof(ls_pop2.c_str());
                          break;
                      }
                      cout<<"temp()="<<result<<endl;
                      Stack2.pop_back();//弹出一个运算符
                      Stack1.pop_back();//弹出一个数字
                      Stack1.pop_back();//再弹出一个数字
                      //Stack2.push_back(it->c_str());//弹完上一个运算符做计算，压入当前运算符。
                      char str[10] = {0};
                      sprintf(str, "%lf", result);
                      string ls_result="";
                      ls_result=str;
                      Stack1.push_back(ls_result);//运算结果压栈
                     int i=0;
                     i++;
                     if(i>10000)//限定循环数，避免由于表达式错误而死循环
                     {
                         break;
                     }
                  }//while 结束

                  cout<<"弹出一个左括号运算符("<<endl;
                  if(Stack2.size()>0)//栈空不必再弹了
                  {
                       Stack2.pop_back();//弹出一个左括号运算符
                  }
              }
          }
          else//栈顶优先级高，运算符弹栈做运算
          {
               string ls_pop1="";
               string ls_pop2="";
              // cout<<"POP Stack2"<<endl;
               cout<<"POP Stack2"<<Stack2.at(Stack2.size()-1).c_str()<<endl;
               if(strcmp(Stack2.at(Stack2.size()-1).c_str(),"*")==0)
               {
                  double result=0;
                  ls_pop1=Stack1.at(Stack1.size()-2);
                  ls_pop2=Stack1.at(Stack1.size()-1);
                  cout<<"temp*="<<endl;
                  result=atof(ls_pop1.c_str())*atof(ls_pop2.c_str());
                  cout<<"temp*="<<result<<endl;
                  Stack2.pop_back();//弹出一个运算符
                  Stack1.pop_back();//弹出一个数字
                  Stack1.pop_back();//再弹出一个数字
                  //Stack2.push_back(it->c_str());//弹完上一个运算符做计算，压入当前运算符。
                  char str[10] = {0};
                  sprintf(str, "%lf", result);
                  string ls_result="";
                  ls_result=str;
                  Stack1.push_back(ls_result);//运算结果压栈
                  it --;//下一次循环重新比较当前运算符(注意当前运算符未变)与新栈顶运算符
                  continue;
               }
               if(strcmp(Stack2.at(Stack2.size()-1).c_str(),"/")==0)
               {
                  double result=0;
                  ls_pop1=Stack1.at(Stack1.size()-2);
                  ls_pop2=Stack1.at(Stack1.size()-1);
                  cout<<"temp/="<<endl;
                  result=atof(ls_pop1.c_str())/atof(ls_pop2.c_str());
                  cout<<"temp/="<<result<<endl;
                  Stack2.pop_back();//弹出一个运算符
                  Stack1.pop_back();//弹出一个数字
                  Stack1.pop_back();//再弹出一个数字
                  //Stack2.push_back(it->c_str());//弹完上一个运算符做计算，压入当前运算符。
                  char str[10] = {0};
                  sprintf(str, "%lf", result);
                  string ls_result="";
                  ls_result=str;
                  Stack1.push_back(ls_result);//运算结果压栈
                  it --;//下一次循环重新比较当前运算符(注意当前运算符未变)与新栈顶运算符
                  continue;
               }
               if(strcmp(Stack2.at(Stack2.size()-1).c_str(),"+")==0)
               {
                  double result=0;
                  ls_pop1=Stack1.at(Stack1.size()-2);
                  ls_pop2=Stack1.at(Stack1.size()-1);
                  cout<<"temp+="<<ls_pop1.c_str()<<"+"<<ls_pop2.c_str()<<endl;
                  result=atof(ls_pop1.c_str())+atof(ls_pop2.c_str());
                  cout<<"temp+="<<result<<endl;
                  Stack2.pop_back();//弹出一个运算符
                  Stack1.pop_back();//弹出一个数字
                  Stack1.pop_back();//再弹出一个数字
                  //Stack2.push_back(it->c_str());//弹完上一个运算符做计算，压入当前运算符。
                  char str[10] = {0};
                  sprintf(str, "%lf", result);
                  string ls_result="";
                  ls_result=str;
                  Stack1.push_back(ls_result);//运算结果压栈
                  it --;//下一次循环重新比较当前运算符(注意当前运算符未变)与新栈顶运算符
                  continue;
               }
               if(strcmp(Stack2.at(Stack2.size()-1).c_str(),"-")==0)
               {
                  double result=0;
                  ls_pop1=Stack1.at(Stack1.size()-2);
                  ls_pop2=Stack1.at(Stack1.size()-1);
                  cout<<"temp-="<<endl;
                  result=atof(ls_pop1.c_str())-atof(ls_pop2.c_str());
                  cout<<"temp-="<<result<<endl;
                  Stack2.pop_back();//弹出一个运算符
                  Stack1.pop_back();//弹出一个数字
                  Stack1.pop_back();//再弹出一个数字
                  //Stack2.push_back(it->c_str());//弹完上一个运算符做计算，压入当前运算符。
                  char str[10] = {0};
                  sprintf(str, "%lf", result);
                  string ls_result="";
                  ls_result=str;
                  Stack1.push_back(ls_result);//运算结果压栈
                  it --;//下一次循环重新比较当前运算符(注意当前运算符未变)与新栈顶运算符
                  continue;
               }
          }

       }
       else
       {
          Stack1.push_back(it->c_str());//变量及数字栈
       }
    }
  string ls_expression_result="";
  for(vector <string>::iterator it = Stack1.begin (); it != Stack1.end (); it ++)
  {
     cout<<it->c_str();
  }
  cout<<endl;
  for(vector <string>::iterator it = Stack2.begin (); it != Stack2.end (); it ++)
  {
     cout<<it->c_str();
  }
  cout<<endl;
  ls_expression_result=Stack1.at(Stack1.size()-1).c_str();
  return atof(ls_expression_result.c_str());
}
/*
auther:symbol
返回比较字符串表达式所运算的结果
校验：必须包含token{>,<,==,<=,>=,(,),||,&&,<>,!=,and,or}中的一种或几种
例： ( 字段1 > 3 ) && ( 字段2 < 6 )
优先级:关系运算符>逻辑运算符
算法分析:
第一种：类似算符优先
第二种：先按&& , ||  and or  把表达式拆分//按逻辑运算符拆分
然后把拆分后的表达式进行运算
最后合并运算
  */
bool Expression::execCmp(string expression)//使用标准C++ string
{
    //第一步:表达式分解，分类存储,例表达式:"Title1 > '3'",分解Title1,>,'3'。
    QTextStream cout(stdout, QIODevice::WriteOnly);

    vector<string> Stack1;//变量及数字栈 //vector末端看为栈顶
    vector<string> Stack2;//运算符栈 //vector末端看为栈顶
    vector<string> Stack3;//运算符优先级栈 //
   try
   {
       while(expression.find("  ")>0)//替换多余的空格
       {
         int ll_pos=expression.find("  ");
         //printf(   "   %s/n",   expression.c_str()   );
         expression=expression.replace(ll_pos,2," ");
       }
   }catch(...){}
   Stack3.push_back(")");//优先级由高到底//0
   Stack3.push_back(">");//1
   Stack3.push_back("<");//1
   Stack3.push_back("==");//1
   Stack3.push_back(">=");//1
   Stack3.push_back("<=");//1
   Stack3.push_back("<>");//1
   Stack3.push_back("!=");//1
   Stack3.push_back("&&");//2
   Stack3.push_back("and");//2
   Stack3.push_back("||");//2
   Stack3.push_back("or");//2
   Stack3.push_back("(");//3
   Stack3.push_back("#");//结束符优先级低//6
   list<string> Expressionlist;
   Expressionlist=strsplit(expression," ");
   //cout<<"表达式已分解为TOKEN"<<endl;

   for(list <string>::iterator it = Expressionlist.begin (); it != Expressionlist.end (); it ++)//解析后的字符串
   {
     // cout<<"Token="<<it->c_str()<<endl;
      if(strcmp(it->c_str(),"(")==0 || strcmp(it->c_str(),")")==0 || strcmp(it->c_str(),">")==0 ||strcmp(it->c_str(),"<")==0
         ||strcmp(it->c_str(),">=")==0||strcmp(it->c_str(),"<=")==0||strcmp(it->c_str(),"!=")==0||strcmp(it->c_str(),"<>")==0
         ||strcmp(it->c_str(),"==")==0||strcmp(it->c_str(),"and")==0||strcmp(it->c_str(),"or")==0||strcmp(it->c_str(),"&&")==0
         ||strcmp(it->c_str(),"||")==0||strcmp(it->c_str(),"#")==0)
      {
         //先和运算符栈栈顶进行优先级比较
          //cout<<"RUN HERE 1"<<endl;
          if(Stack2.empty())
          {
                Stack2.push_back(it->c_str());
                continue;
          }

         // cout<<"Stack2="<<Stack2.at(Stack2.size()-1).c_str()<<endl;//vector  Stack2.end()最后指针指向空
         int li_yxj_f1=6;//初始优先级//栈顶运算符
         int li_yxj_f2=6;//初始优先级//当前运算符
         //栈顶运算符优先级
         if(strcmp(Stack2.at(Stack2.size()-1).c_str(),")")==0)
         {
           li_yxj_f1=0;
         }
         else if(strcmp(Stack2.at(Stack2.size()-1).c_str(),"<")==0 || strcmp(Stack2.at(Stack2.size()-1).c_str(),">")==0 || strcmp(Stack2.at(Stack2.size()-1).c_str(),"<=")==0 ||strcmp(Stack2.at(Stack2.size()-1).c_str(),">=")==0||strcmp(Stack2.at(Stack2.size()-1).c_str(),"<>")==0||strcmp(Stack2.at(Stack2.size()-1).c_str(),"!=")==0||strcmp(Stack2.at(Stack2.size()-1).c_str(),"==")==0)
         {
              li_yxj_f1=1;
              //cout<<"test_li_yxj_f1="<<li_yxj_f1<<endl;
         }
         else if(strcmp(Stack2.at(Stack2.size()-1).c_str(),"&&")==0 || strcmp(Stack2.at(Stack2.size()-1).c_str(),"and")==0 || strcmp(Stack2.at(Stack2.size()-1).c_str(),"||")==0 ||strcmp(Stack2.at(Stack2.size()-1).c_str(),"or")==0)
         {
            li_yxj_f1=2;
         }
         else if(strcmp(Stack2.at(Stack2.size()-1).c_str(),"(")==0)
         {
            li_yxj_f1=3;
         }
         else
         {
             li_yxj_f1=6;
            // cout<<"test_else_li_yxj_f1="<<li_yxj_f1<<endl;
         }
         //当前运算符优先级
        if(strcmp(it->c_str(),")")==0)
        {
          li_yxj_f2=0;
        }
        else if(strcmp(it->c_str(),"<")==0 || strcmp(it->c_str(),">")==0 || strcmp(it->c_str(),"<=")==0 ||strcmp(it->c_str(),">=")==0||strcmp(it->c_str(),"<>")==0||strcmp(it->c_str(),"!=")==0||strcmp(it->c_str(),"==")==0)
        {
           li_yxj_f2=1;
        }
        else if(strcmp(it->c_str(),"&&")==0 || strcmp(it->c_str(),"and")==0 || strcmp(it->c_str(),"||")==0 ||strcmp(it->c_str(),"or")==0)
        {
         li_yxj_f2=2;
        }
        else if(strcmp(it->c_str(),"(")==0)
        {
         li_yxj_f2=3;
        }
        else
        {
          li_yxj_f2=6;
        }
        // cout<<"Stack2.at(Stack2.size()-1).c_str()="<<Stack2.at(Stack2.size()-1).c_str()<<"       it->c_str()="<<it->c_str()<<endl;
        // cout<<"li_yxj_f2="<<li_yxj_f2<<"   li_yxj_f1="<<li_yxj_f1<<endl;
          if(strcmp(it->c_str(),"(")==0)//扫描到左括号时无条件压入符号栈
         {
              Stack2.push_back(it->c_str());//
             // cout<<"PUSH Stack2"<<it->c_str()<<endl;
              continue;
         }

         //if(f2<f1)//数字越小优先级越大,f1找不到的话Stack2就是空栈,f1指向迭代器的尾部
         if(li_yxj_f2<li_yxj_f1)//数字越小优先级越大,f1找不到的话Stack2就是空栈,f1指向迭代器的尾部
         {
             if(strcmp(it->c_str(),")")!=0)
             {
                 Stack2.push_back(it->c_str());//当前优先级高，运算符压栈
                // cout<<"PUSH Stack2"<<it->c_str()<<endl;
             }
             else
             {
                 string ls_pop1="";
                 string ls_pop2="";
                 while(strcmp(Stack2.at(Stack2.size()-1).c_str(),"(")!=0)//弹栈直到遇到'('
                 {
                     int result=0;
                     int lb_result=false;
                     ls_pop1=Stack1.at(Stack1.size()-2);
                     ls_pop2=Stack1.at(Stack1.size()-1);
                    // cout<<"ls_pop1="<<ls_pop1.c_str()<<endl;
                    // cout<<"ls_pop2="<<ls_pop2.c_str()<<endl;
                    // cout<<"Stack2.at(Stack2.size()-1).c_str()="<<Stack2.at(Stack2.size()-1).c_str()<<endl;
                     if(strcmp(Stack2.at(Stack2.size()-1).c_str(),"<")==0 || strcmp(Stack2.at(Stack2.size()-1).c_str(),">")==0 ||
                        strcmp(Stack2.at(Stack2.size()-1).c_str(),"<=")==0 ||strcmp(Stack2.at(Stack2.size()-1).c_str(),">=")==0||
                        strcmp(Stack2.at(Stack2.size()-1).c_str(),"<>")==0||strcmp(Stack2.at(Stack2.size()-1).c_str(),"!=")==0||
                        strcmp(Stack2.at(Stack2.size()-1).c_str(),"==")==0)
                     {
                         result=strcmp(ls_pop1.c_str(),ls_pop2.c_str());//返回<0的值=0的值>0的值具体和编译器有关
                         if(result<0)
                         {
                             result=-1;
                         }
                         else if(result>0)
                         {
                             result=1;
                         }
                         else
                         {
                             result=0;
                         }
                         //lb_result true=1;false=0;
                         lb_result=false;//默认flase;
                        // cout<<"(result)="<<result<<endl;
                         if(strcmp(Stack2.at(Stack2.size()-1).c_str(),"<")==0 && result<0)
                         {
                             lb_result=true;
                         }

                         if(strcmp(Stack2.at(Stack2.size()-1).c_str(),"<=")==0 && result<=0)
                         {
                             lb_result=true;
                         }

                         if(strcmp(Stack2.at(Stack2.size()-1).c_str(),">")==0 && result>0)
                         {
                             lb_result=true;
                            // cout<<"if_lb_result="<<lb_result<<endl;
                         }

                         if(strcmp(Stack2.at(Stack2.size()-1).c_str(),">=")==0 && result>=0)
                         {
                             lb_result=true;
                         }

                         if(strcmp(Stack2.at(Stack2.size()-1).c_str(),"==")==0 && result==0)
                         {
                             lb_result=true;
                         }

                         if(strcmp(Stack2.at(Stack2.size()-1).c_str(),"!=")==0 && result!=0)
                         {
                             lb_result=true;
                         }

                         if(strcmp(Stack2.at(Stack2.size()-1).c_str(),"<>")==0 && result!=0)
                         {
                             lb_result=true;
                         }
                     }
                     else
                     {
                         if(strcmp(it->c_str(),"&&")==0 || strcmp(it->c_str(),"and")==0)
                         {
                            result=atoi(ls_pop1.c_str()) && atoi(ls_pop2.c_str());
                         }
                         else if(strcmp(it->c_str(),"||")==0 || strcmp(it->c_str(),"or")==0)
                         {
                           result=atoi(ls_pop1.c_str()) || atoi(ls_pop2.c_str());
                         }
                     }

                   //  cout<<"temp()="<<lb_result<<endl;
                     Stack2.pop_back();//弹出一个运算符
                     Stack1.pop_back();//弹出一个数字
                     Stack1.pop_back();//再弹出一个数字

                     char str[10] = {0};
                     sprintf(str, "%i", lb_result);
                     string ls_result="";
                     ls_result=str;
                     Stack1.push_back(ls_result);//运算结果压栈
                    int i=0;
                    i++;
                    if(i>10000)//限定循环数，避免由于表达式错误而死循环
                    {
                        break;
                    }
                 }//while 结束

                 //cout<<"弹出一个左括号运算符("<<endl;
                 if(Stack2.size()>0)//栈空不必再弹了
                 {
                      Stack2.pop_back();//弹出一个左括号运算符
                 }
             }
         }
         else//栈顶优先级高，运算符弹栈做运算
         {
              string ls_pop1="";
              string ls_pop2="";
              ls_pop1=Stack1.at(Stack1.size()-2);
              ls_pop2=Stack1.at(Stack1.size()-1);
             // cout<<"POP Stack2"<<endl;
             // cout<<"POP Stack2"<<Stack2.at(Stack2.size()-1).c_str()<<endl;
              int result=0;
              bool lb_result=false;
              if(strcmp(Stack2.at(Stack2.size()-1).c_str(),"<")==0 || strcmp(Stack2.at(Stack2.size()-1).c_str(),">")==0 ||
                 strcmp(Stack2.at(Stack2.size()-1).c_str(),"<=")==0 ||strcmp(Stack2.at(Stack2.size()-1).c_str(),">=")==0||
                 strcmp(Stack2.at(Stack2.size()-1).c_str(),"<>")==0||strcmp(Stack2.at(Stack2.size()-1).c_str(),"!=")==0||
                 strcmp(Stack2.at(Stack2.size()-1).c_str(),"==")==0)
              {
                  result=strcmp(ls_pop1.c_str(),ls_pop2.c_str());//返回<0的值=0的值>0的值具体和编译器有关
                 // cout<<"int result="<<result<<endl;
                  if(result<0)
                  {
                      result=-1;
                  }
                  else if(result>0)
                  {
                      result=1;
                  }
                  else
                  {
                      result=0;
                  }
                  //lb_result true=1;false=0;
                  lb_result=false;//默认flase;
                  if(strcmp(Stack2.at(Stack2.size()-1).c_str(),"<")==0 && result<0)
                  {
                      lb_result=true;
                  }

                  if(strcmp(Stack2.at(Stack2.size()-1).c_str(),"<=")==0 && result<=0)
                  {
                      lb_result=true;
                  }

                  if(strcmp(Stack2.at(Stack2.size()-1).c_str(),">")==0 && result>0)
                  {
                      lb_result=true;
                     // cout<<"if_lb_result="<<lb_result<<endl;
                  }

                  if(strcmp(Stack2.at(Stack2.size()-1).c_str(),">=")==0 && result>=0)
                  {
                      lb_result=true;
                  }

                  if(strcmp(Stack2.at(Stack2.size()-1).c_str(),"==")==0 && result==0)
                  {
                      lb_result=true;
                  }

                  if(strcmp(Stack2.at(Stack2.size()-1).c_str(),"!=")==0 && result!=0)
                  {
                      lb_result=true;
                  }

                  if(strcmp(Stack2.at(Stack2.size()-1).c_str(),"<>")==0 && result!=0)
                  {
                      lb_result=true;
                  }

              }
              else
              {
                  if(strcmp(Stack2.at(Stack2.size()-1).c_str(),"&&")==0 || strcmp(Stack2.at(Stack2.size()-1).c_str(),"and")==0)
                  {
                     lb_result=atoi(ls_pop1.c_str()) && atoi(ls_pop2.c_str());
                  }
                  else if(strcmp(Stack2.at(Stack2.size()-1).c_str(),"||")==0 || strcmp(Stack2.at(Stack2.size()-1).c_str(),"or")==0)
                  {
                    lb_result=atoi(ls_pop1.c_str()) || atoi(ls_pop2.c_str());
                  }
              }

              //cout<<"lb_result="<<lb_result<<endl;
              Stack2.pop_back();//弹出一个运算符
              Stack1.pop_back();//弹出一个数字
              Stack1.pop_back();//再弹出一个数字
              //Stack2.push_back(it->c_str());//弹完上一个运算符做计算，压入当前运算符。
              char str[10] = {0};
              sprintf(str, "%i", lb_result);
              string ls_result="";
              ls_result=str;
              Stack1.push_back(ls_result);//运算结果压栈
              it --;//下一次循环重新比较当前运算符(注意当前运算符未变)与新栈顶运算符
              //continue;
         }

      }
      else
      {
         Stack1.push_back(it->c_str());//变量及数字栈
      }
   }
 string ls_expression_result="";
 for(vector <string>::iterator it = Stack1.begin (); it != Stack1.end (); it ++)
 {
   // cout<<it->c_str();
 }
 cout<<endl;
 for(vector <string>::iterator it = Stack2.begin (); it != Stack2.end (); it ++)
 {
   // cout<<it->c_str();
 }
// cout<<endl;
 ls_expression_result=Stack1.at(Stack1.size()-1).c_str();
  return atoi(ls_expression_result.c_str());
}

#endif // EXPRESSION_H

symbol68688
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
算符优先分析法的简单实现
hhm853610070的博客
05-11 6074
一.算符优先分析法即是一种针对算符优先文法的分析方法。 二.如果一个文法的任一产生式的右部都不存在两个相邻的非终结符，则称这个文法为算符文法(OG)。 三.假定文法G是一个不含e的算符文法，a,b∈Vt，P,Q,R∈Vn，满足： （一）a=b当且仅当文法G含有形如P->...ab...或者P->...aQb...的产生式 （二）a<b当且仅当文法G含有形如P->.....
[编译原理]算符优先文法分析与实现
童凌的技术博客
06-16 2万+
在算术表达式中，运算的优先顺序主要采用四则运算的口诀：先乘除后加减，从左算到右，这个口诀确定了乘除运算优先于加减运算，同级运算一律从左到右，即代数中的“左结合”法则。如果计算的每一步做一个运算，那么四则运算的每一步都是唯一的。        算符优先分析法实质上就是仿效上述计算过程而设计的一种方法，它规定：用算符之间的运算优先关系来确定语句的合法性。并不是所有上下文无关文法都可以建立这样的关系
算符优先文法 C语言实现
06-25
是一个算符优先文法的C语言实现，在这里和大家分享，需要的可以下载。
算符优先文法的实现C++编写
06-02
检查语法错误，从文件中输入文法，出错语法错误到文件中，对算符优先文法适用
慕课编译原理(第十章.算符优先文法)
weixin_42473228的博客
04-07 337
慕课广西大学.编译原理.第十章.语法分析-自下而上分析1.算符优先文法0 目录10 语法分析-自下而上分析110.4 算符优先文法10.4.1 课堂重点10.4.2 测试与作业11 下一章 0 目录 10 语法分析-自下而上分析1 10.4 算符优先文法 10.4.1 课堂重点 10.4.2 测试与作业 11 下一章 博客地址: ...
算符优先文法的编程实现
qq_39322743的博客
12-01 5254
实验三 算符优先文法的编程实现 一、实验目的 1. 通过本次实验，加深对移进规约分析法中算符优先法的理解； 2. 学习程序设计语言的语法分析器的手工编程方法。   二、实验内容 1. 对于任意给定的文法，判断其是否是算符优先文法。 2. 通过语法分析，生成抽象语法树，在此基础上设计并实现一个简单的计算器。   三、实验原理 1. 自底向上优先分析方法 也称移进-归约分析，粗略
算符优先文法
随惜的博客
02-26 7156
算符优先文法 需求描述 对于任意给定的文法，判断其是否是算符优先文法，如果是则构造出算符优先关系表。 算法描述 主要是先判断输入的数据是否是一个文法，然后通过判断是否存在连续两个相邻的非终结符来判断它是否是算符优先文法，若不是，则直接提示并退出程序；否则，依次求得所有非终结符的FIRSTVT集与LASTVT集，然后根据规则构造优先关系表，当任意两终结符之间不存在多种优先关系时，说明它是算符优先文法...
算符优先文法处理判断算术表达式的正确性
06-13
算符优先文法通过建立一个算符优先表来实现这一目标，这个表定义了运算符之间的优先级关系。 03.cpp 文件很可能是用 C++ 编写的程序，实现了算符优先文法解析器。这个程序可能会包含以下关键部分： 1. **算符优先...
算符优先文法分析
03-14
算符优先文法是一种上下文无关文法，它为文法中的每个产生式赋予一个优先级，使得在解析表达式时，可以依据这些优先级来决定运算的顺序。这种文法尤其适用于处理带有多种运算符且运算符具有不同优先级的表达式，如...
编译原理算符优先文法
11-29
算符优先文法是一种自下而上的分析方法，其文法的特点是文法的产生式中不含两个相邻的非终结符。 生成FIRSTVT LASTVT集合 算符优先关系表 可以对输入的语言进行分析 样例 1： S->#E# E->E+T E->T T->T*F T->...
编译原理课程设计简单优先文法判定和分析器的构造
06-11
这是我做的编译原理简单优先文法判定和分析器的构造。 包括第一章 概述 3 1.1 项目背景 3 1.2 设计目的 3 1.3 实验环境与开发工具 3 1.4 C++语言 4 第二章 需求分析 5 2.1 问题陈述 5 2.1.1 简单优先文法 5 2.1.2 简单优先文法的定义 6 2.1.3 简单优先文法的算法 6 2.1.4 简单优先分析法的操作步骤 6 2.2 需要完成的功能 7 2.2.1 判定输入的文法是否是简单优先文法 7 2.2.2 构造文法的简单优先关系矩阵 7 2.3 分析器的构造 7 第三章 逻辑设计 9 3.1系统的组织与基本工作流程 9 3.2 总体结构逻辑结构图 9 第思章 软件功能设计 11 4.1 软件功能分析 11 4.1.1 判定文法是否为简单优先文法 11 4.1.2 查找分析文法优先关系相等 12 4.1.3 查找分析文法中小于的关系 14 4.1.4 查找分析文法中大于的关系 15 4.1.5 构造文法的简单优先关系矩阵 16 第五章 界面设计 18 5.1用户输入文法界面 19 5.2优先矩阵的初始状态 20 5.3 文法中等于关系 21 5.4 小于关系 22 5.5 大于关系 23 5.6 优先关系矩阵 25 小结 27 参考文献 28 附录 29
编译原理课程设计 算符优先文法 带界面 Java版
07-29
算符优先文法完整版，程序实现了几乎整个算符优先文法的自动化分析，并且展示到GUI界面上，可由用户输入任何文法和输入串，算符优先文法则正常分析，非算符优先文法则提示错误信息，并且整个程序在一些方面设计了...
简单算符优先文法分析程序（编译原理）
一只小菜鸟
11-28 1万+
题目                       实现算符优先文法分析程序；完成对以下表达式文法的分析程序。        G[E]:             E->E+T             E->T             T->T*F             T->F             F->(E)             F->i       优
算符优先文法实现
寰宇的博客
05-26 2926
思路： 1.通过求得给定文法的算符文法，对文法进行分析，然后求出该文法每个非终界符的firstVT和lastVT 2.通过求出的firstVT和lastVT得到终结符的优先级 3.通过优先级，对输入的算式进行分析，判断是否合法 具体可以参照我github上的代码地址： https://github.com/kim-yhow/Algpregram
编译原理(七) 算符优先分析法(构造算符优先关系表算法及C++实现)
热门推荐
llin-黎辰
11-29 6万+
概念简述移动归约分析法：自底向上的语法分析方法，也称为移动归约分析法。 最易于实现的一种移动归约分析方法，叫做算符优先分析法， 而更一般的移动归约分析方法叫做LR分析法，LR分析法可以用作许多自动的语法分析器的生成器。 短语：文法G[S]，αβδ是文法G的一个句型，S=>*αAδ且A=>+β则称β是句型αβδ相对于非终结符A的短语。 直接短语：若有A ⇒+\Rightarrow^+β则称β是句型α
算符优先算法（FIRSTVT集，LASTVT集，判读是否是算符优先文法，算符优先矩阵，句子分析）
zzg2511471213的专栏
11-20 6644
/////**共有三个类**①主类Op.java*②处理算法的关键类GetFL.java*③读取信息类ReadInfo.java从TXT文件中读取文法**/////* * author:Ack訾 * Date：15/11/2012 * Attention: */ package com.algorithm; import java.io.IOException; import java.u
编译原理(八) 算符优先分析法(分析过程的算法和C++实现)
llin-黎辰
11-30 1万+
前情提要算符优先分析法(构造算法优先关系表)算法描述算符优先关系主要用于界定右句型的句柄： <标记句柄的左端； =出现在句柄的内部； >标记句柄的右端。 发现句柄的过程： 从左端开始扫描串，直到遇到第一个>为止。 向左扫描，跳过所有的=，直到遇到一个<为止。 句柄包括从上一步遇到的<右部到第一个>左部之间的所有符号，包括介于期间或者两边的非终结符 非终结符的处理： 因为非终结符不能
基于算符优先文法的语法分析器设计与实现
了解算符优先文法的作用和实现 算符优先文法是计算机科学中的一种形式文法，用于描述编程语言的语法结构。它可以用来分析和解析编程语言的语法正确性。下面是关于算符优先文法的知识点： 1. 算符优先文法的作用 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值