最简单的解析器.

#include <常用>
枚 类型{整数,加减,乘除,尾巴};

构 令牌{//有个尾巴类型
    类型 a;整 b=0;符 c;
    令牌(){a=尾巴;}
    显 令牌(符 d){
        静 串无符 加符{"+-"},乘符{"*/"};
        c=d;如(加符.有(d)){a=加减;中;}
        如(乘符.有(d)){a=乘除;中;}
        打印("不支持",d);
    }
    显 令牌(整 d){b=d;a=整数;}
};
//+-/*,等为操作符
//不符号规定就退出,
构 造流{//用入啊,全局好用些
    向量<令牌>列;符 c;
    串无符 呀{"+-*/"},数{"0123456789"};
    空 取数(){//不支持超过9位的数
        整 i=0;整 j=0;
        当(1){
            c=看();如(j>9||!数.有(c))断;
            i=i*10+c-'0';j++;右();
        }
        压(列,令牌{i});
    }
    空 造令(串&a){
        清理(列);入.切换串(a);
        当(1){
            如(入.尾)断;c=看();
            如(是空格(c)){右();下;}
            如(呀.有(c)){压(列,令牌{c});右();下;}
            如(数.有(c)){取数();下;}
            打印("错误符",c);
        }
        压(列,令牌{});//压个空尾巴
    }//加个尾巴,免得不知道到尾巴了.
};

构 消费流{//
    令牌流<令牌>令;
    整 切换(向量<令牌>&a){令.切换(a);中 解析();}
    整 取值(){令牌 t=令.取();中 t.b;}
    整 解析乘除(){//优先级高的在下层.
        整 i=取值();整 j=0;令牌 t;
        打印("解析乘除开始",i,j);
        当(1){
            t=令.偷看();如(t.a==尾巴)断;
            如(t.a!=乘除)断;令.针加();
            j=取值();
            如(t.c=='*')i*=j;
            异 如(t.c=='/')i/=j;
        }
        打印("解析乘除结束",i,j,"哈");
        中 i;
    }//消解乘除影响
    整 解析(){
        打印("解析开始");
        整 i=解析乘除();整 j=0;令牌 t;
        当(1){
            t=令.偷看();如(t.a==尾巴)断;
            如(t.a!=加减)断;令.针加();
            j=解析乘除();
            如(t.c=='+')i+=j;
            异 如(t.c=='-')i-=j;
        }
        打印("解析结束",i,"哈");
        中 i;
    }//只剩下加减.
};
整 组合(串&a){
    静 造流 b;静 消费流 c;
    b.造令(a);中 c.切换(b.列);
}


空 主(){
    串 b{"34+456*5-4534/3"};
    串 c{"23*45/2+45/3*34/2-34"};
    串 d{"2+34+34*2/3+45/3*34/2-34"};
    打印(组合(b));打印(组合(c));
    打印(组合(d));
    //不能并列,要冲突.
}