// The Stack is used in the program. So it is included here
#include <vector>
#include <iostream>
#include <cmath>
using namespace std;

#ifndef STACK_H
#define STACK_H

template<typename T>
class Stack
{
public:
  Stack();
  bool empty() const;
  T peek() const;
  void push(T value);
  T pop();
  int getSize() const;

private:
  vector<T> elements;
};

template<typename T>
Stack<T>::Stack()
{
}

template<typename T>
bool Stack<T>::empty() const
{
  return elements.size() == 0;
}

template<typename T>
T Stack<T>::peek() const
{
  return elements[elements.size() - 1];
}

template<typename T>
void Stack<T>::push(T value)
{
  elements.push_back(value);
}

template<typename T>
T Stack<T>::pop()
{
  T temp = elements[elements.size() - 1];
  elements.pop_back();
  return temp;
}

template<typename T>
int Stack<T>::getSize() const
{
  return elements.size();
}

#endif

#include <string>
#include <cctype>

using namespace std;

// Split an expression into numbers, operators, and parenthese
vector<string> split(const string& expression);

// Evaluate an expression and return the result
int evaluateExpression(const string& expression);

// Perform an operation
void processAnOperator(
  Stack<int>& operandStack, Stack<char>& operatorStack);

int main()
{
  string expression;
  cout << "Enter an expression: ";
  getline(cin, expression);

  cout << expression << " = "
    << evaluateExpression(expression) << endl;

  return 0;
}

vector<string> split(const string& expression)
{
  vector<string> v; // A vector to store split items as strings
  string numberString; // A numeric string

  for (unsigned int i = 0; i < expression.length(); i++)
  {
    if (isdigit(expression[i]))
      numberString.append(1, expression[i]); // Append a digit
    else
    {
      if (numberString.size() > 0)
      {
        v.push_back(numberString); // Store the numeric string
        numberString.erase(); // Empty the numeric string
      }

      if (!isspace(expression[i]))
      {
        string s;
        s.append(1, expression[i]);
        v.push_back(s); // Store an operator and parenthesis
      }
    }
  }

  // Store the last numeric string
  if (numberString.size() > 0)
    v.push_back(numberString);

  return v;
}

// Evaluate an expression 
int evaluateExpression(const string& expression)
{
  // Write your code here
}

// Process one opeator: Take an operator from operatorStack and 
// apply it on the operands in the operandStack 
void processAnOperator(
  Stack<int>& operandStack, Stack<char>& operatorStack)
{
  // Write your code here
}