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

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;