简单操作数运算

#include "stdio.h"
#include <conio.h>
#include <iostream>
const int Maxsize = 100;//
#define TRUE 1
#define FALSE 0
#define Stack_Size 50
#include <iostream>
using namespace std;
/*int栈*/
typedef struct
{
	int elem[Stack_Size]; /*用来存放栈中元素的一维数组*/
	int top;          		/*用来存放栈顶元素的下标，top为-1表示空栈*/
}IntStack;


/*char栈*/
typedef struct
{
	char elem[Stack_Size]; /*用来存放栈中元素的一维数组*/
	int top;          		/*用来存放栈顶元素的下标，top为-1表示空栈*/
}CharStack;

/*初始化int栈*/
void InitStack(IntStack *S)
{
	S = (IntStack*)malloc(sizeof(IntStack));
	S->top = -1;
}
/*初始化char栈*/
void InitStack(CharStack *S)
{
	S = (CharStack*)malloc(sizeof(CharStack));
	S->top = -1;
}
/*判栈空*/
int IsEmpty(IntStack *S) /*判断栈S为空栈时返回值为真，反之为假*/
{
	return(S->top == -1 ? TRUE : FALSE);
}
/*判栈空*/
int IsEmpty(CharStack *S) /*判断栈S为空栈时返回值为真，反之为假*/
{
	return(S->top == -1 ? TRUE : FALSE);
}

/*判栈满*/
int IsFull(IntStack *S)	/*判断栈S为满栈时返回值为真，反之为假*/
{
	return(S->top == Stack_Size - 1 ? TRUE : FALSE);
}
/*判栈满*/
int IsFull(CharStack *S)	/*判断栈S为满栈时返回值为真，反之为假*/
{
	return(S->top == Stack_Size - 1 ? TRUE : FALSE);
}
/*进栈*/
int Push(CharStack *S, char x)
{
	if (S->top == Stack_Size - 1)
		return(FALSE);  /*栈已满*/
	S->top++;
	S->elem[S->top] = x;
	return(TRUE);
}
/*进栈*/
int Push(IntStack *S, int x)
{
	if (S->top == Stack_Size - 1)
		return(FALSE);  /*栈已满*/
	S->top++;
	S->elem[S->top] = x;
	return(TRUE);
}
/*出栈*/
int Pop(IntStack *S, int *x)
{
	/* 将栈S的栈顶元素弹出，放到x所指的存储空间中 */
	if (S->top == -1)  /*栈为空*/
		return(FALSE);
	else
	{
		*x = S->elem[S->top];
		S->top--;    /* 修改栈顶指针 */
		return(TRUE);
	}
}
/*出栈*/
int Pop(CharStack *S, char *x)
{
	/* 将栈S的栈顶元素弹出，放到x所指的存储空间中 */
	if (S->top == -1)  /*栈为空*/
		return(FALSE);
	else
	{
		*x = S->elem[S->top];
		S->top--;    /* 修改栈顶指针 */
		return(TRUE);
	}
}

/*取栈顶元素。*/
int GetTop(IntStack *S, int *x)
{
	/* 将栈S的栈顶元素弹出，放到x所指的存储空间中，但栈顶指针保持不变 */
	if (S->top == -1)  /*栈为空*/
		return(FALSE);
	else
	{
		*x = S->elem[S->top];
		return(TRUE);
	}
}
/*取栈顶元素。*/
int GetTop(CharStack *S, char *x)
{
	/* 将栈S的栈顶元素弹出，放到x所指的存储空间中，但栈顶指针保持不变 */
	if (S->top == -1)  /*栈为空*/
		return(FALSE);
	else
	{
		*x = S->elem[S->top];
		return(TRUE);
	}
}


char oper[5][5] = { { '>','>','<','<','>' },
					{ '>','>','<','<','>' },
					{ '>','>','>','>','>' },
					{ '>','>','>','>','>' },
					{ '<','<','<','<','=' }};
char ch, x;
int IsNum(char ch);
char Execute(char data1, char op, char data2);
char Compare(char topsign, char ch);
int ExpEvaluation()
{
	char a, b, op, result;
	CharStack operatdata, operatsign;
	char topsign;
	InitStack(&operatdata);
	InitStack(&operatsign);
	Push(&operatsign, '#');
	cout<<"\nplease input an expression(Ending with #):";
	ch = getchar();
	ch = getchar();
	GetTop(&operatdata, &topsign);
	while (ch != '#' || topsign != '#')
	{
		if (IsNum(ch) == 1)
		{
			Push(&operatdata, ch - '0');
			ch = getchar();
		}
		else {
			switch (Compare(topsign, ch)) {
			case'<':
				Push(&operatsign, ch);
				ch = getchar();
				break;
			case'>':	
				Pop(&operatsign, &op);
				Pop(&operatdata, &b);
				Pop(&operatdata, &a);
				result = Execute(a, op, b);
				Push(&operatdata, result);
				break;
			}
		}
		GetTop(&operatdata, &topsign);
	}
	GetTop(&operatdata, &result);
	return((int)result);
}

int main()
{
	int result;
	char str[Maxsize];
	while (1)  
	{
		printf("please input your expression:");
		cin >> str;
		result = ExpEvaluation();
		cout << str << "=" << result;
	}
	return 0;
}

int IsNum(char ch)
{
	if (ch >= '0'&&ch <= '9')
		return 1;
	else
		return 0;
}


char  Execute(char data1, char op, char data2)
{
	switch (op)
	{
		case '+': return (char((int) data1 + (int) data2));
		case '-': return (char((int)data1 - (int)data2));
		case '*': return (char((int)data1 * (int)data2));
		case '/': return (char((int)data1 / (int)data2));
	}

}


char Compare(char op1, char op2)
{
	int i, j;
	switch (op1) {
		case'+':i = 0; break;
		case'-':i = 1; break;
		case'*':i = 2; break;
		case'/':i = 3; break;
		case'#':i = 4; break;
	}
	switch (op2) {
		case'+':j = 0; break;
		case'-':j = 1; break;
		case'*':j = 2; break;
		case'/':j = 3; break;
		case'#':j = 4; break;
	}
	return oper[i][j];
}