使用栈计算中缀表达式（实现计算器功能）

最近学习数据结构与算法中栈的部分，跟着小甲鱼的视频教程一步一步学习，并把部分问题自己写代码巩固一遍，分享在博客上一方面是记录自己的学习过程，另一方面也是经常在网上查看别人写的博客解决问题，自己也应该像他们学习，如果自己写的内容可以帮助到他人那再好不过了。
回归正题，关于栈实现计算器功能，也就是键盘输入(1.2+3)(4-5.5)，就可以得到-6.3，这里面涉及到了中缀表达式(1.2+3)(4-5.5)转换为后缀表达式1.2 3 + 4 5.5 - *，并且通过后缀表达式计算结果的过程，具体原理可以参考小甲鱼的视频链接中p27 28 29部分，他是用C语言实现的，我这里使用的是C++，最终的版本我也只是测试了一下正确性，并没有去比对和他的方方法一样，下面给出代码部分：
这是一些关于头文件和栈处理的函数：

#include <stdio.h>
#include <stdlib.h>
#include <iostream>
#include <ctype.h>
using namespace std;

const int stackMaxLen = 10;

template<class T>
struct Stack
{
	int stacklen;
	T *base;
	T *top;
};

enum STATE
{
	SUCCESS,
	ERROR,
};

template<class T>
Stack<T>* CreatStack()
{
	Stack<T>* p = new Stack<T>;
	p->base = new T[stackMaxLen];
	p->top = p->base;
	p->stacklen = stackMaxLen;
	return p;
}

template<class T>
void DeleteStack(Stack<T>* p)
{
	delete[] p->base;
	if (p)
		delete p;
}

template<class T>
int GetStackFree(Stack<T>* p)
{
	return p->stacklen - (p->top - p->base);
}

template<class T>
void AppendStack(Stack<T>* p)
{
	//长度为0，开辟新空间
	int newlen = p->stacklen + stackMaxLen;
	T *temp = new T[newlen];
	memcpy(temp, p->base, sizeof(T)* p->stacklen);
	//释放掉以前的栈
	delete[] p->base;

	p->base = temp;
	p->top = p->base + p->stacklen;
	p->stacklen = newlen;
}

template<class T>
void Push(Stack<T>* p, T data)
{
	if (GetStackFree(p) == 0)
	{
		AppendStack(p);
	}
	else
	{
		*p->top = data;
		p->top++;
	}
}

template<class T>
STATE Pop(Stack<T>* p, T& data)
{
	if (p->top == p->base)
		return ERROR;
	else
	{
		data = *--p->top;
		return SUCCESS;
	}
}

使用了函数模板 ，是因为我在后面分别用的了char的栈和double的栈，当然这里可能把这些函数都封装为类应该更好一些。但是我太懒了，就没弄了~~~。
下面是通过中缀表达式得到后缀表达式的函数，这里我将后缀表达式存到一个char数组里的，每个变量用空格隔开的：

char* GetNifixExp()
{
	cout << "请输入中缀表达式，并以＃号键结束:" << endl;
	Stack<char> *symbolStack = CreatStack<char>();
	char c;
	char *nifixExp = new char[30];
	memset(nifixExp, 0, sizeof(char) * 30);
	int nifixIdx = 0;
	scanf("%c", &c);
	while (c != '#')
	{
		if (c == '+' || c == '-' || c == '/' || c == '*' || c == '(' || c == ')')
		{
			if (c == ')')
			{
				nifixExp[nifixIdx++] = ' ';
				while (Pop(symbolStack, c) == SUCCESS)
				{
					if (c == '(')
					{
						break;
					}
					nifixExp[nifixIdx++] = c;
					nifixExp[nifixIdx++] = ' ';
				}
			}
			else if (c == '+' || c == '-')
			{
				nifixExp[nifixIdx++] = ' ';
				char after;
				if (Pop(symbolStack, after) == SUCCESS)
				{
					if (after == '*' || after == '/')
					{
						nifixExp[nifixIdx++] = after;
						nifixExp[nifixIdx++] = ' ';
						char afterMulti;
						while (Pop(symbolStack, afterMulti) == SUCCESS)
						{
							nifixExp[nifixIdx++] = afterMulti;
							nifixExp[nifixIdx++] = ' ';
						}
					}
					else
					{
						Push(symbolStack, after);
					}
				}
				Push(symbolStack, c);
			}
			else
			{
				if(c == '*' || c == '/')
					nifixExp[nifixIdx++] = ' ';
				Push(symbolStack, c);
			}

		}
		else if (c >= '0' && c <= '9' || c == '.')
		{
			nifixExp[nifixIdx++] = c;
		}
		scanf("%c", &c);
	}
	while (Pop(symbolStack, c) == SUCCESS)
	{
		nifixExp[nifixIdx++] = ' ';
		nifixExp[nifixIdx++] = c;
	}
	DeleteStack(symbolStack);
	getchar();
	return nifixExp;
}

下面是通过栈计算后缀表达式：

double CalcNifixExp(char* nifixExp)
{
	Stack<double> *p = CreatStack<double>();
	char c;
	char g_c[10];
	int i = 0;
	c = *nifixExp++;
	double pre, aft;
	while (c != '\0')
	{
		while (c > '0' && c < '9' || c == '.')
		{
			g_c[i++] = c;
			g_c[i] = '\n';
			c = *nifixExp++;
			if (i > 10 || c == ' ')
			{
				double f = atof(g_c);
				Push(p, atof(g_c));
				i = 0;
				break;
			}

		}

		switch (c)
		{
		case '+':
			Pop(p, aft);
			Pop(p, pre);
			Push(p, pre + aft);
			break;
		case '-':
			Pop(p, aft);
			Pop(p, pre);
			Push(p, pre - aft);
			break;
		case '*':
			Pop(p, aft);
			Pop(p, pre);
			Push(p, pre * aft);
			break;
		case '/':
			Pop(p, aft);
			Pop(p, pre);
			if (aft == 0)
			{
				cout << "除数不能为0" << endl;
				break;
			}
			Push(p, pre / aft);
			break;
		default:
			break;
		}

		c = *nifixExp++;
	}
	Pop(p, aft);
	DeleteStack(p);

	return aft;
}

最后是主函数：

int main()
{
	char* nifixExp = GetNifixExp();
	cout << "后缀表达式为：" << nifixExp << endl;

	double result = CalcNifixExp(nifixExp);
	cout << "计算结果是：" << result << endl;

	delete[] nifixExp;
	system("pause");
	return 0;
}

当然这里只是最简单的计算器功能，并没有去做一些异常的处理，如果有什么bug，欢迎大家指出。