表达式求值（中）

最新推荐文章于 2021-11-01 17:09:51 发布
最新推荐文章于 2021-11-01 17:09:51 发布
阅读量1.4k 收藏
点赞数
分类专栏： 算法 文章标签： iterator token math.h class null delete
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/bluebohe/article/details/21047
版权
 

// Expression.cpp: implementation of the CExpression class.

//

//

 

#include "stdafx.h"

#include "Expression.h"

#include "math.h"

 

const  int funTableLen = 17;  //函数表长度

double sign(double x);

static  double ( * funTable[ ] )( double ) = {

    acos, asin, atan,

              ceil, cos,  cosh,  exp,

              fabs, floor, log,  log10,

              sin,  sinh,  sqrt,

              tan,  tanh, sign

}; //单参数函数入口地址表

 

static char funNameTable[ ][6] = {

    "acos", "asin", "atan", "ceil", "cos", "cosh", "exp", "fabs",

              "floor",  "log", "log10", "sin", "sinh", "sqrt", "tan", "tanh", "sign"

};    //函数名表

 

//

// CVar Class

//

 

//

// Construction/Destruction

//

 

CVar::CVar()

{

       InitVar();

}

 

CVar::~CVar()

{

      

}

void CVar::InitVar()

{

     m_cFlag=1;   

        m_strName="";

     m_strSlave="";      

     m_dValue=0;  

}

//

// CVarList Class

//

 

//

// Construction/Destruction

//

 

CVarList::CVarList()

{

      

}

 

CVarList::~CVarList()

{

       list<CVar*>::iterator iter;

       for(iter=m_VarList.begin();iter!=m_VarList.end();iter++)

       {

              delete (*iter);

       }

       m_VarList.clear();

}

bool CVarList::AddVar(CVar *pVar)

{

       m_VarList.insert(m_VarList.end(),pVar);

       return true;

}

 

 

 

//

// Construction/Destruction

//

 

CExpression::CExpression()

{

       m_iErrFlag=0;

       m_iFunFlag=0;

       m_iMatchFlag=0;

    m_dResult = 0;

       m_bDegUnit=true;

       m_strExp=NULL;

       strcpy(m_strToken,"");

}

 

CExpression::~CExpression()

{

      

}

 

bool CExpression::CalExp()

{

    bool ret;

      

       m_iErrFlag=0;

       m_iFunFlag=0;

       m_iMatchFlag=0;

    m_dResult = 0;

      

    if( strlen(m_strExp)==0)

       {

              m_iErrFlag = 1;

              Error();

              return false;

       }

       UpdateSlaveVar();

      

    //取表达式第一单元(利用m_strExp)

    if(GetToken() == true)

    {

              //进入高优先级运算

              ret = Level1(&m_dResult);

             

              //若高级运算出现错误(m_iErrFlag被设置)

              if(ret == false)

              {

                     //打印错误信息

                     Error();

                     return false;

              }

              else

                     return true;

    }

      

    //从表达式中取符号错误

    m_iErrFlag = 2;

    Error();

    return false;

}

void CExpression::Error()

{

    switch(m_iErrFlag)

    {

       case 1:

              Message( "表达式为空!" );

              break;

       case 2:

              Message( "变量或函数非法或语法错误!/n表达式无法计算!" );

              break;

       case 3:

              Message("括号不匹配!");       //"括号不匹配!"

              break;

    }

      

}

 

void CExpression::Message(const char *strMsg)

{

//       printf("/n%s/n",strMsg);

}

 

 

bool CExpression::GetToken()

{

    register char *temp;

      

    m_cTokenType = 0;

      

    //指针指向token的首地址

    temp = m_strToken;

      

    //跳过空格及TAB符

    while(IsWhite(*m_strExp) == true)

              m_strExp++;

      

    //首字符是为运算符

    if(IsInStr(*m_strExp,"+-*/%^=(),") == true)

    {

              m_cTokenType = DELIMITER;

              *temp++ = *m_strExp++;

              *temp = 0;

              return true;

    }

      

    //首字符为ASSCI字符或汉字

    else if( isalpha(*m_strExp) || (*m_strExp > 127) || (*m_strExp < 0) )

    {

              //找到字符串结尾

              while(IsDelim(*m_strExp) != true)

                     *temp ++ = *m_strExp++;

             

              *temp = 0;

             

              if(IsFunc( m_strToken ) )

              {

                     m_cTokenType = FUNCTION;

                     return true;

              }

             

              //搜索变量表,判断取得的符号是否为变量

              string  sToken = m_strToken;

              list<CVar*>::iterator iter;

             

              for(iter=m_VarList.m_VarList.begin();iter!=m_VarList.m_VarList.end();iter++)

              {

                     if((*iter)->m_strName == sToken )

                     {

                            m_cTokenType = VARIABLE;

                            return true;

                     }

              }

              return false;

    }

      

    //首字符为数字

    else if(isdigit(*m_strExp) || *m_strExp == '.')

    {

              //.5按0.5处理

              if(*m_strExp == '.')

            *temp++ = '0';

             

              while(IsDelim(*m_strExp) != true)

                     *temp ++ = *m_strExp++;

             

              *temp = 0;

              m_cTokenType = NUMBER;

              return true;

    }

      

    //首字符为NULL

    if(*m_strExp == 0)

    {

              strcpy(m_strToken,"");

             

              //到达结尾

        return true;

       }

    return false;

      

}

 

 

