Infix to Postfix in C++ (3 files, header[infixtopostfix.h] , imp file [infixtopostfiximp.cpp], and main [main.cpp]) show ran through terminal at end

Suppose infx represents the infix expression and pfx represents the postfix expression. The rules to convert infx into pfx are as follows:

a. Initialize pfx to an empty expression and also initialize the stack.

b. Get the next symbol, sym, from infx.

b.1. If sym is an operand, append sym to pfx.

b.2. If sym is (, push sym into the stack.

b.3. If sym is ), pop and append all the symbols from the stack until the most recent left parenthesis. Pop and discard the left parenthesis.

b.4. If sym is an operator:

b.4.1. Pop and append all the operators from the stack to pfx that are above the most recent left parenthesis and have precedence greater than or equal to sym.

b.4.2. Push sym onto the stack.

c. After processing infx, some operators might be left in the stack. Pop and append to pfx everything from the stack.

You may assume that the expressions you will process are error free. In this program, you will consider the following (binary) arithmetic operators: +, -, *, and /.

Design a class with separate header and implementation files called infixToPostfix that stores the infix and postfix strings and includes the following methods:

getInfix - Stores the infix expression

showInfix - Outputs the infix expression

showPostfix - Outputs the postfix expression

convertToPostfix - Converts the infix expression into a postfix expression. The resulting postfix expression is stored in pfx.

precedence - Determines the precedence between two operators. If the first operator is of higher or equal precedence than the second operator, it returns the value true; otherwise, it returns the value false.

Include the constructors and destructors for automatic initialization and dynamic memory deallocation. Your program will read from a file called data.txt which contains five expressions to convert. For each expression, your answer must be in the following form:

Infix Expression: A + B - C;

Postfix Expression: A B + C -

Files included are :

//MY_STACK.H

#ifndef H_StackType

#define H_StackType

#include

#include

#include "stackADT.h"

using namespace std;

//*************************************************************

// Author: D.S. Malik

//

// This class specifies the basic operation on a stack as an

// array.

//*************************************************************

template

class stackType: public stackADT

{

public:

const stackType& operator=(const stackType&);

//Overload the assignment operator.

void initializeStack();

//Function to initialize the stack to an empty state.

//Postcondition: stackTop = 0;

bool isEmptyStack() const;

//Function to determine whether the stack is empty.

//Postcondition: Returns true if the stack is empty,

// otherwise returns false.

bool isFullStack() const;

//Function to determine whether the stack is full.

//Postcondition: Returns true if the stack is full,

// otherwise returns false.

void push(const Type& newItem);

//Function to add newItem to the stack.

//Precondition: The stack exists and is not full.

//Postcondition: The stack is changed and newItem is

// added to the top of the stack.

Type top() const;

//Function to return the top element of the stack.

//Precondition: The stack exists and is not empty.

//Postcondition: If the stack is empty, the program

// terminates; otherwise, the top element of the stack

// is returned.

void pop();

//Function to remove the top element of the stack.

//Precondition: The stack exists and is not empty.

//Postcondition: The stack is changed and the top element is

// removed from the stack.

stackType(int stackSize = 100);

//Constructor

//Create an array of the size stackSize to hold

//the stack elements. The default stack size is 100.

//Postcondition: The variable list contains the base address

// of the array, stackTop = 0, and maxStackSize = stackSize

stackType(const stackType& otherStack);

//Copy constructor

~stackType();

//Destructor

//Remove all the elements from the stack.

//Postcondition: The array (list) holding the stack

// elements is deleted.

private:

int maxStackSize; //variable to store the maximum stack size

int stackTop; //variable to point to the top of the stack

Type *list; //pointer to the array that holds the stack elements

void copyStack(const stackType& otherStack);

//Function to make a copy of otherStack.

//Postcondition: A copy of otherStack is created and assigned

// to this stack.

};

template

void stackType::initializeStack()

{

stackTop = 0;

}//end initializeStack

template

bool stackType::isEmptyStack() const

{

return(stackTop == 0);

}//end isEmptyStack

template

bool stackType::isFullStack() const

{

return(stackTop == maxStackSize);

} //end isFullStack

template

void stackType::push(const Type& newItem)

{

if (!isFullStack())

{

list[stackTop] = newItem; //add newItem to the

//top of the stack

stackTop++; //increment stackTop

}

else

cout << "Cannot add to a full stack." << endl;

}//end push

template

Type stackType::top() const

{

assert(stackTop != 0); //if stack is empty,

//terminate the program

return list[stackTop - 1]; //return the element of the

//stack indicated by

//stackTop - 1

}//end top

template

void stackType::pop()

{

if (!isEmptyStack())

stackTop--; //decrement stackTop

else

cout << "Cannot remove from an empty stack." << endl;

}//end pop

template

stackType::stackType(int stackSize)

{

if (stackSize <= 0)

{

cout << "Size of the array to hold the stack must "

<< "be positive." << endl;

cout << "Creating an array of size 100." << endl;

maxStackSize = 100;

}

else

maxStackSize = stackSize; //set the stack size to

//the value specified by

//the parameter stackSize

stackTop = 0; //set stackTop to 0

list = new Type[maxStackSize]; //create the array to

//hold the stack elements

}//end constructor

template

stackType::~stackType() //destructor

{

delete [] list; //deallocate the memory occupied

//by the array

}//end destructor

template

void stackType::copyStack(const stackType& otherStack)

{

delete [] list;

maxStackSize = otherStack.maxStackSize;

stackTop = otherStack.stackTop;

list = new Type[maxStackSize];

//copy otherStack into this stack

for (int j = 0; j < stackTop; j++)

list[j] = otherStack.list[j];

} //end copyStack

template

stackType::stackType(const stackType& otherStack)

{

list = NULL;

copyStack(otherStack);

}//end copy constructor

template

const stackType& stackType::operator=

(const stackType& otherStack)

{

if (this != &otherStack) //avoid self-copy

copyStack(otherStack);

return *this;

} //end operator=

#endif

//////////STACKADT.H

#ifndef H_StackADT #define H_StackADT //************************************************************* // Author: D.S. Malik // // This class specifies the basic operations on a stack. //*************************************************************

template class stackADT { public: virtual void initializeStack() = 0; //Method to initialize the stack to an empty state. //Postcondition: Stack is empty.

virtual bool isEmptyStack() const = 0; //Function to determine whether the stack is empty. //Postcondition: Returns true if the stack is empty, // otherwise returns false.

virtual bool isFullStack() const = 0; //Function to determine whether the stack is full. //Postcondition: Returns true if the stack is full, // otherwise returns false.

virtual void push(const Type& newItem) = 0; //Function to add newItem to the stack. //Precondition: The stack exists and is not full. //Postcondition: The stack is changed and newItem is added // to the top of the stack.

virtual Type top() const = 0; //Function to return the top element of the stack. //Precondition: The stack exists and is not empty. //Postcondition: If the stack is empty, the program // terminates; otherwise, the top element of the stack // is returned.

virtual void pop() = 0; //Function to remove the top element of the stack. //Precondition: The stack exists and is not empty. //Postcondition: The stack is changed and the top element // is removed from the stack. }; #endif

////////////////////data.txt

A+B-C; (A+B)*C; (A+B)*(C-D); A+((B+C)*(E-F)-G)/(H-I); A+B*(C+D)-E/F*G+H;