计算包含函数的算术表达式

最新推荐文章于 2024-01-11 10:05:03 发布
最新推荐文章于 2024-01-11 10:05:03 发布
阅读量1.4k 收藏 7
点赞数 1
分类专栏： C/C++ 文章标签： 中缀表达式 后缀表达式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yb0022/article/details/96025932
版权

       算术表达式可以使用中缀表达式和后缀表达式（逆波兰表达式）计算，以下分别实现这两个方法，以下实现方法可以在算术表达式中包含部分函数，如三角函数sin等。

        由于普通的算术操作符（如“+-*/”）只包含一个字符，而函数会包含多个字符，为了方便先将函数用一个FunctionId的枚举替代，该枚举从1开始，算术表达式一般为明文字符串，这些枚举数只要使用20以下的数字就不会发生冲突，只是打印出来会是乱码，计算不会受影响。

enum FunctionId
{
	None = 0,
	Sin = 1,
	Cos = 2,
	Tan = 3,
	Cot = 4,
	FunctionMax,
};

         然后定义函数和运算符的结构FunctionInfo和OperatorInfo，以及一些全局变量和方法。


struct FunctionInfo
{
	FunctionId funcId;
	char funcStr[10];//函数名，如"sin"
	int bytesOfStr;//函数名字节数，如"sin"为3字节
	FunctionInfo(FunctionId InFuncId, const char* InFuncStr, int InBytes = 0)
	{
		funcId = InFuncId;
		memset(funcStr, 0, 10);
		bytesOfStr = InBytes > 0 ? InBytes : strlen(InFuncStr);
		memcpy(funcStr, InFuncStr, bytesOfStr);
	}
	static FunctionInfo None;
};
FunctionInfo FunctionInfo::None = FunctionInfo(FunctionId::None, "", 0);

FunctionInfo g_functionInfos[] =
{
	FunctionInfo(FunctionId::Sin,   "sin",   3),
	FunctionInfo(FunctionId::Cos,   "cos",  3),
	FunctionInfo(FunctionId::Tan,   "tan", 3),
	FunctionInfo(FunctionId::Cot,   "cot", 3),
	FunctionInfo::None
};
//判断是否是函数
FunctionInfo GetFunctionInfo(const char* InExp)
{
	for (int i = 0; i < FunctionId::FunctionMax; i++)
	{
		if (g_functionInfos->funcId == FunctionId::None)
		{
			return FunctionInfo::None;
		}
		if (memcmp(InExp, g_functionInfos[i].funcStr, g_functionInfos[i].bytesOfStr) == 0)
		{
			return g_functionInfos[i];
		}
	}
	return FunctionInfo::None;
}

struct OperatorInfo
{
	char ch;//运算符
	int priority;//优先级
	OperatorInfo(char InChar, int InPriority)
	{
		ch = InChar;
		priority = InPriority;
	}
};
OperatorInfo g_operatorInfos[] =
{
	OperatorInfo('(',   0),
	OperatorInfo(')',   0),
	OperatorInfo('+',   1),
	OperatorInfo('-',   1),
	OperatorInfo('*',   2),
	OperatorInfo('/',   2),
	OperatorInfo('%',   2),
	OperatorInfo('^',   3),
	OperatorInfo('\0',  -1)
};
//判断是否为操作符
bool IsOperator(char c)
{
	for (int i = 0;; i++)
	{
		if (g_operatorInfos[i].ch == c)
		{
			return true;
		}
		if (g_operatorInfos[i].ch == '\0')
		{
			return false;
		}
	}
	return false;
}
//获取操作符优先级
int GetPriority(char c)
{
	//函数优先级最高
	if (c > FunctionId::None && c < FunctionId::FunctionMax)
	{
		return 10;
	}
	for (int i = 0;; i++)
	{
		if (g_operatorInfos[i].ch == c)
		{
			return g_operatorInfos[i].priority;
		}
		if (g_operatorInfos[i].ch == '\0')
		{
			return -1;
		}
	}
	return -1;
}

bool IsNumber(char c)
{
	return c >= '0' && c <= '9';
}
//是否为数字，包括小数点
bool IsNumberOrDot(char c)
{
	return IsNumber(c) || (c == '.');
}

1、中缀表达式计算

      中缀表达式需要一个操作符栈和操作数栈，多个字符的函数被替换为一个字节存放到操作符栈中，判断时只需判断是否大于None且小于FunctionMax，计算值时操作数只有一个。


