• Logical (or ADT) level: A stack is an ordered group of homogeneous items (elements), in which the removal and addition of stack items can take place only at the top of the stack.

• A stack is a LIFO “last in, first out” structure.

Operations      

// Class specification for Stack ADT in file StackType.h
//  uses Array of specified maximum size to store items


class FullStack	    	// Exception class thrown by 
					// Push when stack is full
{};
class EmptyStack	 	// Exception class thrown by 
			             // Pop and Top when stack is empty
{};

#include "ItemType.h"

class StackType
{
public:

	StackType( );  
	// Class constructor.
	bool IsFull () const;
	// Function: Determines whether the stack is full.
	// Pre: Stack has been initialized
	// Post: Function value = (stack is full) 
	bool IsEmpty() const;
	// Function: Determines whether the stack is empty.
	// Pre:   Stack has been initialized.
	// Post:  Function value = (stack is empty)
	void Push( ItemType item );
	// Function: Adds newItem to the top of the stack.
	// Pre: Stack has been initialized.
	// Post: If (stack is full), FullStack exception is thrown;
  //        otherwise, newItem is at the top of the stack.
  void Pop();
	// Function: Removes top item from the stack.
	// Pre: Stack has been initialized.
	// Post: If (stack is empty), EmptyStack exception is thrown;
  // 	     otherwise, top element has been removed from stack.
  ItemType Top();	
	// Function: Returns a copy of top item on the stack.
	// Pre: Stack has been initialized.
 	// Post: If (stack is empty), EmptyStack exception is thrown;
	// 	     otherwise, top element has been removed from stack.
private:
	int top;
	ItemType  items[MAX_ITEMS];	
};


// File: StackType.cpp

#include "StackType.h" 
#include 
StackType::StackType( )
{
   top = -1;
}
bool StackType::IsEmpty() const
{
   return(top = = -1);
}

bool StackType::IsFull() const
{ 
   return (top = = MAX_ITEMS-1);
}

void StackType::Push(ItemType newItem)
{
	if( IsFull() )
	   throw FullStack():
	top++;
	items[top] = newItem;
}
 
void StackType::Pop()
{
	if( IsEmpty() )
	  throw EmptyStack();
   top--;
}

ItemType StackType::Top()
{
	if (IsEmpty())
	  throw EmptyStack();
  return items[top];
}


            

Example: Tracing Client Code

Implementation 2 &3:

Using "Class Templates" to create different Types of Stack Data Structures and also Implementation with templates and dynamic array allocation

• The dynamic array implementation of the stack has a weakness -- the maximum size of the stack is passed to the constructor as parameter.

Implementation 3: (better solution)

Using Dynamically Linked Strucutre