www.pudn.com > container.rar > container.h

// Fig. 15.3: list.h 
// Template List class definition 
#ifndef CONTAINER_H 
#define CONTAINER_H 
 
#include  
#include  
#include "element.h" 
 
template< class TYPE > 
class Container { 
public: 
   Container();      // constructor 
   ~Container();     // destructor 
   void insertAtFront( const TYPE & ); 
   void insertAtBack( const TYPE & ); 
   bool removeFromFront( TYPE & ); 
   bool removeFromBack( TYPE & ); 
   bool isEmpty() const; 
   void print() const; 
private: 
   Element< TYPE > *firstPtr;  // pointer to first node 
   Element< TYPE > *lastPtr;   // pointer to last node 
 
   // Utility function to allocate a new node 
   Element< TYPE > *getNewNode( const TYPE & ); 
}; 
 
// Default constructor 
template< class TYPE > 
Container< TYPE >::Container()   
{ 
	firstPtr = NULL; 
	lastPtr = NULL; 
} 
 
// Destructor 
template< class TYPE > 
Container< TYPE >::~Container() 
{ 
   if ( !isEmpty() ) {    // List is not empty 
      cout << "Destroying nodes ...\n"; 
 
      Element< TYPE > *currentPtr = firstPtr, *tempPtr; 
 
      while ( currentPtr != 0 ) {  // delete remaining nodes 
         tempPtr = currentPtr; 
	//	 cout << tempPtr->data << '\n'; 
         currentPtr = currentPtr->nextPtr; 
         delete tempPtr; 
      } 
   } 
 
   cout << "All nodes destroyed\n\n"; 
} 
 
// Insert a node at the front of the list 
template< class TYPE > 
void Container< TYPE >::insertAtFront( const TYPE &value ) 
{ 
   Element< TYPE > *newPtr = getNewNode( value ); 
 
   if ( isEmpty() )  // List is empty 
      firstPtr = lastPtr = newPtr; 
   else {          // List is not empty 
      newPtr->nextPtr = firstPtr; 
      firstPtr = newPtr; 
   } 
} 
 
// Insert a node at the back of the list 
template< class TYPE > 
void Container< TYPE >::insertAtBack( const TYPE &value ) 
{ 
   Element< TYPE > *newPtr = getNewNode( value ); 
 
   if ( isEmpty() )  // List is empty 
      firstPtr = lastPtr = newPtr; 
   else {          // List is not empty 
      lastPtr->nextPtr = newPtr; 
      lastPtr = newPtr; 
   } 
} 
 
// Delete a node from the front of the list 
template< class TYPE > 
bool Container< TYPE >::removeFromFront( TYPE &value ) 
{ 
   if ( isEmpty() )             // List is empty 
      return false;             // delete unsuccessful 
   else { 
      Element< TYPE > *tempPtr = firstPtr; 
 
      if ( firstPtr == lastPtr ) 
         firstPtr = lastPtr = 0; 
      else 
         firstPtr = firstPtr->nextPtr; 
 
      value = tempPtr->data;  // data being removed 
      delete tempPtr; 
      return true;            // delete successful 
   } 
} 
 
// Delete a node from the back of the list 
template< class TYPE > 
bool Container< TYPE >::removeFromBack( TYPE &value ) 
{ 
   if ( isEmpty() ) 
      return false;   // delete unsuccessful 
   else { 
      Element< TYPE > *tempPtr = lastPtr; 
 
      if ( firstPtr == lastPtr ) 
         firstPtr = lastPtr = 0; 
      else { 
         Element< TYPE > *currentPtr = firstPtr; 
 
         while ( currentPtr->nextPtr != lastPtr ) 
            currentPtr = currentPtr->nextPtr; 
 
         lastPtr = currentPtr; 
         currentPtr->nextPtr = 0; 
      } 
 
      value = tempPtr->data; 
      delete tempPtr; 
      return true;   // delete successful 
   } 
} 
 
// Is the List empty? 
template< class TYPE >  
bool Container< TYPE >::isEmpty() const  
   { return firstPtr == 0; } 
 
// Return a pointer to a newly allocated node 
template< class TYPE > 
Element< TYPE > *Container< TYPE >::getNewNode(  
                                        const TYPE &value ) 
{ 
   Element< TYPE > *ptr =  
      new Element< TYPE >( value ); 
   assert( ptr != 0 ); 
   return ptr; 
} 
 
// Display the contents of the List 
template< class TYPE > 
void Container< TYPE >::print() const 
{ 
   if ( isEmpty() ) { 
      cout << "The list is empty\n\n"; 
      return; 
   } 
 
   Element< TYPE > *currentPtr = firstPtr; 
 
   cout << "The list is: "; 
 
   while ( currentPtr != 0 ) { 
      cout << currentPtr->data << ' '; 
      currentPtr = currentPtr->nextPtr; 
   } 
 
   cout << "\n\n"; 
} 
 
#endif