數學表示式的計算

#pragma once
#include <stack>
#include <deque>
using namespace std;


typedef struct {
	double opnd;  //運算元
	char optr;       //運算子
}Item;

const int COUNTS =6 ;             //“+-*/（）”一共六個運算子，照抄書上的優先順序表格(沒有用到'#')
const char PRECEDE[COUNTS][COUNTS] = {
	{ '>', '>' ,'<' ,'<' ,'<','>'},
	{ '>','>','<','<','<' ,'>',},
	{ '>','>','>', '>', '<', '>' },
	{ '>','>','>','>', '<','>'},
	{ '<', '<', '<', '<', '<', '='},
	{ '>', '>', '>', '>', '!', '>'},
};

double Value(double a, char optr, double b);       
char Precede(char optr1, char optr2);
double EvaluateExpression(stack<Item> & stackExpression, deque<Item> dequeExpression, const char * ptrExpression);
 

#include <regex>
#include <string>
#include <stack>
#include <deque>
#include"regular expression.h"
using namespace std;
 
double EvaluateExpression(stack<Item> & stackExpression, deque<Item> dequeExpression, const char * ptrExpression)
{
	int nLength;          //表示式長度
	double opnd1, opnd2;    //兩個double型別的數
	Item item;                      //Item型別物件
	const char * ptrAnalyze;
	string strToptr;
	regex rx("\\d+\\.?\\d*");                //正則表示式
	cmatch mr;                              //match_result<const char*>物件

	nLength = strlen(ptrExpression);

	for (ptrAnalyze = ptrExpression; ptrAnalyze < ptrExpression + nLength; )    
	{
		if (strchr("+-*/()", *ptrAnalyze) == nullptr)       //不是運算
		{                                                                          
			regex_search(ptrAnalyze, mr, rx);                     //使用正則表示式找出第一個數字
			ptrAnalyze += mr.length();                               //ptrAnalyze越過這個數字
			strToptr = mr.str();
			dequeExpression.push_back({ atof(strToptr.c_str()),'\0' })；//atof()將字串轉化為浮點數，將數字放入佇列最後
		}
		else                //是運算子
		{
			if (stackExpression.empty())     //棧為空，直接把運算子放入棧
			{
				stackExpression.push({ 0.0,*ptrAnalyze });
				ptrAnalyze++;     //越過這個運算子
			}
			else
			{
				item = stackExpression.top();           //提取棧頂的運算子
				switch (Precede(item.optr, *ptrAnalyze))    //和棧頂運算子比較優先順序
				{
				case '<':
					stackExpression.push({ 0.0,*ptrAnalyze });        //優先順序小就入棧
					ptrAnalyze++;                 //越過這個運算子
					break;
				case '=':
					stackExpression.pop(); //相等就使棧頂元素退棧( 其實就是當 '(' 和 ')' 相遇的時候，將一對括號都拋棄)
					ptrAnalyze++;
					break;
				case '>':
					item = stackExpression.top();         //優先順序比棧頂的運算子高，就使棧頂運算子退棧並放入佇列最後
					dequeExpression.push_back(item);
					stackExpression.pop();
					break;       //注意ptrAnalyze沒有自增，依然指向此運算子，直到比較結果為'<'或'='此運算子才被處理
				default:
					break;
				}
			}
		}
	}
	while (!stackExpression.empty())       //將棧中剩餘的運算子依次取出放入佇列最後
	{
		item = stackExpression.top();
		dequeExpression.push_back(item);
		stackExpression.pop();
	}

	while (!dequeExpression.empty())                //將佇列中的元素從頭部依次放入棧中
	{
		item = dequeExpression.front();
		if (item.optr)                                       //如果是運算子，判斷是幾元運算子，取棧頂元素進行計算，結果放入棧頂
		{
			opnd2 = stackExpression.top().opnd;
			stackExpression.pop();
			opnd1 = stackExpression.top().opnd;
			stackExpression.pop();
			stackExpression.push({ Value(opnd1,item.optr,opnd2),'\0' });
			dequeExpression.pop_front();
			continue;
		}
		stackExpression.push(item);         //如果不是運算子，就將運算元放入棧頂
		dequeExpression.pop_front();
	}

	return stackExpression.top().opnd;
}

char Precede(char optr1, char optr2)   //判斷運算子優先順序
{
	int i, n;

	switch (optr1)
	{
	case '+':i = 0;break;
	case '-':i = 1;break;
	case '*':i = 2;break;
	case '/':i = 3;break;
	case '(':i = 4;break;
	case ')':i = 5;break;
	default:
		break;
	}

	switch (optr2)
	{
	case '+':n = 0;break;
	case '-':n = 1;break;
	case '*':n = 2;break;
	case '/':n = 3;break;
	case '(':n = 4;break;
	case ')':n = 5;break;
	default:
		break;
	}
	return PRECEDE[i][n];     //標頭檔案二維char陣列
}

double Value(double a, char optr, double b)   //二元操作符的運算
{
	switch (optr)
	{
	case '+':return a + b;
	case '-':return a - b;
	case '*':return a*b;
	case '/':return a / b;
	default:
		return 0.0;
		break;
	}
}
 

#include <iostream>
#include <regex>
#include <string>
#include <stack>
#include <deque>
#include "regular expression.h"
using namespace std;


int main()
{
	string strCin;             //表示式字串
	stack<Item> stackExpression;      //一個堆
	deque<Item> dequeExpression;    //一個佇列
	const char * ptrExrpression;

	cin >> strCin;     //輸入表示式
	ptrExrpression = strCin.c_str();    //string物件返回一個const char *
	cout << EvaluateExpression(stackExpression, dequeExpression, ptrExrpression) << endl;  //呼叫EvaluateExpression 直接出結果
}