Question

implement a class of infix calculators (Using C++).

Consider a simple infix expression that consist of single digit operands; the operators +, -, *, and / ; and parentheses. Assume that unary operators are illegal and that the expression contains no embedded spaces.

Design and implement a class of infix calculators. Use the algorithms given in the chapter 6 to evaluate infix expressions as entered into the calculator. You must first convert the infix expression to postfix form and then evaluate the resulting postfix expression. You need to implement a driver function that takes one line of infix expression either from console or an input file infix.dat, and print out the post fix expression and calculated result to the console.

Answer 1

CODE

/* C++ implementation to convert infix expression to postfix*/

// Note that here we use std::stack for Stack operations

#include<bits/stdc++.h>

using namespace std;

//Function to return precedence of operators

int prec(char c)

{

  if(c == '^')

  return 3;

  else if(c == '*' || c == '/')

  return 2;

  else if(c == '+' || c == '-')

  return 1;

  else

  return -1;

}

// The main function to convert infix expression

//to postfix expression

string infixToPostfix(string s)

{

  std::stack<char> st;

  st.push('N');

  int l = s.length();

  string ns;

  for(int i = 0; i < l; i++)

  {

    // If the scanned character is an operand, add it to output string.

    if((s[i] >= 'a' && s[i] <= 'z')||(s[i] >= 'A' && s[i] <= 'Z')||(s[i] >= '0' && s[i] <= '9'))

    ns+=s[i];

    // If the scanned character is an ‘(‘, push it to the stack.

    else if(s[i] == '(')

    

    st.push('(');

    

    // If the scanned character is an ‘)’, pop and to output string from the stack

    // until an ‘(‘ is encountered.

    else if(s[i] == ')')

    {

      while(st.top() != 'N' && st.top() != '(')

      {

        char c = st.top();

        st.pop();

      ns += c;

      }

      if(st.top() == '(')

      {

        char c = st.top();

        st.pop();

      }

    }

    

    //If an operator is scanned

    else{

      while(st.top() != 'N' && prec(s[i]) <= prec(st.top()))

      {

        char c = st.top();

        st.pop();

        ns += c;

      }

      st.push(s[i]);

    }

  }

  //Pop all the remaining elements from the stack

  while(st.top() != 'N')

  {

    char c = st.top();

    st.pop();

    ns += c;

  }

  

  return ns;

}

// Stack type

struct Stack

{

  int top;

  unsigned capacity;

  int* array;

};

// Stack Operations

struct Stack* createStack( unsigned capacity )

{

  struct Stack* stack = (struct Stack*) malloc(sizeof(struct Stack));

  if (!stack) return NULL;

  stack->top = -1;

  stack->capacity = capacity;

  stack->array = (int*) malloc(stack->capacity * sizeof(int));

  if (!stack->array) return NULL;

  return stack;

}

int isEmpty(struct Stack* stack)

{

  return stack->top == -1 ;

}

char peek(struct Stack* stack)

{

  return stack->array[stack->top];

}

char pop(struct Stack* stack)

{

  if (!isEmpty(stack))

    return stack->array[stack->top--] ;

  return '$';

}

void push(struct Stack* stack, char op)

{

  stack->array[++stack->top] = op;

}

// The main function that returns value of a given postfix expression

int evaluatePostfix(string exp)

{

  // Create a stack of capacity equal to expression size

  struct Stack* stack = createStack(exp.size());

  int i;

  // See if stack was created successfully

  if (!stack) return -1;

  // Scan all characters one by one

  for (i = 0; exp[i]; ++i)

  {

    // If the scanned character is an operand (number here),

    // push it to the stack.

    if (isdigit(exp[i]))

      push(stack, exp[i] - '0');

    // If the scanned character is an operator, pop two

    // elements from stack apply the operator

    else

    {

      int val1 = pop(stack);

      int val2 = pop(stack);

      switch (exp[i])

      {

      case '+': push(stack, val2 + val1); break;

      case '-': push(stack, val2 - val1); break;

      case '*': push(stack, val2 * val1); break;

      case '/': push(stack, val2/val1); break;

      }

    }

  }

  return pop(stack);

}

//Driver program to test above functions

int main()

{

  string exp;

cout << "Enter an infix expression: ";

cin >> exp;

  string postfix = infixToPostfix(exp);

cout << "Postfix expression: " << postfix << endl;

cout<<"postfix evaluation: " << evaluatePostfix(postfix);

  return 0;

}

NOTE: Due to lack of time(we get only 2 hours), I could only implement the code which could accept only single digit as operands.