C/C++利用双栈实现算术表达式计算

//利用栈来计算算术表达式的值
//预编译区::
#pragma once
#include "stdafx.h"
#include<stdio.h>
#include<iostream>
#include<string>
#define TRUE 1
#define FALSE 0
#define OVERFLOW -1
#define UNDERFLOW -2
#define OK 1
#define ERROR 0
#define STACK_INIT_SIZE 7
#define STACKINCREMENT 10
using namespace std;

//数据结构声明区::
//创建存放操作数的栈
typedef struct {
	int *base;
	int *top;
	int StackSize;
}OperandStack;

//创建存放运算符的栈
typedef struct {
	char *base;
	char *top;
	int StackSize;
}OperatorStack;

//创建判断运算符优先级数据结构
typedef struct {
	char ch;		//运算符
	int level;		//运算符优先等级
}Operator_prior;

//构建运算符间的优先关系
unsigned char Prior[7][7] = { 
	'>','>','<','<','<','>','>',
	'>','>','<','<','<','>','>',
	'>','>','>','>','<','>','>',
	'>','>','>','>','<','>','>',
	'<','<','<','<','<','=',' ',
	'>','>','>','>',' ','>','>',
	'<','<','<','<','<',' ','='
};

//构建运算符序列
char OP[7] = { '+','-','*','/','(',')','#' };

typedef int status;

//函数声明区：
template <class T1, class T2> void Push_Stack(T1 &S, T2 e);
template <class T1, class T2> status Init_Stack(T1 &S, T2 e = 0);
template<class T1, class T2> void Pop_Stack(T1 &S, T2 &e);
template<class T1, class T2> T2 GetTop_Stack(T1 &S, T2 &e = 0);
status Judge(char c);
int ReturnOrder(char op, char *TempOp);
char Precede(char top, char ch);
int Operate(int a, char theta, int b);
int EvaluateExpression(OperandStack &OPND, OperatorStack &OPTR);

//主函数区::
int main()
{
	double temp;
	OperandStack OPND;
	OperatorStack OPTR;
	temp=EvaluateExpression(OPND, OPTR);
	printf("计算结果为结果::%lf", temp);
	printf("\n");
	system("pause");
	return 0;
}

//初始化栈算法模板
template <class T1,class T2>		//T1:栈的数据类型，T2:栈中元素的数据类型
status Init_Stack(T1 &S,T2 e=0) {		//e是用来传递数据类型的
	S.base = (T2*)malloc(STACK_INIT_SIZE * sizeof(T2));		//分配空间
	if (!S.base) exit(OVERFLOW);		//如果没有分配成功则退出
	S.top = S.base;		//初始化栈时栈顶和栈底指针两者指向同一位置
	S.StackSize = STACK_INIT_SIZE;
	return OK;
}

//压栈算法模板
template<class T1,class T2>
void Push_Stack(T1 &S, T2 e) {
	if (S.top - S.base >= S.StackSize) {
		S.base = (T2*)realloc(S.base, (STACK_INIT_SIZE + STACKINCREMENT) * sizeof(T2));		//如果栈满，则重新分配空间
		if (!S.base) exit(OVERFLOW);
		S.top = S.base + S.StackSize;
		S.StackSize += STACKINCREMENT;
	}
	*S.top++ =e;		//压入新元素之后将栈顶指针向上移动一个位置
	return;
}

//出栈算法模板
template<class T1,class T2>
void Pop_Stack(T1 &S, T2 &e) {
	if (S.top == S.base) exit(0);		//如果为空栈则退出
	e = *(--S.top);		//取出栈顶元素，并将指针指向该元素
	return;
}

//取出栈顶元素算法模板
template<class T1,class T2>
T2 GetTop_Stack(T1 &S,T2 &e=0){
	if(S.top==S.base) exit(0);
	e = *(S.top - 1);		//取出栈顶元素
	return e;
}

//判断当前字符是操作数还是运算符
status Judge(char c){
	if (48 <= c&&c <= 57) return OK;		//如果是数字就返回OK
	else return ERROR;
}

//比较OPTR栈顶元素与当前元素的运算符优先级算法
//查找两个运算符在运算符优先级表中的横、纵坐标
int ReturnOrder(char op, char *TempOp) {
	int i;
	for (i = 0; i <= 6; i++) {
		if (op == TempOp[i]) return i;
	}
	return 0;
}

//判断操作符栈栈顶元素和当前操作符优先级关系
char Precede(char top,char ch){
	return Prior[ReturnOrder(top, OP)][ReturnOrder(ch, OP)];
}

//当栈顶元素与当前元素满足">"关系时，进行相应运算符的运算
int Operate(int a, char theta, int b) {
	switch (theta) {
		case'+':return a + b;
		case'-':return a - b;
		case'*':return a*b;
		case'/':return a / b;
	}
}

//算术表达式的算符优先算法
int EvaluateExpression(OperandStack &OPND, OperatorStack &OPTR) {
	int step=1;
	int a,b,e=0/*最后返回的操作数栈顶元素*/,temp;
	char c,e1='0'/*OPTR栈顶元素*/,theta;
	if (!Init_Stack<OperatorStack, char>(OPTR)) exit(OVERFLOW);
	if(!Init_Stack<OperandStack,int>(OPND)) exit(OVERFLOW);
	printf("请输入一个算术表达式::");
	c = getchar();
	printf("\n操作步骤如下::\n");
	Push_Stack<OperatorStack, char>(OPTR, c);
	printf("第%d步::'%c'-->OPTR栈\n", step,c);
	c = getchar();
	while (c != '#' || GetTop_Stack<OperatorStack, char>(OPTR, e1) != '#'){
		if (Judge(c)) {
			step++;
			temp = atoi(&c);
			Push_Stack<OperandStack, int>(OPND,temp);
			printf("第%d步::'%c'-->OPND栈\n",step,c);
			c = getchar();
		}
		else {
			switch (Precede(e1=GetTop_Stack(OPTR,e1), c)) {
			case'<':
				step++;
				printf("第%d步::【prior('%c')<prior('%c')】  '%c'-->OPTR栈\n", step,e1= GetTop_Stack(OPTR, e1), c, c);
				Push_Stack<OperatorStack, char>(OPTR, c);
				c = getchar(); 
				break;
			case'=':
				step++;
				printf("第%d步::【prior('%c')=prior('%c')】  '%c'出OPTR栈\n", step, e1 = GetTop_Stack(OPTR, e1), c, e1);
				Pop_Stack<OperatorStack, char>(OPTR, e1);
				c = getchar(); 
				break;
			case'>':
				step++;
				printf("第%d步::【prior('%c')>prior('%c')】\n",step,e1= GetTop_Stack(OPTR, e1), c);
				Pop_Stack<OperatorStack, char>(OPTR,theta);
				printf("①'%c'出OPTR栈\n", theta);
				Pop_Stack<OperandStack, int>(OPND, b);
				Pop_Stack<OperandStack, int>(OPND, a);
				printf("②'%d'、'%d'出OPND栈\n",b, a);
				temp = Operate(a, theta, b);
				printf("③操作数运算  %d %c %d=%d\n", a, theta, b, temp);
				Push_Stack<OperandStack, int>(OPND,temp);
				printf("④'%d'-->OPND栈\n",temp);
				break;
			}
		}
	} 
	return e=GetTop_Stack<OperandStack,int>(OPND,e);
}