double CalcValueByInfixExpression(const char* expression)
{
	std::stack<char> operatorStack;//操作符栈，包括普通运算符和函数
	std::stack<double> dataStack;//操作数栈

	const char* iterExp = expression;
	if (*iterExp == '-')//判断第一个符号是否为'-'，如果是就按"0-..."处理
	{
		dataStack.push(0);
		operatorStack.push('-');
		iterExp++;
	}

	while (*iterExp != '\0')
	{
		if (*iterExp == ' ')
		{
			iterExp++;
			continue;
		}
		FunctionInfo funcInfo = GetFunctionInfo(iterExp);
		if (funcInfo.funcId > FunctionId::None)
		{
			//函数直接入栈
			operatorStack.push(funcInfo.funcId);
			iterExp += funcInfo.bytesOfStr;
		}
		else if (IsOperator(*iterExp))
		{
			char ch = *iterExp;
			if (ch == ')')
			{
				//遇到右括号，则弹出之前的运算符直到遇到左括号'('，并将计算数据保存到栈顶
				while (!operatorStack.empty() && operatorStack.top() != '(')
				{
					char topOper = operatorStack.top();
					if (topOper > FunctionId::None && topOper < FunctionId::FunctionMax)
					{
						//函数只有一个操作数，有多个操作数的函数不考虑
						double topData = dataStack.top();
						dataStack.top() = CalcFunctionValue(topData, (FunctionId)topOper);
					}
					else
					{
						//运算符有两个操作数，其他情况不考虑
						double rightData = dataStack.top();
						dataStack.pop();
						double leftData = dataStack.top();
						dataStack.top() = CalcOperatorValue(leftData, rightData, topOper);
					}
					operatorStack.pop();
				}
				operatorStack.pop();
				if (!operatorStack.empty())
				{
					char topOper = operatorStack.top();//函数后跟的都是'('，所以要判断一下下一个运算符是不是函数
					if (topOper > FunctionId::None && topOper < FunctionId::FunctionMax)
					{
						double topData = dataStack.top();
						dataStack.top() = CalcFunctionValue(topData, (FunctionId)topOper);
						operatorStack.pop();
					}
				}
			}
			else if (ch == '-' && *(iterExp - 1) == '(')
			{
				//'('后也可能跟负数，也当成"0-..."处理
				//不考虑'-'前有空格的情况，可提前将表达式的空格去掉
				dataStack.push(0);
				operatorStack.push('-');
			}
			else if (operatorStack.empty() || ch == '(' || GetPriority(ch) > GetPriority(operatorStack.top()))
			{
				//这三种情况直接将运算符入栈
				operatorStack.push(ch);
			}
			else
			{
				//优先级高于或等于ch优先级的出栈进行运算，最后将ch入栈
				while (!operatorStack.empty() && GetPriority(ch) <= GetPriority(operatorStack.top()))
				{
					char topOper = operatorStack.top();
					if (topOper > FunctionId::None && topOper < FunctionId::FunctionMax)
					{
						dataStack.top() = CalcFunctionValue(dataStack.top(), (FunctionId)topOper);
					}
					else
					{
						double rightData = dataStack.top();
						dataStack.pop();
						double leftData = dataStack.top();
						dataStack.top() = CalcOperatorValue(leftData, rightData, topOper);
					}
					operatorStack.pop();
				}
				operatorStack.push(ch);
			}
			iterExp++;
		}
		else if (IsNumberOrDot(*iterExp))
		{
			//操作数入栈
			char buf[20] = { 0 };
			char* iterDest = buf;
			while (IsNumberOrDot(*iterExp))
			{
				*iterDest++ = *iterExp++;
			}

			double opData = atof(buf);
			dataStack.push(opData);
		}
		else
		{
			return 0;//表达式有误
		}
	}

	//将操作符都出栈运算，这里不会有函数，因为函数后都跟'(',在'('出栈的时候已经计算了
	while (!operatorStack.empty())
	{
		double rightData = dataStack.top();
		dataStack.pop();
		double leftData = dataStack.top();
		dataStack.top() = CalcOperatorValue(leftData, rightData, operatorStack.top());
		operatorStack.pop();
	}
	return dataStack.top();
}

