第一步： 左括号直接压入操作符栈
操作符栈 (
后缀表达式 空
第二步：数字加入表达式中
操作符栈 (
后缀表达式 15
第三步：+号压入操作符栈
操作符栈 ( +
后缀表达式 15
第四步：数字加入表达式中
操作符栈 ( +
后缀表达式 15 25
第五步：遇到反括号了，将两个括号之间操作符依次加入到表达式中，并删除匹配的正括号
操作符栈 空
后缀表达式 15 25 +
第六步：*号压入操作符栈
操作符栈 *
后缀表达式 15 25 +
第七步：数字加入表达式中
操作符栈 *
后缀表达式 15 25 + 2
第八步：没有符号了，直接将操作符栈中剩余的依次加到表达式中，最终的结果
操作符栈 空
后缀表达式 15 25 + 2 *
000019. CalcPreprocessor() : Base Expression : (15 + 25) * 2
000020. FixArgument() : src='(15 + 25)'.
000021. FixArgument() : dst='(15 + 25)'.
000022. CalcPreprocessor() : Final Expression : (15 + 25)*2
000023. GetToken() : Current Char:'(', m_Position: 1
000024. GetToken() : Current Char:'1', m_Position: 2
000025. GetToken() : Last Char: '('
000026. GetToken() : Current Token: "(", m_Position: 1
000027. GetToken() : Current Char:'1', m_Position: 2
000028. GetToken() : Current Char:'5', m_Position: 3
000029. GetToken() : Last Char: '1'
000030. GetToken() : Current Char:' ', m_Position: 4
000031. GetToken() : Current Char:'+', m_Position: 5
000032. GetToken() : Last Char: '5'
000033. GetToken() : Current Token: "15", m_Position: 4
000034. GetToken() : Current Char:'+', m_Position: 5
000035. GetToken() : Current Char:' ', m_Position: 6
000036. GetToken() : Current Char:'2', m_Position: 7
000037. GetToken() : Last Char: '+'
000038. GetToken() : Current Token: "+", m_Position: 6
000039. GetToken() : Current Char:'2', m_Position: 7
000040. GetToken() : Current Char:'5', m_Position: 8
000041. GetToken() : Last Char: '2'
000042. GetToken() : Current Char:')', m_Position: 9
000043. GetToken() : Last Char: '5'
000044. GetToken() : Current Token: "25", m_Position: 8
000045. GetToken() : Current Char:')', m_Position: 9
000046. GetToken() : Current Char:'*', m_Position: 10
000047. GetToken() : Last Char: ')'
000048. GetToken() : Current Token: ")", m_Position: 9
000049. GetToken() : Current Char:'*', m_Position: 10
000050. GetToken() : Current Char:'2', m_Position: 11
000051. GetToken() : Last Char: '*'
000052. GetToken() : Current Token: "*", m_Position: 10
000053. GetToken() : Current Char:'2', m_Position: 11
000054. GetToken() : Current Token: "2", m_Position: 11
000055. ConvertToPostfixExpressione() : PostfixExpressione : 15 25 + 2 *
/*
* This file is part of the Code::Blocks IDE and licensed under the GNU General Public License, version 3
* http://www.gnu.org/licenses/gpl-3.0.html
*/
#ifndef EXPRESSION_H
#define EXPRESSION_H
#include "tokenizer.h"
#include "token.h"
class ExpressionNode
{
public:
enum ExpressionNodeType
{
Unknown, // Unknown
Plus, // +
Subtract, // -
MultiPly, // *
Divide, // /
LParentheses, // (
RParentheses, // )
Mod, // %
Power, // ^
BitwiseAnd, // &
BitwiseOr, // |
And, // &&
Or, // ||
Not, // !
Equal, // ==
Unequal, // !=
GT, // >
LT, // <
GTOrEqual, // >=
LTOrEqual, // <=
LShift, // <<
RShift, // >>
Numeric, // Numeric
};
ExpressionNode(wxString value);
ExpressionNodeType GetType() const { return m_Type; }
wxString GetValue() const { return m_Value; }
wxString GetUnitary() const { return m_Unitary; }
int GetPriority() const { return m_Priority; }
void SetUnitary(wxString unitary) { m_Unitary = unitary; }
static ExpressionNodeType ParseNodeType(wxString value);
static int GetNodeTypePriority(ExpressionNodeType nodeType);
static bool IsUnitaryNode(ExpressionNodeType nodeType);
private:
wxString m_Value;
ExpressionNodeType m_Type;
wxString m_Unitary;
int m_Priority;
int m_Numeric;
};
class ExpressionParser
{
public:
ExpressionParser(wxString expression);
wxString GetToken();
bool NotEOF();
bool IsWhiteSpace(wxChar ch);
bool IsCongener(wxChar ch1, wxChar ch2);
bool IsDoubleOperator(wxChar ch1, wxChar ch2);
private:
const wxString m_Expression;
size_t m_Position;
};
class Expression
{
public:
Expression();
void ConvertToPostfixExpression(wxString expression);
bool CalcPostfixExpression();
bool GetResult() const { return m_Result; }
bool GetStatus() const { return m_Status; }
private:
typedef std::list<ExpressionNode> ExpressionNodeList;
ExpressionNodeList m_PostfixExpression;
bool m_Result;
bool m_Status;
};
#endif // EXPRESSION_H
/*
* This file is part of the Code::Blocks IDE and licensed under the GNU General Public License, version 3
* http://www.gnu.org/licenses/gpl-3.0.html
*/
#include <sdk.h>
#include "expression.h"
#include <wx/app.h>
#include <wx/msgdlg.h>
#include <manager.h>
#include "logmanager.h"
#include <globals.h>
#include <stack>
#define PARSERTHREAD_DEBUG_OUTPUT 0
#ifdef PARSER_TEST
extern void ParserTrace(const wxChar* format, ...);
#define TRACE(format, args...)\
ParserTrace(format , ## args)
#else
#if PARSERTHREAD_DEBUG_OUTPUT
#define TRACE(format, args...)\
Manager::Get()->GetLogManager()->DebugLog(F( format , ## args))
#else
#define TRACE(format, args...)
#endif
#endif
namespace ExpressionConsts
{
const wxString Plus (_T("+"));
const wxString Subtract (_T("-"));
const wxString MultiPly (_T("*"));
const wxString Divide (_T("/"));
const wxString LParentheses (_T("("));
const wxString RParentheses (_T(")"));
const wxString Mod (_T("%"));
const wxString Power (_T("^"));
const wxString BitwiseAnd (_T("&"));
const wxString BitwiseOr (_T("|"));
const wxString And (_T("&&"));
const wxString Or (_T("||"));
const wxString Not (_T("!"));
const wxString Equal (_T("=="));
const wxString Unequal (_T("!="));
const wxString GT (_T(">"));
const wxString LT (_T("<"));
const wxString GTOrEqual (_T(">="));
const wxString LTOrEqual (_T("<="));
const wxString LShift (_T("<<"));
const wxString RShift (_T(">>"));
}
ExpressionNode::ExpressionNode(wxString value) :
m_Value(value),
m_Type(ParseNodeType(value)),
m_Numeric(0)
{
m_Priority = GetNodeTypePriority(m_Type);
}
ExpressionNode::ExpressionNodeType ExpressionNode::ParseNodeType(wxString value)
{
if (value.IsEmpty() || value.IsNull()) return Unknown;
else if (value == ExpressionConsts::Plus) return Plus;
else if (value == ExpressionConsts::Subtract) return Subtract;
else if (value == ExpressionConsts::MultiPly) return MultiPly;
else if (value == ExpressionConsts::Divide) return Divide;
else if (value == ExpressionConsts::Mod) return Mod;
else if (value == ExpressionConsts::Power) return Power;
else if (value == ExpressionConsts::LParentheses) return LParentheses;
else if (value == ExpressionConsts::RParentheses) return RParentheses;
else if (value == ExpressionConsts::BitwiseAnd) return BitwiseAnd;
else if (value == ExpressionConsts::BitwiseOr) return BitwiseOr;
else if (value == ExpressionConsts::And) return And;
else if (value == ExpressionConsts::Or) return Or;
else if (value == ExpressionConsts::Not) return Not;
else if (value == ExpressionConsts::Equal) return Equal;
else if (value == ExpressionConsts::Unequal) return Unequal;
else if (value == ExpressionConsts::GT) return GT;
else if (value == ExpressionConsts::LT) return LT;
else if (value == ExpressionConsts::GTOrEqual) return GTOrEqual;
else if (value == ExpressionConsts::LTOrEqual) return LTOrEqual;
else if (value == ExpressionConsts::LShift) return LShift;
else if (value == ExpressionConsts::RShift) return RShift;
else if (value == ExpressionConsts::Plus) return Plus;
else
{
if (value.IsNumber()) return Numeric;
else return Unknown;
}
}
int ExpressionNode::GetNodeTypePriority(ExpressionNodeType nodeType)
{
switch (nodeType)
{
case LParentheses:
case RParentheses:
return 9;
case Not:
return 8;
case Mod:
return 7;
case MultiPly:
case Divide:
case Power:
return 6;
case Plus:
case Subtract:
return 5;
case LShift:
case RShift:
return 4;
case BitwiseAnd:
case BitwiseOr:
return 3;
case Equal:
case Unequal:
case GT:
case LT:
case GTOrEqual:
case LTOrEqual:
return 2;
case And:
case Or:
return 1;
default:
return 0;
}
}
bool ExpressionNode::IsUnitaryNode(ExpressionNodeType nodeType)
{
return nodeType == Plus || nodeType == Subtract;
}
ExpressionParser::ExpressionParser(wxString expression)
: m_Expression(expression), m_Position(0)
{
}
bool ExpressionParser::NotEOF()
{
return m_Position < m_Expression.Length();
}
bool ExpressionParser::IsWhiteSpace(wxChar ch)
{
return ch == _T(' ') || ch == _T('\t');
}
bool ExpressionParser::IsDoubleOperator(wxChar ch1, wxChar ch2)
{
switch (ch1)
{
case _T('&'):
case _T('|'):
case _T('='):
case _T('!'):
case _T('>'):
case _T('<'):
{
wxString tmp(ch1);
tmp.Append(ch2);
if (tmp == ExpressionConsts::And ||
tmp == ExpressionConsts::Or ||
tmp == ExpressionConsts::Equal ||
tmp == ExpressionConsts::Unequal ||
tmp == ExpressionConsts::GTOrEqual ||
tmp == ExpressionConsts::LTOrEqual ||
tmp == ExpressionConsts::LShift ||
tmp == ExpressionConsts::RShift)
return true;
else
return false;
}
default:
return false;
}
}
bool ExpressionParser::IsCongener(wxChar ch1, wxChar ch2)
{
if (ch1 == _T('(') || ch2 == _T('(')) return false;
if (ch1 == _T(')') || ch2 == _T(')')) return false;
bool b1 = wxIsdigit(ch1);
bool b2 = wxIsdigit(ch2);
if ((b1 && b2) || (!b1 && !b2))
{
return true;
}
else
{
return false;
}
}
wxString ExpressionParser::GetToken()
{
wxString token;
while (NotEOF())
{
wxChar cur = m_Expression[m_Position++];
TRACE(_T("GetToken() : Current Char:'%c', m_Position: %d"), cur, m_Position);
if (IsWhiteSpace(cur))
{
continue;
}
if (!token.IsEmpty())
{
TRACE(_T("GetToken() : Last Char: '%c'"), token.Last());
if (IsDoubleOperator(cur, token.Last()))
{
token.Append(cur);
break;
}
if (IsCongener(cur, token.Last()))
{
token.Append(cur);
continue;
}
else
{
--m_Position;
break;
}
}
else
{
token.Append(cur);
}
}
TRACE(_T("GetToken() : Current Token: \"%s\", m_Position: %d"), token.wx_str(), m_Position);
return token;
}
Expression::Expression() : m_Result(true), m_Status(true)
{
}
void Expression::ConvertToPostfixExpression(wxString expression)
{
if (expression.IsEmpty()) return;
m_PostfixExpression.clear();
m_Result = true;
m_Status = true;
std::stack<ExpressionNode> stackOperator;
wxString unitary;
wxString token;
ExpressionParser parser(expression);
while (parser.NotEOF())
{
token = parser.GetToken();
if (token == wxEmptyString) break;
ExpressionNode expNode(token);
if (expNode.GetType() == ExpressionNode::Numeric)
{
// Operand, add to postfix expression
m_PostfixExpression.push_back(expNode);
}
else if (expNode.GetType() == ExpressionNode::LParentheses)
{
// Left Parentheses, add to stack
stackOperator.push(expNode);
}
else if (expNode.GetType() == ExpressionNode::RParentheses)
{
// Right Parentheses, reverse search the Left Parentheses, add all operator of the middle
ExpressionNode node(wxEmptyString);
while (!stackOperator.empty())
{
node = stackOperator.top();
stackOperator.pop();
if (node.GetType() == ExpressionNode::LParentheses)
break;
else
m_PostfixExpression.push_back(node);
}
// The lastest node must be Left Parentheses
if (node.GetType() != ExpressionNode::LParentheses)
{
m_Status = false;
}
}
else
{
if (stackOperator.empty())
{
// The first operator must be one of '+' '-' '!' '('
if (m_PostfixExpression.empty() &&
!(expNode.GetType() == ExpressionNode::LParentheses ||
expNode.GetType() == ExpressionNode::Not ||
expNode.GetType() == ExpressionNode::Plus ||
expNode.GetType() == ExpressionNode::Subtract))
{
if (ExpressionNode::IsUnitaryNode(expNode.GetType()) && unitary.IsEmpty())
{
unitary = expNode.GetValue();
}
}
else
{
stackOperator.push(expNode);
}
}
else
{
if (!unitary.IsEmpty())
{
expNode.SetUnitary(unitary);
unitary.Clear();
}
else
{
if (!stackOperator.empty())
{
ExpressionNode beforeExpNode = stackOperator.top();
if (beforeExpNode.GetType() != ExpressionNode::LParentheses
&& (beforeExpNode.GetPriority() - expNode.GetPriority()) > 0)
{
m_PostfixExpression.push_back(beforeExpNode);
stackOperator.pop();
}
}
stackOperator.push(expNode);
}
}
}
}
while (!stackOperator.empty())
{
ExpressionNode beforeExpNode = stackOperator.top();
if (beforeExpNode.GetType() == ExpressionNode::LParentheses)
{
m_Status = false;
}
m_PostfixExpression.push_back(beforeExpNode);
stackOperator.pop();
}
#ifdef PARSER_TEST
wxString exp;
for (ExpressionNodeList::const_iterator it = m_PostfixExpression.begin(); it != m_PostfixExpression.end(); ++it)
{
exp += it->GetValue() + _T(" ");
}
TRACE(_T("ConvertToPostfixExpressione() : PostfixExpressione : %s"), exp.wx_str());
#endif
}
等级：
在我做过的一个针对网络设备和主机的数据采集系统中，某些采集到的数据需要经过一定的计算后才保存入库，而不是仅仅保存其原始值。为了提供给用户最大的灵活性，我设想提供一个用户界面，允许用户输入计算表达式...
1. 这本书对Python的知识点的描述很详细，而且排版看的很舒服. 2. 几个例题：假装自己从零开始学，将一些有代表性、有意思的例题抽取出来. 3. 还有自己对一部分课后复习题，全部课后上机实践题的解题思路
1 算术运算符 （1）除 int x = 2810; System.out.println(x/1000);...两个整数类型进行相除，那么结果就一定是...当计算两边都是正数，如果左边小于右边，那么结果就是左边；如果左边等于右边,那么结果就是为0。...
这里写目录标题一元操作符前缀递增操作符 ++前缀递增操作符 - -一元加号操作符 +一元加号操作符 -按位取反操作符 ~逻辑取反操作符 ！强制类型转换表达式乘除操作符乘法操作符 *除法操作符 /取余操作符 %加减操作符...
一元操作符 优先级 结合性 运算顺序 表达式是什么？ 就是JS 中的一个短语，解释器遇到这个短语以后会把对它进行计算，得到一个结果参与运算，我们把这种要参与到运算中的各种各样的短语称为表达式。实际...
JavaScript操作符与表达式1.表达式1.1原始表达式1.2表达式2.操作符 1.表达式 1.1原始表达式 3.14 //数字直接量 "hello world" //字符串直接量 /pattern/ //正则表达式直接量 true //返回一个布尔值： 真 false //...
问题由来在我做过的一个针对网络设备和主机的数据采集系统中，某些采集到的数据需要经过一定的计算后才保存入库，而不是仅仅保存其原始值。为了提供给用户最大的灵活性，我设想提供一个用户界面，允许用户输入计算...
Aviator 表达式求值引擎开源框架 简介¶ Aviator是一个高性能、轻量级的java语言实现的表达式求值引擎，主要用于各种表达式的动态求值。现在已经有很多开源可用的java表达式求值引擎，为什么还需要Avaitor呢？ ...
C#基础教程-c#实例教程，适合初学者。 第一章 C#语言基础 本章介绍C#语言的基础知识，希望具有C语言的读者能够基本掌握C#语言，并以此为基础，能够进一步学习用C#语言编写window应用程序和Web应用程序。...
一元操作符（9个） 定义：只可以操作一个表达式的符号 一元加、一元减、递增加、递增减、按位非、逻辑非、typeof、delete、void 一元加/减：将表达式转换成数字 typeof：用于判断数据类型 delete：删除对象属性 ...
本文中主要介绍Java中的运算操作。 如何正确的使用运算符，防止溢出是每个程序员的责任。 1. 算术运算 Java支持以下的算术运算： 运算符 描述 使用 例子 * 乘法 exp
1.1 运算符的分类 运算符(operator)也被称为操作符，是用于实现赋值、比较和执行算数运算等功能的符号。 算数运算符 递增和递减运算符 比较运算符 逻辑运算符 赋值运算符 1.2 算数运算符 算术运算符概述 概念:...
两种常见表达式是代数表达式（如：3+2）和布尔表达式（如true ^ false）都可以用它表示，这些表达式包含了一元运算符和二元运算符，从而节点的孩子可以是零个、一个或两个。表达式树的叶子节点储存操作数（操作数...
最近因工作需要，用到“计算器”功能：输入一串文本，解析后进行计算。这部分只是作为一个简单的应用模块，而不是单独的程序，所以着重在算法的实现上。实际编码前，想过用栈、二叉树、循环递归等各种方法，但都否定...
C++中操作符重载的使用
点击关注异步图书，置顶公众号媒体与你分享IT好书 技术干货 职场知识首先要说明的一下，所描述的是 Python 中的 运算表达式 的部分，不是 Python 表达式的部分。关于什么是 Python 中的运算表达式，可以...
逻辑操作符/布尔运算 位操作符 标准算术操作符 比较操作符 赋值操作符 操作符优先级 逻辑操作符/布尔运算 假设变量 a 为 10, b为 20: 逻辑操作符 运算符 逻辑表达式 描述 实例 and x and y ...
一、Expression中的操作运算符 成员名称 说明 Add 加法运算，如a + b, ，不进行溢出检查，针对数值操作数。 AddAssign 加法复合赋值运算，如(a += b), ，不进行溢出检查，针对数值操作数。 AddAssignChecked ...
前面已经学习了变量和常量，我们可以开始对它们进行操作，这就要用到C++的操作符。有些语言，很多操作符都是一些关键字， 比如add, equals等等。C++的操作符主要是由符号组成的。这些符号不在字母表中，但是在所有...
Python表达式操作符及程序 操作符 描述 yield x 生成器函数发送协议 lambda args：expression 生成匿名函数 x if y else z 三元选择表达式 x or y 逻辑或（只有x为False，才会计算y...
python表达式操作符 三元选择表达式：x if y else z 逻辑或： x or y 逻辑与： x and y 逻辑非：not x 成员关系 x in y x not in y 对象实体测试 x is y x not is y 大小比较，集合子集，超集相等性...
对于计算一个算式 如 : 3*(5+6)-...后缀表达式又叫逆波兰表达式, 把运算量写在前面, 把运算符写在后面, 并且可以去掉括号 如 a+b 变为 a b + a*(b+c) 可以变为 a b c + * 将普通算式转化为逆波兰表达式的步骤如...
换种说法，如果我们在C语言中定义了一个结构体，然后申明一个指针指向这个结构体，那么我们要用指针取出结构体中的数据，就要用到“->”。 p=p->next ，意思是将p指向的一个结构体实例中的子数据next赋值给p...
Java操作符包括：算术操作符、赋值操作符、按位操作符等 操作符的优先级 赋值操作符 - 操作符使用 赋值操作符具有右结合性，从右向左操作。 算术操作符 ... //一元操作符 //正号作用：将小类型...
一元操作符 优先级 结合性 运算顺序 表达式是什么？ 就是JS 中的一个短语，解释器遇到这个短语以后会把对它进行计算，得到一个结果参与运算，我们把这种要参与到运算中的各种各样的短语称为表达式。实际上...
关于 Java 中操作符优先级、一二三元操作符以及逻辑操作符中德模佛定理小结。操作符的优先级和结合规则确定了操作符计算的顺序。
3.1C运算符和表达式 3.1.1算术运算符和表达式 ... 求余运算限定参与运算的两个操作数必须为整数 11%5=1，11%(-5)=1，(-11)%5=-1 计算并且输出一个三位数的个位，十位和百位数字之和 #include<stdio.h>...
Python 表达式操作符 方便查阅
Spring框架是目前Java企业级开发中必不可少的一门技术，而Spring包含的内容又极其丰富，对于初学者来说无从把握，而该技术的更新速度相对快，如现在企业中用纯注解的方案，网上也很难找到全注解方案。 本套视频，主要讲解Spring 3.2.9的使用，对使用者的要求：已经会使用Struts 2和Hibernate 4等技术，同时对Spring的IOC有一些了解。 能够采用Struts 2.3 + Spring 3.2 +JDBC搭建项目 能够了解AOP概念和AOP在项目中的使用 会使用三种声明方式进行事务管理 IOC的注解方式完成SSH 在Myeclipse 2015中进行SSH快速搭建 采用Eclipse完成SSH框架搭建及功能实现
首先学习Python的基础知识，然后使用Python来控制Excel，做数据处理。 Excel使用者、Python爱好者、数据处理人员、办公人员等 第1章 python基础 1.1 什么是python？ 1.2 为什么要学习用Python处理Excel表格？ 1.3 手把手教你安装python程序 1.3.1 下载python 1.3.2 安装python 1.3.3 验证是否安装成功 1.4 安装Python集成开发工具PyCharm 1.4.1 下载 1.4.2 安装 1.5 Python的输入与输出
