#ifndef H_StackType

#define H_StackType

#include

#include

#include "stackADT.h"

using namespace std;

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.

bool operator==(const stackType& otherStack) const;

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 = nullptr;

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