//判断是否为空格或TAB

bool CExpression::IsWhite(char c)

{

    if(c == ' ' || c == 9)

              return true;

    return false;

}

 

//判断是否为分隔符

bool CExpression::IsDelim(char c)

{

    if(IsInStr(c,"+-*/%^=() ,") == true || c == 9 || c == '/r' || c == 0)

              return true;

    return  false;

}

 

//判断是否为函数

bool CExpression::IsFunc(const char *fname)

{

    int i;

    for(i=0;i<funTableLen;i++)

    {

              if(strcmp(fname,funNameTable[i]) == 0)

                     return true;

    }

    return false;

}

 

//判断C是否在串S中

bool CExpression::IsInStr(char ch,char *s)

{

    while(*s)

    {

              if(*s++ == ch)

                     return true;

    }

    return false;

}

 

 

double sign(double x)

{

    if(x > 0)

        return x;

    else

        return 0;

}

//赋值运算

bool CExpression::Level1(double *result)

{

    int index,ttok_type;

    char temp_token[80];

      

    //变量单元,有可能是赋值的表达式运算

    if(m_cTokenType == VARIABLE)

    {

              //保留该单元及单元类型

              strcpy(temp_token,m_strToken);

              ttok_type = m_cTokenType;

             

              //若取不到变量在变量表中的索引值

              if(GetVarIndex(m_strToken,&index) != true)

              {

                     m_iErrFlag = 2;

                     return false;

              }

             

              if(GetToken() != true)

              {

                     m_iErrFlag = 2;        //m_iErrFlag = 1;

                     return false;

              }

             

              //若变量后紧跟'='号,则为赋值运算,否则为一般运算

              if(*m_strToken != '=')

              {

                     //将刚取得的单元回送到表达式中

                     PutBack();

                    

                     //恢复当前单元变量及变量类型

                     strcpy(m_strToken,temp_token);

                     m_cTokenType = ttok_type;

              }

             

              //若为赋值运算进入下面运算

              else

              {

                     //取'='号后面的单元

                     if(GetToken() != true)

                     {

                            m_iErrFlag = 2;        //m_iErrFlag = 1;

                            return false;

                     }

                    

                     //进入高级的+-运算

                     if(Level2(result) == true)

                     {

                            list<CVar*>::iterator iter;

                            int i=0;

                            for(iter=m_VarList.m_VarList.begin();iter!=m_VarList.m_VarList.end();iter++)

                            {

                                   if(i==index)

                                   {

                                          (*iter)->m_dValue=*result;

                                          return true;

                                   }

                                   i++;

                            }

                     }

                     else

                            return false;

              }

    }

      

    //第一单元不是变量,直接进入高优先级+-运算

    if(Level2(result) == true)

              return true;

    else

              return false;

}

 

//加减运算

bool CExpression::Level2(double *result)

{

    register char op;  //运算符

    double     hold=0;      //保留运算中间结果

      

    //直接进入高优先级的*/%运算,没有高级运算才进入下面运算

    if(Level3(result) != true)

              return false;

      

    //若下一单元为+-号

    while((op = *m_strToken) == '+' || op == '-')

    {

              //取得+-号后的单元

              if(GetToken() == true)

              {

                     //运算+-号后面的表达式值,有可能又取得+-号

                     if(Level3(&hold) == true)

                     {

                            //数学运算,结果直接放在*result中

                            bool  bRet = Arith(op,result,&hold);

                            if( bRet == false )

                                   return  false;

                     }

                     else

                            return false;

              }

              else

              {

                     m_iErrFlag = 2;        //m_iErrFlag = 1;

                     return false;

              }

    }

    return true;

}

 

//乘除及求余数运算

bool CExpression::Level3(double *result)