2、后缀表达式计算

      后缀表达式分为两步，先将中缀表达式转为后缀表达式，然后计算后缀表达式，运算符的处理上与中缀表达式有很多相似之处。


//InExpression为原表达式，OutSuffixExp为后缀表达式
bool ExpressionToSuffixExp(const char* InExpression, char* OutSuffixExp)
{
	std::stack<char> operatorStack;//操作符栈，包括普通运算符和函数
	const char* iterInfix = InExpression;
	char* iterSuffix = OutSuffixExp;
	if (*iterInfix == '-')//判断第一个符号是否为'-'，如果是就按"0-..."处理
	{
		*iterSuffix++ = '0';
		*iterSuffix++ = ' ';
		operatorStack.push('-');
		iterInfix++;
	}
	while (*iterInfix != '\0')
	{
		if (*iterInfix == ' ')
		{
			iterInfix++;
			continue;
		}
		FunctionInfo funcInfo = GetFunctionInfo(iterInfix);
		if (funcInfo.funcId > FunctionId::None)
		{
			operatorStack.push(funcInfo.funcId);
			iterInfix += funcInfo.bytesOfStr;
		}
		else if (IsOperator(*iterInfix))
		{
			char ch = *iterInfix;
			if (ch == ')')
			{
				//遇到右括号，则弹出之前的运算符直到遇到左括号'('，并将运算符加入到后缀表达式
				while (!operatorStack.empty() && operatorStack.top() != '(')
				{
					*iterSuffix++ = operatorStack.top();
					operatorStack.pop();
				}
				if (!operatorStack.empty())
				{
					operatorStack.pop();
				}
			}
			else if (ch == '-' && *(iterInfix - 1) == '(')
			{
				//'('后也可能跟负数，也当成"0-..."处理
				//不考虑'-'前有空格的情况，可提前将表达式的空格去掉
				*iterSuffix++ = '0';
				*iterSuffix++ = ' ';
				operatorStack.push('-');
			}
			else if (operatorStack.empty() || ch == '(' || GetPriority(ch) > GetPriority(operatorStack.top()))
			{
				//这三种情况直接将运算符入栈
				operatorStack.push(ch);
			}
			else
			{
				//优先级高于或等于ch优先级的出栈，并加入后缀表达式，最后将ch入栈
				while (!operatorStack.empty() && GetPriority(ch) <= GetPriority(operatorStack.top()))
				{
					*iterSuffix++ = operatorStack.top();
					operatorStack.pop();
				}
				operatorStack.push(ch);
			}
			iterInfix++;
		}
		else if (IsNumberOrDot(*iterInfix))
		{
			while (IsNumberOrDot(*iterInfix))
			{
				*iterSuffix++ = *iterInfix++;
			}
			*iterSuffix++ = ' ';//用空格分隔操作数
		}
		else
		{
			return false;//表达式有误
		}
	}
	//将剩余操作符出栈加入后缀表达式
	while (!operatorStack.empty())
	{
		*iterSuffix++ = operatorStack.top();
		operatorStack.pop();
	}
	*iterSuffix = '\0';
	return true;
}

double CalcSuffixValue(const char* InSuffixExp)
{
	std::stack<double> dataStack;//操作数栈
	const char* iterExp = InSuffixExp;
	while (*iterExp != '\0')
	{
		if (*iterExp == ' ')
		{
			iterExp++;
			continue;
		}
		//计算后缀表达式只需要区分操作数和操作符即可
		if (IsNumberOrDot(*iterExp))
		{
			int t = 0;
			char buf[20];
			while (IsNumberOrDot(*iterExp))
			{
				buf[t++] = *iterExp++;
			}
			buf[t] = '\0';
			double d = atof(buf);
			dataStack.push(d);
		}
		else
		{
			if (*iterExp > FunctionId::None && *iterExp < FunctionId::FunctionMax)
			{
				double topData = dataStack.top();
				dataStack.top() = CalcFunctionValue(topData, (FunctionId)* iterExp);
			}
			else
			{
				double rightData = dataStack.top();
				dataStack.pop();
				double leftData = dataStack.top();
				dataStack.top() = CalcOperatorValue(leftData, rightData, *iterExp);
			}
			iterExp++;
		}
	}
	if (dataStack.empty())
	{
		return 0;//表达式有误才会进到这里
	}
	return dataStack.top();
}

