中缀表达式转后缀表达式并求值

1、缺点代码中缺少一个函数来判断输入的左右括号是否匹配
2、其中中缀后缀中使用了两次栈（由于栈只能后进先出，得出来的是逆序，再用一遍将逆序转成顺序）这种由于逆序而使用两次栈的地方有两处。如果使用队列，就不必使用两次了。
需求分析 ：输入中缀表达式后，需要变成后缀表达式，然后运算求值。
输入形式、输入值的范围；输入一个数学公式，且只能是十进制的数。可以是小数，也可以是一位数、二位数、三位数等多位整数。公式最后必须以“=”结尾。运算功能包括加、减、乘、除、幂运算、取余运算、带括号运算等。
输出形式；输出double型的运算结果（根据需要，也可以输出后缀表达式和每一步的运算步骤）。
程序功能； 将输入的中缀表达式，变成后缀表达式，然后运算求值。
测试数据（包括正确的输入和输出、错误的输入和输出）
正确：
输入：-2+(2^2+6*2-10)+{7+(3+8%3)}+[3+(2-1)]+1.1=
输出：21.1
错误：
输入：3()0=
输出：前面是数字，后面是括号，表达式输入错误!
不能输入两次操作符
可以输出结果
栈为空，不能读取栈顶元素
0
错误：
输入：=23=
输出：直接输入等号错误
可以输出结果
栈为空，不能读取栈顶元素
0
错误：
输入：3++3=
输出：输入不合法！
0:+
1:3
栈为空，不能读取栈顶元素
0没有操作数了
栈为空，不能删除
可以输出结果
栈为空，不能读取栈顶元素
0
错误：
输入：rt+3=
输出：输入不合法！
r
可以输出结果
栈为空，不能读取栈顶元素
0
输入：1/0=
输出：被除数不能是0！运算错误
栈为空，不能删除
可以输出结果
0

#include<iostream>
#include<stack>
#include<string>
#include<math.h>//卷狗才加三角函数、开方的运算……
using namespace std;
//用来存放符号和数字

class Superdigit
{
   
public:
	Superdigit();
	Superdigit(char op);
	Superdigit(double num);
	~Superdigit();
	int so = 0;
	Superdigit* next;
	char digitOp;
	double digitNum;
};
Superdigit::Superdigit()
{
   
	digitOp = 0;
	digitNum = 0;
	next = NULL;
}
Superdigit::Superdigit(char op)
{
   
	digitOp = op;
	digitNum = 0;
	//so=1，表示运算符，so=3表示左括号，s0=4表示右括号
	if (op == '+' || op == '-' || op == '*' || op == '/' || op == '^' || op == '%')
	{
   
		so = 1;
	}
	else if (op == '(' || op == '[' || op == '{')
	{
   

		so = 3;
	}
	else
	{
   
		so = 4;
	}
	next = NULL;
}
Superdigit::Superdigit(double num)
{
   
	digitOp = 0;
	digitNum = num;
	so = 2;
	next = NULL;
}
Superdigit::~Superdigit()
{
   

}
//超级栈，用来存Superdigit
class SuperStack
{
   
public:
	SuperStack();
	~SuperStack();
	bool push(const Superdigit obj);//入栈
	bool pop();//出栈
	Superdigit top();//查找栈顶元素
	void clear();//清空函数
	int GetSize();//获得栈的长度
private:
	Superdigit* Top;//指向栈顶的指针
	//SuperStack* Next;
	int size;//存放元素的个数
};

SuperStack::SuperStack()
{
   
	Top = new Superdigit();

	size = 0;
}

SuperStack::~SuperStack()
{
   
	//cout << "此处调用析构" << endl;
	clear();
}
void SuperStack::clear() {
   
	//cout << "此处调用clear()" << endl;
	int ClearNum = size;
	for (int i = 0; i < ClearNum; i++)
	{
   
		
		Superdigit* temp;
		temp = Top;
		Top = Top->next;
		delete temp;
		size--;
	}
	//Top->next = NULL;
	size = 0;
}

bool SuperStack::push(const Superdigit obj) {
   
	if (size == 0)//说明是空栈，需要对最后一个节点重新赋值
	{
   
		if (Top==NULL)
		{
   
			Top= new Superdigit();
		}
		//cout << "此处调用push1()" << endl;
		Top->digitNum = obj.digitNum;
		Top->digitOp = obj.digitOp;
		Top->so = obj.so;
		Top->next = NULL;

		size++;
	}
	else {
   
		//cout << "此处调用push2()" << endl;
		Superdigit* temp = new Superdigit();
		temp->digitNum = obj.digitNum;
		temp->digitOp = obj.digitOp;
		temp->so = obj.so;
		temp->next = Top;
		Top = temp;
		size++;
	}

	return true;
}
bool SuperStack::pop() {
   
	//cout << "此处调用pop()" << endl;
	if (size == 0)
	{
   
		cout << "栈为空，不能删除" << endl;
		return false;
	}
	else
	{
   
		Superdigit* temp;
		temp = Top->next;
		delete Top;
		Top = temp;
		size--;
		return true;
	}


}
Superdigit SuperStack::top() {
   
	//cout << "此处调用top()" << endl;
	if (size == 0)
	{
   
		cout << "栈为空，不能读取栈顶元素" << endl;
		Superdigit gog;


		return gog;
	}
	else
	{
   
		Superdigit gog;
		gog.digitNum = Top->digitNum;
		gog.digitOp = Top->digitOp