{

    register char op;  //运算符

    double     hold=0;      //保留中间运算结果

      

    //直接进入高优先级运算,没有高级运算才进入下面运算

    if(Level4(result) != true)

              return false;

      

    //若下一单元为*/%

    while((op=*m_strToken) == '*' || op == '/' || op == '%')

    {

              //取得运算符后的单元

              if(GetToken() == true)

              {

                     //运算*/%后的表达式值,有可能又获得*/%

                     if(Level4(&hold) == true)

                     {

                            //数学运算,结果放在*result中

                            bool  nRet = Arith(op,result,&hold);

                            if( nRet == false )

                                   return  false;

                     }

                     else

                            return false;

              }

              else

              {

                     m_iErrFlag = 2;        //m_iErrFlag = 1;

                     return false;

              }

    }

    return true;

}

 

//乘方运算

bool CExpression::Level4(double *result)

{

    register char op;  //运算符

    double     hold=0;      //保留中间运算结果

      

    //直接进入高优先级运算,没有高级运算才进入下面运算

    if(Level5(result) != true)

              return false;

      

    //若下一单元为^(乘方)

    while((op=*m_strToken) == '^')

    {

              if(GetToken() == true)

              {

                     //取得运算符后的单元

                     if(Level5(&hold) == true)

                     {

                            //运算^后的表达式值,有可能又获得^

                            bool  nRet = Arith(op,result,&hold);

                            if( nRet == false )

                                   return  false;

                     }

                     else

                            return false;

              }

              else

              {

                     m_iErrFlag = 2;        //m_iErrFlag = 1;

                     return false;

              }

    }

    return true;

}

 

 

 

//单目求反运算

bool CExpression::Level5(double *result)

{

    register char op = 0;

      

    if((m_cTokenType == DELIMITER) && *m_strToken == '+' || *m_strToken == '-' )

    {

              //若表达式第一单元为+号或-号,记录该运算符

              op = *m_strToken;

             

              //取得下一单元

              if(GetToken() != true)

              {

                     m_iErrFlag = 2;        //m_iErrFlag = 1;

                     return false;

              }

    }

      

    //进入高优先级运算

    if(Level6(result) != true)

              return false;

      

    //进入高优先级运算

    if(op)

              Unary(op,result);

      

    return true;

}

