栈的应用-简单计算器（中缀表达式转后缀表达式）

//
//  Stack.h
//  顺序栈
//
//  Created by geshenglu on 2020/3/21.
//  Copyright © 2020 geshenglu. All rights reserved.
//

#ifndef Stack_h
#define Stack_h
template<class Elemtype>
class Stack
{
public:
    virtual bool IsEmpty() const =0;
    virtual void Push(const Elemtype&x)=0;
    virtual Elemtype Pop()=0;
    virtual Elemtype Top()const =0;
    virtual ~Stack(){};
};
#endif /* Stack_h */

//
//  SeqStack.h
//  顺序栈
//
//  Created by geshenglu on 2020/3/21.
//  Copyright © 2020 geshenglu. All rights reserved.
//

#ifndef SeqStack_h
#define SeqStack_h
#include "Stack.h"
template<class Elemtype>
class SeqStack:public Stack<Elemtype>
{
private:
    Elemtype *data;
    int maxSize;
    int top_p;
    void doubleSpace();
public:
    SeqStack(int initSize = 10)
    {
        maxSize = initSize;
        data =  new Elemtype[maxSize];
        top_p = -1;
    }
    ~SeqStack()
    {
        delete [] data;
    }
    virtual bool IsEmpty() const override;
    virtual void Push(const Elemtype&x)override;
    virtual Elemtype Pop()override;
    virtual Elemtype Top()const override;
};

template<class Elemtype>
void SeqStack<Elemtype>::doubleSpace()
{
    Elemtype *tmp = data;
    data = new  Elemtype[maxSize*2];
    for (int i=0; i<maxSize; ++i)
        data[i] = tmp[i];
    maxSize *= 2;
    delete tmp;
}

template<class Elemtype>
 bool SeqStack<Elemtype>::IsEmpty() const
{
    return top_p == -1;
}

template<class Elemtype>
void SeqStack<Elemtype>::Push(const Elemtype&x)
{
    if(top_p == maxSize - 1)
    {
        doubleSpace();
    }
    data[++top_p]=x;
}

template<class Elemtype>
Elemtype SeqStack<Elemtype>::Pop()
{
    return data[top_p--];
}


template<class Elemtype>
Elemtype SeqStack<Elemtype>::Top() const
{
    return data[top_p];
}

#endif /* SeqStack_h */

//
// Created by geshenglu on 2020/4/4.
//

#ifndef CALC_H
#define CALC_H
#include "SeqStack.h"
#include <string>
class Calc {
    char *expression;
    enum class token{
        OPAREN,ADD,SUB,MULTI,DIV,EXP,CPAREN,VALUE,EOL
    };
    void BinaryOp(token op,SeqStack<int>&dataStack);
    token GetOp(int &value);
public:
    Calc(char *s){
        expression = new char[strlen(s)+1];
        strcpy(expression,s);
    }
    ~Calc(){
        delete expression;
    }
    int result();
};
#endif //CALC_H

//
// Created by geshenglu on 2020/4/4.
//

#include "Calc.h"
#include <iostream>
#include <cmath>
void Calc::BinaryOp(Calc::token op, SeqStack<int> &dataStack) {
    int num1,num2;
    if(dataStack.IsEmpty()){
        std::cerr<<"缺少右操作数！"<<std::endl;
        exit(1);
    }
    else
        num2 = dataStack.Pop();

    if(dataStack.IsEmpty()){
        std::cerr<<"缺少左操作数！"<<std::endl;
        exit(1);
    }
    else
        num1 = dataStack.Pop();

    switch(op){
        case token::ADD:
            dataStack.Push(num1+num2);
            break;
        case token::SUB:
            dataStack.Push(num1-num2);
            break;
        case token::MULTI:
            dataStack.Push(num1*num2);
            break;
        case token::DIV:
            dataStack.Push(num1/num2);
            break;
        case token::EXP:
            dataStack.Push(pow(num1,num2));
            break;
    }
}

Calc::token Calc::GetOp(int &value) {
    while (*expression && *expression == ' '){
        ++expression;
    }
    if(*expression=='\0'){
        return token::EOL;
    }
    if(*expression>='0' && *expression<='9'){
        value = 0;
        while (*expression>='0' && *expression<='9'){
            value = value*10 + *expression - '0';
            ++expression;
        }
        return token::VALUE;
    }
    switch(*expression){
        case '(':
            ++expression;
            return token::OPAREN;
        case ')':
            ++expression;
            return token::CPAREN;
        case '+':
            ++expression;
            return token::ADD;
        case '-':
            ++expression;
            return token::SUB;
        case '*':
            ++expression;
            return token::MULTI;
        case '/':
            ++expression;
            return token::DIV;
        case '^':
            ++expression;
            return token::EXP;
    }
}

int Calc::result() {
    token lastOp,topOp;
    int result_value,CurrentValue;
    SeqStack<token> opStack;
    SeqStack<int> dataStack;
    char *str = expression;
    while((lastOp = GetOp(CurrentValue))!=token::EOL){
        switch(lastOp){
            case token::VALUE:
                dataStack.Push(CurrentValue);
                break;
            case token::CPAREN:
                while (!opStack.IsEmpty() && (topOp = opStack.Pop())!=token::OPAREN){
                    BinaryOp(topOp,dataStack);
                }
                if(topOp!=token::OPAREN){
                    std::cerr<<"缺失左括号"<<std::endl;
                }
                break;
            case token::OPAREN:
                opStack.Push(token::OPAREN);
                break;
            case token::EXP:
                opStack.Push(token::EXP);
                break;
            case token::MULTI:
            case token::DIV:
                while (!opStack.IsEmpty() && (opStack.Top())>=token::MULTI){
                    BinaryOp(opStack.Pop(),dataStack);
                }
                opStack.Push(lastOp);
                break;
            case token::ADD:
            case token::SUB:
                while (!opStack.IsEmpty() && (opStack.Top())!=token::OPAREN){
                    BinaryOp(opStack.Pop(),dataStack);
                }
                opStack.Push(lastOp);
                break;
        }
    }

    while (!opStack.IsEmpty()){
        BinaryOp(opStack.Pop(),dataStack);
    }

    if(dataStack.IsEmpty()){
        std::cout<<"无结果!"<<std::endl;
        return 0;
    }
    result_value = dataStack.Pop();
    if(!dataStack.IsEmpty()){
        std::cout<<"缺操作符!"<<std::endl;
        return 0;
    }
    expression = str;
    return result_value;
}

#include <iostream>
#include "Calc.h"
int main() {
    Calc exp1("3*(1+1)^2^3/(4-2)-10*99+  1 -13");
    std::cout<<exp1.result()<<std::endl;
    return 0;
}