Parsing String of symbols to Expression

// C++ implementation of the approach
#include <cstring>
#include <iostream>
using namespace std;

// Length of expressions in characters
const int LEN = 80;

// Size of the stack
const int MAX = 40;

class Stack {
private:
    // Stack: array of characters
    char st[MAX];

    // Number at top of the stack
    int top;

public:
    Stack()
    {
        top = 0;
    }

    // Function to put a character in stack
    void push(char var)
    {
        st[++top] = var;
    }

    // Function to return a character off stack
    char pop()
    {
        return st[top--];
    }

    // Function to get the top of the stack
    int gettop()
    {
        return top;
    }
};

// Expression class
class Express {
private:
    // Stack for analysis
    Stack s;

    // Pointer to input string
    char* pStr;

    // Length of the input string
    int len;

public:
    Express(char* ptr)
    {
        pStr = ptr;
        len = strlen(pStr);
    }

    // Parse the input string
    void parse();

    // Evaluate the stack
    int solve();
};

void Express::parse()
{

    // Character from the input string
    char ch;

    // Last value
    char lastval;

    // Last operator
    char lastop;

    // For each input character
    for (int j = 0; j < len; j++) {
        ch = pStr[j];

        // If it's a digit then save
        // the numerical value
        if (ch >= '0' && ch <= '9')
            s.push(ch - '0');

        // If it's an operator
        else if (ch == '+' || ch == '-'
                 || ch == '*' || ch == '/') {

            // If it is the first operator
            // then put it in the stack
            if (s.gettop() == 1)

                s.push(ch);

            // Not the first operator
            else {
                lastval = s.pop();
                lastop = s.pop();

                // If it is either '*' or '/' and the
                // last operator was either '+' or '-'
                if ((ch == '*' || ch == '/')
                    && (lastop == '+' || lastop == '-')) {

                    // Restore the last two pops
                    s.push(lastop);
                    s.push(lastval);
                }

                // In all the other cases
                else {

                    // Perform the last operation
                    switch (lastop) {

                    // Push the result in the stack
                    case '+':
                        s.push(s.pop() + lastval);
                        break;
                    case '-':
                        s.push(s.pop() - lastval);
                        break;
                    case '*':
                        s.push(s.pop() * lastval);
                        break;
                    case '/':
                        s.push(s.pop() / lastval);
                        break;
                    default:
                        cout << "\nUnknown oper";
                        exit(1);
                    }
                }
                s.push(ch);
            }
        }
        else {
            cout << "\nUnknown input character";
            exit(1);
        }
    }
}

int Express::solve()
{
    // Remove the items from stack
    char lastval;
    while (s.gettop() > 1) {
        lastval = s.pop();
        switch (s.pop()) {

        // Perform operation, push answer
        case '+':
            s.push(s.pop() + lastval);
            break;
        case '-':
            s.push(s.pop() - lastval);
            break;
        case '*':
            s.push(s.pop() * lastval);
            break;
        case '/':
            s.push(s.pop() / lastval);
            break;
        default:
            cout << "\nUnknown operator";
            exit(1);
        }
    }
    return int(s.pop());
}

// Driver code
int main()
{

    char string[LEN] = "2+3*4/3-2";

    // Make expression
    Express* eptr = new Express(string);

    // Parse it
    eptr->parse();

    // Solve the expression
    cout << eptr->solve();

    return 0;
}