double CalcValueBySuffixExpression(const char* expression)
{
	//分两步，先转为后缀表达式，后计算表达式
	char suffixExp[100] = { 0 };
	ExpressionToSuffixExp(expression, suffixExp);
	return CalcSuffixValue(suffixExp);
}

       由于算术运算符手动输入，会有各种各样的形式，甚至是输入错误的表达式，这里还有很多特殊情况没有考虑到，只处理一些比较简单的情况。另外如果要添加其他函数需在枚举（FunctionId）、全局数组g_functionInfos以及函数CalcFunctionValue中增加相关代码。

       最后使用控制台程序测试。

int main()
{
	char expression[100];
	printf("请输入表达式：\n");
	gets_s(expression, 100);

	printf("表达式计算结果为：\n");

	printf("CalcValueByInfixExpression：%f\n", CalcValueByInfixExpression(expression));

	printf("CalcValueBySuffixExpression：%f\n", CalcValueBySuffixExpression(expression));
	system("pause");
	return  0;
}

       输出结果：

蓬 蒿 人
关注
  • 1
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
算术表达式
12-17
在计算机科学领域，算术表达式(Arithmetic Expression)是编程中的基本概念，它是由数字、运算符和括号组成的序列，用于表示数学计算。算术表达式求值是编程语言解释器或编译器的核心功能之一，它能将一个抽象的...
用栈实现算术表达式的计算
11-28
本话题将深入探讨如何利用栈来实现算术表达式的计算，特别是涉及到四则运算（加、减、乘、除）以及乘方（^）操作，并遵循运算符的优先级规则。 栈的基本操作包括压栈（Push）和弹栈（Pop）。在计算一个算术表达式时...
文件包含函数之间的区别
Yqz20030的博客
03-09 200
通过对文件包含漏洞的学习，发现对漏洞包含漏洞所使用的函数不太熟悉，因此进行一下整理。 第一次发表文章，还有许多地方需要学习和巩固，如有错误请多多担待。
php内置函数-文件包含的函数
最新发布
m0_60494863的博客
01-11 873
可以将别的文件直接引用过来（被引用的文件含有打印代码的话，会直接打印），如果失败了，会返回一条警告，文件会继续执行下去，通常用于动态包含。如下，我建两个 php 文件，一个写有函数声明的文件，一个函数调用的文件所以被引用的文件一般不写打印的代码，直接写函数声明即可include 引用失败的话，会返回警告，并继续执行下去，如下function.php 文件引用成功情况下引用失败（将路径写错）情况下。
文件包含常用函数
weixin_53303754的博客
10-15 327
include()、require()、include_once()、require_once()、fopen()、readfile()
函数声明与函数表达式
雪雷-的专栏
10-19 408
函数声明与函数表达式函数声明：function 函数名称 (参数：可选){ 函数体 }函数表达式：function 函数名称（可选）(参数：可选){ 函数体 }如何辨别不包含函数名为函数表达式，如果包含，参见下文函数声明：1. function foo(){} // 声明，因为它是程序的一部分 2. (function(){ function bar(){} // 声明，因为它是函数体的一
第七章、函数表达式
DreamFive
02-28 348
函数表达式有两种：函数声明和函数表达式。函数声明：1、我们常用的function functionName( 参数1,参数2 ){   }。                 2、先声明一个在执行代码前先声明一个函数，                       sayHi（）；                       function sayHi（）{  }函数表达式：var function...
Java算术表达式计算类库 ExpressionJ
06-02
**Java算术表达式计算类库 ExpressionJ** ExpressionJ是一个强大的Java库，专门设计用于解析和计算数学算术表达式。这个库对于那些在应用程序中需要动态计算复杂数学表达式的开发者来说，是一个非常有用的工具。它...
数据结构算术表达式求解.doc
07-06
该课程设计的目标是实现一个能处理算术表达式的系统，它能够正确识别和计算包含加、减、乘、除等基本运算符的表达式，同时处理括号以确保正确的运算顺序。系统应能处理错误情况，并给出相应的错误提示。 1.2 选题...
C++算术表达式
12-21
11. **表达式求值**：C++编译器会根据运算符的优先级和结合性，以及函数调用等规则来解析和求值算术表达式。在复杂表达式中，了解这些规则对于正确编写和理解代码至关重要。 以上是对"C++算术表达式"这个主题的一些...
oracle中基本函数
01-30
oracle中基本函数，包含字符函数、数值函数、日期函数等
oracle的包含函数
清水的专栏
09-22 6008
instr(a.coloum,'1') > 0，大于0说明包含1，等于0说明不包含1
【C】结构体中包含函数
热门推荐
编程记录，亲测有效
12-22 2万+
在《【C】Malloc与结构体，其实就是C语言里面的new和类》（点击打开链接）提到，C语言结构体里面也可以包含函数，如同类中有方法一样，但是不能通过直接放过一个函数进去，需要通过函数指针的方式，同时，关于类的构造函数与析构函数C语言表示是没有的，需要你自己手动解决这些问题。 下面讲讲如何在C语言中的结构体包含函数。 如下的一段代码： #include #include using name
运算符与表达式
matrix_xiaobai的博客
03-27 904
C语言运算符与表达式 算术运算符与算数表达式 操作数为数字类型或算术类型 + 加 - 减 * 乘 / 除 % 取模 ++（--） 自加（自减) 赋值运算符与赋值表达式 关系运算符与关系表达式 逻辑运算符与逻辑表达式 ...
C++编程常用头文件及其包含函数汇总
汉南最後の読書人
08-28 7223
1. #include是标准的C++头文件，任何符合标准的C++开发环境都有这个头文件。 当使用时，相当于在c中调用库函数，使用的是全局命名空间，也就是早期的c++实现；当使用的时候，该头文件没有定义全局命名空间，必须使用namespace std；这样才能正确使用cout。   2.#include 是C++里面的一个常用函数库， 等价于C中的stdlib.h>       所包
最常用标准库函数
ACM！荣耀之路！
01-10 3380
最常用标准库函数 标准头文件包括：                                                                          标准定义（） 文件里包含了标准库的一些常用定义，无论我们包含哪个标准头文件，都会被自动包含进来。这个文件里定义：          类型size_t（sizeof运算符的结果类型，是某个无符号整
mysql 中的包含函数
不以人人的意志为转义乃天道
10-12 2842
SELECT * FROM `send_order` WHERE waybill_no SELECT waybill_no FROM `send_order` SELECT waybill_no FROM send_order WHERE INSTR(waybill_no ,'zjs')=0 INSTR 雷同于 包含返回的是所在的位置 DELETE FROM s...
计算表达式的函数
w_dexu的博客
08-06 764
计算表达式的函数 为了能够接受用户以表达式的形式输入的数据，今天给出两个函数，可以解决这个问题。思路是先将表达式中可能存在的双角字符代替成半角字符，再调用系统的表达式计算函数做计算，以下两个函数可以自行试用。 Function JS(表达式 As String) 表达式 = Replace(表达式, "＋", "+") 表达式 = Replace(表达式, "－", "-") 表达式 = Replace(表达式, "×", "*") 表达式 = Replace(表达式, "÷
算术表达式求值的C语言程序使用递归函数
05-19
以下是一个使用递归函数计算算术表达式的示例程序： ```c #include <stdio.h> // 函数声明 int calc(char *); int main() { char expr[100]; printf("请输入算术表达式（仅包含+、-、*、/和数字）：\n"); scanf("%s", expr); int result = calc(expr); printf("结果为：%d\n", result); return 0; } // 递归函数计算算术表达式 int calc(char *expr) { static int pos = 0; // 记录当前处理的位置 int num1, num2; char op; num1 = 0; // 处理第一个数字 while (expr[pos] >= '0' && expr[pos] <= '9') { num1 = num1 * 10 + (expr[pos] - '0'); pos++; } // 处理运算符和第二个数字 op = expr[pos]; pos++; if (op == '+') { num2 = calc(expr); return num1 + num2; } else if (op == '-') { num2 = calc(expr); return num1 - num2; } else if (op == '*') { num2 = calc(expr); return num1 * num2; } else if (op == '/') { num2 = calc(expr); return num1 / num2; } else { return num1; } } ``` 该程序首先从用户输入中读取算术表达式，然后将其传递给 `calc` 函数。`calc` 函数使用一个静态变量 `pos` 来记录当前处理的位置。在每次递归调用中，先处理第一个数字，然后处理运算符和第二个数字。如果运算符是加、减、乘、除中的一种，则递归调用 `calc` 函数来计算第二个数字，最后返回运算结果。如果运算符是空格，则表示表达式已经被完全处理完毕，直接返回第一个数字。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值