//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