Queue

Queue Data Structure in C Plus Plus

// Jesse B. Dooley
// 22 Oct 1996

// simplequeue.cc

// Jesse B. Dooley
// 26 May 1995

// template simplequeue class

// The following overloaded operators are
// assumed for the Q data type.
// <  less than
// >  greater than
// == equals
// << output stream
// >> input stream
// =  assignment

#ifndef SIMPLEQUEUE_CC
#define SIMPLEQUEUE_CC

#include <iostream.h>  // UNIX

template<class Q> class simplequeue {
	
   struct simplequeuenode {
      Q simplequeueData;
      simplequeuenode *next;
   };

   simplequeuenode *first, *last;

   unsigned long m_ulPopulation;

friend istream& operator >> (istream &IS , simplequeue<Q> &A);

friend ostream& operator << (ostream &OS , simplequeue<Q>& A );

public:

simplequeue()
{
   first = last = NULL;
   m_ulPopulation = 0;
}

~simplequeue()
{
   while (first)
   {
      simplequeuenode *ptr = first;
      first = first ->next;
      delete ptr;
   }
   first = last = NULL;
}

simplequeue( const simplequeue<Q> &P)
{
     if( P.first )
     {
         erase();
         first = new simplequeuenode;
         first->simplequeueData = P.first->simplequeueData;
         simplequeuenode *currL = NULL;
         simplequeuenode *Pcurr = P.first->next;
         first->next = currL;
         while( Pcurr )
         {
                currL = new simplequeuenode;
                currL->simplequeueData = Pcurr->simplequeueData;
                Pcurr = Pcurr->next;
                currL = currL->next;
         }
     }
     else
     {
         first = last = NULL;
     }
     m_ulPopulation = P.m_ulPopulation;
}


simplequeue operator=(const simplequeue &P )
{
     if( P.first )
     {
         erase();
         first = new simplequeuenode;
         first->simplequeueData = P.first->simplequeueData;
         simplequeuenode *currL = NULL;
         simplequeuenode *Pcurr = P.first->next;
         first->next = currL;
         while( Pcurr )
         {
                currL = new simplequeuenode;
                currL->simplequeueData = Pcurr->simplequeueData;
                Pcurr = Pcurr->next;
                currL = currL->next;
         }
     }
     else
     {
         first = last = NULL;
     }
     m_ulPopulation = P.m_ulPopulation;
     return *this;
}


unsigned long census()
{
    return m_ulPopulation;
}


int desimplequeue( Q &d )
{
    if( first == NULL )
        return 0;

    simplequeuenode *p_qptr = NULL;
    p_qptr = first;
    d = first->simplequeueData;
    first = first->next;
    delete p_qptr;

    if( last == p_qptr )
        last = NULL;

    m_ulPopulation--;

    return 1;
} // desimplequeue( Q &d )


int ensimplequeue( Q d )
{
     simplequeuenode *newnode = new simplequeuenode;
     if( newnode == NULL )
         return 0;

     newnode->next = NULL;
     newnode->simplequeueData = d;

     if( !last ) // first node in simplequeue
     {
         first = newnode;
         last = newnode;
         last->next = newnode;
         last = newnode;
     
     }
     else
     {
         last->next = newnode;
         last = newnode;
     }

     m_ulPopulation++;

     return 1;
} // ensimplequeue( Q d )


void erase()
{
   while (first)
   {
      simplequeuenode *ptr = first;
      first = first->next;
      delete ptr;
   }
   first = NULL;
} // erase()


int isempty()
{
    return (first == NULL);
} // isempty()

int resetlast()
{
    if( first == NULL )
        return 1;
        
    last = first;
    while( last->next )
    {
           last = last->next;    
    }
    return 1;
}
};

template<class Q> istream& operator >> (istream &IS , simplequeue<Q> &A)
{
     if( IS )
     {
         Q D;
         IS >> D;
         A.ensimplequeue( D );
     }
     return IS;
} 

template<class Q> ostream& operator << (ostream &OS , simplequeue<Q>& A )
{
     if( A.first == NULL )
        return OS;

     A.last = A.first;
     while( A.last )
     {
            OS << A.last->simplequeueData;
            A.last = A.last->next;
     }
     A.resetlast();
     return OS;
} 
#endif  // SIMPLEQUEUE_CC

Internal Links

Parent Article: Programming Portfolio