Question: Having problems with my code. This is what I have so far. janderson22Lab5.cpp //Main program infix to postfix #include #include #include #include myStack.h #include infixToPostfix.h

Having problems with my code. This is what I have so far.

janderson22Lab5.cpp

//Main program infix to postfix

#include #include #include #include "myStack.h" #include "infixToPostfix.h"

using namespace std;

int main() {

infixToPostfix InfixExp; string infix;

ifstream infile;

infile.open("testData.txt");

if (!infile) { cout << "Cannot open input file. Program terminates!!!" << endl; return 1; }

getline(infile, infix);

while (infile) { InfixExp.getInfix(infix); InfixExp.showInfix(); InfixExp.showPostfix(); cout << endl;

getline(infile, infix); }

infile.close();

return 0; }

///////////////////////////

Source.cpp

//Implementation File

#include #include #include "myStack.h" #include "infixToPostfix.h"

using namespace std;

void infixToPostfix::convertToPostfix() { for (int c = 0; c < inFix.size(); c++) { sym = inFix[c];

if (isalpha(sym)) { postFix += sym; }//if(isalpha(sym) else if (isdigit(sym)) { postFix += sym; }//else if else { switch (sym) { case '(': fixStack.push(sym); break; case ')': if (!fixStack.isEmptyStack()) { while (fixStack.top() != '(') { postFix += fixStack.top(); fixStack.pop(); }//while checking if top of stack is not ( }//if checking if stack is not empty

if (!fixStack.isEmptyStack()) { fixStack.pop(); }//if checking if stack is not empty break;

case '+': case '*': case '-': case '/':

if (fixStack.isEmptyStack()) { fixStack.push(sym); }//checking if stack is empty else if (fixStack.top() == '(') { fixStack.push(sym); }//if checking if top of stack is ( else { while (precedence()) { postFix += fixStack.top(); fixStack.pop(); if (fixStack.isEmptyStack()) { break; } }//while checking precefence

fixStack.push(sym); } break;

default: //cout << "Error! Sym = " << sym << endl; break; }//switch(sym) for picking what to do with each operator }//else }//for(c < inFix.size)

while (!fixStack.isEmptyStack()) { postFix += fixStack.top(); fixStack.pop(); }//while //Your Source Code;

}//end convertToPostfix

bool infixToPostfix::precedence(char opr1, char opr2) { int prec1, prec2;

if (opr1 == '*' || opr1 == '/') prec1 = 2; else if (opr1 == '+' || opr1 == '-') prec1 = 1; else if (opr1 = '(') prec1 = 0;

if (opr2 == '*' || opr2 == '/') prec2 = 2; else if (opr2 == '+' || opr2 == '-') prec2 = 1;

return(prec1 >= prec2); }//end precedence

void infixToPostfix::getInfix(string data) { ifx = data; convertToPostfix(); }

void infixToPostfix::showInfix() { cout << "Infix: " << ifx << endl; }

void infixToPostfix::showPostfix() { cout << "Postfix: " << pfx << endl; }

infixToPostfix::infixToPostfix(string infx) { ifx = infx; convertToPostfix(); }

///////////////////////////////////////////////////////////////////

myStack.h

//Header file: myStack.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

//////////////////////////////////////////////////////////////////////////////////////

infixToPush.h

// Specification file for InfixToPostfix.h

#ifndef H_InfixToPostfix #define H_InfixToPostfix

#include

using namespace std;

class infixToPostfix { public: void convertToPostfix(); bool precedence(char opr1, char opr2); void getInfix(string); void showInfix(); void showPostfix(); infixToPostfix(string = ""); //Default constructor

private: string ifx; string pfx; };

#endif

/////////////////////////////////////////////////////////////////////////////////

stackADT.h