看書學了一晚上這個內容，終於實現了

分為三個步驟：

　　0. 檢查輸入是否有誤（因為輸入其他的非預期字符，程序就會崩潰，我就試著加了一個檢查輸入的函數）

　　1. 先將正常的中綴表達式轉換為後綴表達式

　　2. 再進行求值

根據後綴表達式求值比較簡單，因為後綴表達式已經有了優先級。

比較難懂的是將中綴表達式轉換為後綴表達式，需要考慮很多情況：

　　1. 如果字符是 ‘(‘ ，就直接入操作符棧，因為越內層的括號優先級越高，所以不用考慮什麽

　　2. 如果字符是 ‘)‘ ，就要結束一個左括號了，將前面的操作符出棧送入postexp，直到遇到 ‘(‘。

　　3. 如果字符是 ‘-‘ 或 ‘+‘ ，就要將遇到的第一個 ‘(‘ 之前的所有操作符出棧送入postexp。因為相對來說，後面的 ‘+‘ 和 ‘-‘ 優先級是最低的，低於前面的所有操作符。最後出棧完，再將它壓入棧。

　　4. 如果字符是 ‘*‘ 或 ‘/‘ ， 先判斷前面操作符棧底是否為 ‘*‘ 或 ‘/‘ ，是的話就要將棧裏的符號出棧送入postexp。因為 ‘*‘ 或 ‘/‘ 的優先級低於前面的 ‘*‘ 或 ‘/‘，是高於前面的 ‘+‘ 和 ‘-‘ 的。

#include <iostream>
using namespace std;
const int MAXSIZE = 50;

typedef struct
{
    char data[MAXSIZE];
    int top;
}Stack;

void InitStack(Stack *&s)
{
    s = (Stack*)malloc(sizeof(Stack));
    s->top = -1;
}

bool Push(Stack *&s, char e)
{
    if (s->top == MAXSIZE - 1)
        return false;
    s->top++;
    s->data[s->top] = e;
    return true;
}

bool Pop(Stack *&s, char &e)
{
    if (s->top == -1)
        return false;
    e = s->data[s->top];
    s->top--;
    return true;
}

bool GetTop(Stack *&s, char &e)
{
    if (s->top == -1)
        return false;
    e = s->data[s->top];
    return true;
}

bool StackEmpty(Stack *&s)
{
    if (s->top == -1)
        return true;
    return false;
}


void trans(char *exp, char postexp[])
{
    int i = 0; // postexp 下標
    char e;    // 給 pop gettop用
    Stack *Optr;
    InitStack(Optr);

    while (*exp != ‘\0‘)
    {
        switch (*exp)
        {
        case ‘(‘:
            Push(Optr, ‘(‘);
            exp++; //exp指針前移，繼續處理下一個字符
            break;
        case ‘)‘: //右括號時，一直出棧，指導遇到 (
            Pop(Optr, e);
            while (e != ‘(‘ ) // 當 e=‘(‘ 時，正好把它丟棄了
            {
                postexp[i++] = e;
                Pop(Optr, e);
            }
            exp++;
            break;
        case ‘+‘:
        case ‘-‘: // + - 優先級相同，當做同一種情況處理
            while (!StackEmpty(Optr)) //操作符棧只要不為空，則一直掃描出棧，直到遇到 ) 。
            {
                GetTop(Optr, e);
                if (e == ‘(‘) //後面的 + - ，優先級最低，最後考慮；如果e是 (，則直接入棧即可，所以break
                    break;
                else
                {
                    postexp[i++] = e;
                    Pop(Optr, e);
                }
            }
            Push(Optr, *exp); //最後將 + - 入棧
            exp++;
            break;
        case ‘*‘:
        case ‘/‘:
            while (!StackEmpty(Optr))
            {
                GetTop(Optr, e);
                if (e == ‘/‘ || e == ‘*‘) // * / 的優先級僅僅低於它前面的 * /，高於前面的 + -，所以要將前面的 * / 彈出棧；+ - 保留，因為新的 * / 會放在棧低，優先級高。
                {
                    postexp[i++] = e;
                    Pop(Optr, e);
                }
                else
                    break; // 其他情況（ + - 左括號 ）退出，
            }
            Push(Optr, *exp); //最後將 / * 入棧
            exp++;
            break;
        default:
            while (*exp > ‘0‘ && *exp < ‘9‘) //循環判斷是否為數字字符，如果是則保存到postexp，循環判斷是因為可能是多位數字
            {
                postexp[i++] = *exp;
                exp++;
            }
            postexp[i++] = ‘#‘; //以#標誌一個數字字串結束
        } 
    }
    while (!StackEmpty(Optr)) //掃描完exp後，操作符棧可能還有操作符，將其存到postexp
    {
        Pop(Optr, e);
        postexp[i++] = e;
    }
    postexp[i] = ‘\0‘; //結束字符串
    free(Optr); //銷毀棧
}

//--------- 下面是針對數字型棧的

typedef struct
{
    double data[MAXSIZE];
    int top;
}Stack_num;

void InitStack_num(Stack_num *&s)
{
    s = (Stack_num *)malloc(sizeof(Stack_num));
    s->top = -1;
}

bool Push_num(Stack_num *&s, double e)
{
    if (s->top == MAXSIZE - 1)
        return false;
    s->top++;
    s->data[s->top] = e;
    return true;
}

bool Pop_num(Stack_num *&s, double &e)
{
    if (s->top == -1)
        return false;
    e = s->data[s->top];
    s->top--;
    return true;
}


//---------

double compvalue(char *postexp)
{
    Stack_num *num; //操作數棧
    InitStack_num(num);
    double result; //結果
    double a, b; //彈出棧的兩個數
    double c; //計算彈出棧的兩個數
    double d;    //將連續的數字字符轉換成整數保存在d裏
    while (*postexp != ‘\0‘)
    {
        switch (*postexp)
        {
        case ‘+‘:
            Pop_num(num, a); //因為後綴表達式已經有了優先級了，所以可以直接彈出兩個數進行計算
            Pop_num(num, b);
            c = a + b;
            Push_num(num, c);
            break;
        case ‘-‘:
            Pop_num(num, a);
            Pop_num(num, b);
            c = b - a; //註意是b-a，因為a先出來，是後面的數字
            Push_num(num, c);
            break;
        case ‘*‘:
            Pop_num(num, a);
            Pop_num(num, b);
            c = a * b;
            Push_num(num, c);
            break;
        case ‘/‘:
            Pop_num(num, a); // a是除數
            Pop_num(num, b);
            if (a != 0)
            {
                c = b / a;
                Push_num(num, c);
            }
            else
            {
                cout << "除0錯誤！" << endl;
                exit(0);
            }
            break;
        default:
            d = 0;
            while (*postexp >= ‘0‘ && *postexp <= ‘9‘) //當 *postexp = # 時，就忽略了。
            {
                d = 10 * d + (*postexp - ‘0‘);
                postexp++;
            }
            Push_num(num, d);
        }
        postexp++; //繼續下一個字符
    }
    Pop_num(num, result);

    return result;
}

bool test(char *exp)
{
    // start - 是否非法字符
    for (int i = 0; exp[i] != ‘\0‘; i++)
    {
        if ( !((exp[i] >= ‘0‘ && exp[i] <= ‘9‘) || exp[i] == ‘+‘ || exp[i] == ‘-‘ ||             exp[i] == ‘*‘ || exp[i] == ‘/‘ || exp[i] == ‘(‘ || exp[i] == ‘)‘) )

            return false;
    }
    // end - 是否非法字符

    // start - 括號是否匹配
    Stack *s;
    char e;
    InitStack(s);
    for (int i = 0; exp[i] != ‘\0‘; i++)
    {
        switch (exp[i])
        {
        case ‘(‘:
            Push(s, exp[i]);
            break;
        case ‘)‘:
            if (Pop(s, e))
            {
                if (exp[i] == ‘)‘ && e == ‘(‘)
                    return true;
                else
                    return false;
            }
            else
                return false;
            break;
        }
    }
    if (s->top != -1)  //棧為空才認為成功
        return false;
    else
        return true;

    // end - 括號匹配

    return true;
}

int main()
{
    char exp[MAXSIZE];
    char postexp[MAXSIZE];
    
    while (true)
    {
        cout << "輸入表達式：";
        
        cin >> exp;
        if (!test(exp))
        {
            cout << "非法字符 或 括號不匹配！" << endl;
            continue;
        }
        trans(exp, postexp);

        cout << "後綴表達式:" << postexp << endl;
        cout << "結果：" << compvalue(postexp) << endl;
    }

    system("pause");
    return 0;
}

使用棧實現表達式求值