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

ID: 3675181 • Letter: H

Question

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

janderson22Lab5.cpp

//Main program infix to postfix

#include <iostream>
#include <fstream>
#include <cstring>
#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 <iostream>
#include <string>
#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 <iostream>
#include <cassert>

#include "stackADT.h"

using namespace std;

//*************************************************************
// Author: D.S. Malik
//
// This class specifies the basic operation on a stack as an
// array.
//*************************************************************

template <class Type>
class stackType : public stackADT<Type>
{
public:
const stackType<Type>& operator=(const stackType<Type>&);
//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<Type>& 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<Type>& otherStack);
   //Function to make a copy of otherStack.
   //Postcondition: A copy of otherStack is created and assigned
   // to this stack.
};

template <class Type>
void stackType<Type>::initializeStack()
{
stackTop = 0;
}//end initializeStack

template <class Type>
bool stackType<Type>::isEmptyStack() const
{
return(stackTop == 0);
}//end isEmptyStack

template <class Type>
bool stackType<Type>::isFullStack() const
{
return(stackTop == maxStackSize);
} //end isFullStack

template <class Type>
void stackType<Type>::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 <class Type>
void stackType<Type>::pop()
{
   if (!isEmptyStack())
       stackTop--; //decrement stackTop
   else
       cout << "Cannot remove from an empty stack." << endl;
}//end pop

template <class Type>
stackType<Type>::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 <class Type>
stackType<Type>::~stackType() //destructor
{
delete[] list; //deallocate the memory occupied
//by the array
}//end destructor

template <class Type>
void stackType<Type>::copyStack(const stackType<Type>& 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 <class Type>
stackType<Type>::stackType(const stackType<Type>& otherStack)
{
list = NULL;

copyStack(otherStack);
}//end copy constructor

template <class Type>
const stackType<Type>& stackType<Type>::operator=
(const stackType<Type>& 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 <string>

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