bluebohe
关注
专栏目录
中缀表达式求值
q757666419的博客
11-09 643
中缀表达式求值 中缀表达式求值的运算方法为 当遇到数值直接压入数值栈 当遇到运算符时比较运算符栈栈顶运算符的优先级，如果大于等于当前运算符优先级，则弹出两个数值进行运算，并入栈 当遇到（时直接入栈 当遇到)时计算直到( 代码用到了一点小技巧，首先在运算符栈里面存放了一个优先级最低的字符(‘q’)，因此当第一个运算符比较优先级时一定大于栈顶优先级，故此实现第一个入栈的运算符不会进行运算(这种方法...
【课件】3.3.2_2_栈在表达式求值中的应用(下).pdf
最新发布
05-16
根据提供的文件标题、描述以及部分内容，我们可以明确地了解到这一节主要关注的是栈在表达式求值中的应用。接下来，我们将详细探讨与栈及其在表达式求值中的应用相关的知识点。 ### 一、栈的基本概念 栈是一种特殊...
中值表达式求值（C语言解法）
qq_56350439的博客
11-01 1420
#include <stdio.h> #include <iostream> using namespace std; #define MAXSIZE 100 typedef struct LNode { int OPNT[MAXSIZE]; int top1; } LNode; //操作数栈 typedef struct SLNode { char OPRT[MAXSIZE]; int top2; } SLNode; //运算符栈； void .
【数据结构】中缀表达式表达式求值
这里是Mae。
10-08 3443
一、问题描述 中缀表达式求值 例如：2*(3+5)-7 二、解题思路 定义两个栈，一个操作数栈，一个运算符栈，首先需要定义运算符的优先级，如图。 将表达式的前后都加上‘#’方便操作。#2*(3+5)-7# 首先从前往后扫描字符串，当遇到操作数时，就将其压入操作数栈。当遇到运算符时，首先和运算符栈的栈顶元素比较，当小于，压栈(运算符)，大于，出栈(运算符)并且从运算符栈出两个字符，先出做后件，后出做前件，运算完后将其压入操作数栈，注意并不继续扫描下一个字符，当等于时，若为括号弹出括号但不从操作数栈弹出两个操
【课件】3.3.2_1_栈在表达式求值中的应用(上).pdf
05-16
### 栈在表达式求值中的应用 #### 一、栈的基本概念 栈是一种特殊的线性表，只允许在一端进行插入和删除操作，通常这一端被称为栈顶(top)，另一端被称为栈底(bottom)。其操作特点遵循后进先出(Last In First Out, ...
数据结构-表达式求值实验报告.doc
08-27
在表达式求值中，数据结构的设计是至关重要的。我们可以使用顺序栈来寄存表达式的操作数和运算符。顺序栈是一种限定仅在表尾进行插入或删除操作的线性表。栈的存储结构是利用一组连续的存储单元依次存放自栈底到栈顶...
序列点在C语言表达式求值中的作用.pdf
09-19
序列点是C语言表达式求值中的一个重要概念，它定义了表达式中特定的时间点，在这些时间点之前的所有副效应（side effects）必须已经完成，而在这些时间点之后的副效应还未发生。正确理解和运用序列点对于编写符合...
8.表达式求值_python/表达式求值_
09-29
在Python编程语言中，表达式求值是一项基本且重要的任务，它涉及到将字符串形式的数学或逻辑表达式转换为实际的计算结果。本教程将深入探讨如何使用Python来实现表达式求值，特别是通过五行代码的简洁实现，以及相关...
含变量的表达式求值问题.rar
04-02
算法选的课设，含变量的表达式求值，通过对课本上的算法进行改良，优化，里面有完整的代码和课设报告，仅供参考
简单数学表达式求值
03-18
简单数学表达式求值，只能进行+ - * / 和（）的运算，先将中缀表达式转化为后缀表达式，再利用栈进行求解
数据结构课设——表达式求值（c++）
01-08
表达式是数据运算的基本形式。人们的书写习惯是中缀式，如：11+22*（7-4）/3.中缀式的计算按运算符的优先级及括号优先的原则，相同级别从左到右进行计算。表达式还有后缀表达式（如：11 22 7 4 - * 3 / +）和前缀表达式（+ 11 / * 22 - 7 4 3）。后缀表达式和前缀表达式中没有括号，给计算带来方便。如后缀表达式计算时按运算符出现的先后进行计算。本设计的主要任务是进行表达式形式的转换及不同形式的表达式计算。
try3_表达式求值_
09-29
表达式求值，包含单变量表达式求值和简单的表达式求值。
中缀表达式求值 C++
小哥哥咯的博客
08-22 2908
中缀表达式求值 C++实现四则运算
表达式求值
G191018的博客
03-16 146
#include #include #include #include #include #include using namespace std; const int MAXN = 1010; int priority(char c) // 表达优先级的大小关系 { if (c == ‘*’ || c == ‘/’) return 2; if (c == ‘+’ || c == ‘-...
中缀表达式求值问题
weixin_44501390的博客
09-10 1743
中缀表达式的求值问题是一个比较常见的问题之一，我们通常在编写程序时，直接写出表达式让编译器去处理，很少去关心编译器是怎么对表达式进行求值的，今天我们来一起了解一下其中具体的原理和过程。 表达式一般来说有三种：前缀表达式、中缀表达式、后缀表达式，其中后缀表达式又叫做逆波兰表达式。中缀表达式是最符合人们思维方式的一种表达式，顾名思义，就是操作符在操作数的中间。而前缀表达式和后缀表达式中操作符分别在操作数的前面和操作数的后面。举个例子： 3+2 这个是最简单的一个中缀表达式。而其等同的前缀表达式形式为+32，后缀
严版教材Y53页 中值表达式的计算
Read by heart
06-02 217
【反思】 1.输入的值必须为0~9 2.OPND必须为int，因为操作得到的结果的值可能超过char类型的取值范围 3.在计算完c值后，用continue跳出本层循环，这是由于exp[i]还没有入栈，不可以++i 4.将top1 == -1和栈顶优先级小的情况放在一起会使得代码更加简洁 5.因为没有##表达式求值完毕符号，所以必须要再写一个while循环将OPTR中的运算符都出栈后再返回...
scala进阶13-中值表达式
千里冰封
08-16 455
/** * 中值表达式 */ object Infix_Type { def main(args: Array[String]): Unit = { //函数名为>>: object Log { def >>: (data: String): Log.type = {println(data); Log}} //中值表达是是右结合的,其实是Log.>>:"Spa
使用栈实现表达式求值
在表达式求值中，我们通常采用逆波兰表示法（Reverse Polish Notation, RPN）或中缀表达式转换为后缀表达式的方法。这里我们将使用中缀表达式，并通过栈来计算其值。" 在计算机科学中，表达式求值是计算数学表达式...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值