逆波兰表达式

#include<queue>
#include<iostream>
#include<stdlib.h>
#include<string>
#include<string.h>
#include<sstream>
#include<stack>

static stack<string> ss_out;   //后缀求值时用来存放后缀表达式的元素
static stack<string> ss_optr;  //中缀转后缀时用来存放运算符
static queue<string> qs;       //中缀换后缀时用来存放后缀表达式的元素
typedef string::const_iterator IT;

bool IsNum(IT it){
    if(*it-‘0‘>=0 && *it-‘9‘<=0)
        return true;
    else
        return false;
}
//将运算符栈中( )之间的运算符弹出并压入输出队列中;
void GetParenth(void){    
    for(;ss_optr.top()!="(";qs.push(ss_optr.top()),ss_optr.pop()){}
    if(ss_optr.top()=="(")
        ss_optr.pop();
}
void Push_qs(void){
    qs.push(ss_optr.top());
    ss_optr.pop();
}
void Push_Optr_Top(IT& it){
    ostringstream oss;
    oss << *it;
    string tmp=oss.str();
    ss_optr.push(tmp);
}
//优先级处理：+ - * / 简单的四则运算，就直接列举出来了，还可以参照百科里面二维数组定优先级的方法
void Push_Optr(IT& it){
    if(*it == ‘(‘)
        Push_Optr_Top(it);
    if(*it == ‘/‘){
        while(!ss_optr.empty() && ss_optr.top()=="/")
            Push_qs();
        Push_Optr_Top(it);
    }
    if(*it == ‘*‘){
        while(!ss_optr.empty() && (ss_optr.top()=="/"
                    || ss_optr.top()=="*"))
            Push_qs();
        Push_Optr_Top(it);
    }
    if(*it == ‘-‘){
        while(!ss_optr.empty() && (ss_optr.top()=="/" 
                    || ss_optr.top()=="*" || ss_optr.top()=="-"))
            Push_qs();
        Push_Optr_Top(it);
    }
    if(*it == ‘+‘){
        while(!ss_optr.empty() && ss_optr.top()!="(")
            Push_qs();
        Push_Optr_Top(it);
    }
}
//中缀转后缀
void IntoPost(string const& str_in){
    for( IT it_in = str_in.begin(); it_in!=str_in.end(); ++it_in){
        ostringstream oss;
        while(IsNum(it_in)){
            oss << *it_in;
            if(!IsNum(it_in+1) || it_in+1 == str_in.end()){
                string tmp = oss.str();
                qs.push(tmp);                               //遇到符号将输出流转化成字符串存入输出队列;
                break;
            }
            ++it_in;
        }
        if(!IsNum(it_in)){ 
            if(*it_in==‘)‘)
                GetParenth();                               //将运算符栈中( )之间的运算符弹出并压入输出队列中;
            else{
                Push_Optr(it_in);
            }
        }
    }
    while(!ss_optr.empty()){
        qs.push(ss_optr.top());
        ss_optr.pop();
    }
}

void Clear_s(stack<string>& ss){
    while(!ss.empty()){
        ss.pop();
    }
}
//栈顶2元素运算，并将结果入栈
void Calculate(IT& it,stack<string>& ss_out){
    string str_tmp = ss_out.top();
    int result = atoi(str_tmp.c_str());//栈顶元素转为int;
    ss_out.pop();
    str_tmp = ss_out.top();
    ss_out.pop();
    switch(*it){
        case ‘+‘:result = atoi(str_tmp.c_str()) + result; break;
        case ‘-‘:result = atoi(str_tmp.c_str()) - result; break;
        case ‘*‘:result = atoi(str_tmp.c_str()) * result; break;
        case ‘/‘:result = atoi(str_tmp.c_str()) / result; break;

    }
    ostringstream oss;
    oss << result;
    str_tmp = oss.str();//计算结果转为string
    ss_out.push(str_tmp);
}
//后缀表达式求值
void Post_Val(string const& str_post){
    Clear_s(ss_out);
    for(IT it_out = str_post.begin(); it_out!=str_post.end(); ++it_out){
        ostringstream oss;
        while(IsNum(it_out)){  
            oss << *it_out;
            if(!IsNum(it_out+1)){
                string tmp = oss.str();
                ss_out.push(tmp);                                 //遇到符号将输出流内数字转化成字符串存入栈;
            }
            ++it_out;
        }
        if(!IsNum(it_out)){
            if(*it_out == ‘,‘)
                continue;
            else
                Calculate(it_out,ss_out);
        }
    }
}

void Show_Post(){
    while(!qs.empty()){
        cout << qs.front() << " " << flush;
        qs.pop();
    }
    cout << endl;
}
void test(){
    string str_post;
    string str_in;
    cout << "Input infix expression:" << endl;
    cin >> str_in;
    IntoPost(str_in);
    Show_Post();
    cout << "Input postfix expression:" << endl;
    cin >> str_post;
    Post_Val(str_post);
    cout << ss_out.top() << endl;
}
int main(void){
    test();
    return 0;
}