Queues: C++ queue2 [41]

% g++ -o queue2 queue2.cc                        >tcc queue2.cpp
% queue2
% 0

% queue3                                         // solution program
% 5

Queues: queue2.h [42]

static const Default_Size = 100;
template <class Element_Type>
class Queue {
  private:
    unsigned int Full_Queue;
    int Q_Front;
    int Q_Rear;
    int Q_Size;
    Element_Type *Q_Array;
    void Increment( int & X );
    Queue( const Queue & Value );
  public:
    Queue( unsigned int Max_Size = Default_Size );      // constructor
    ~Queue( ) { delete [ ] Q_Array; }                   // destructor
    const Queue & operator = ( const Queue & Value );
    void Enqueue( const Element_Type & X );
    Element_Type Dequeue( );
    void Make_Empty( );
    int Is_Empty( ) const { return Q_Size == 0; }
    int Is_Full( ) const { return Q_Size == Full_Queue; }
};

Queues: queue2.cc [43]

#include <iostream.h>
#include "queue2.h"
template <class Element_Type>
void Queue<Element_Type>::
Make_Empty( ) {
  Q_Front = 1;
  Q_Rear = 0;
  Q_Size = 0;
}
template <class Element_Type>
Queue<Element_Type>::
Queue( unsigned int Max_Size ) {
  Full_Queue = Max_Size;
  Make_Empty();
  Q_Array = new Element_Type[ Max_Size ];
  if (Q_Array == NULL )
    cout << "Out of space!" << endl;
}
template <class Element_Type>
void Queue<Element_Type>::
Increment( int & X ) {
  if (++X == Full_Queue )
    X = 0;
}

Arrays: queue2.cc [44]

template <class Element_Type>
void Queue<Element_Type>::
Enqueue( const Element_Type & X ) {
  if( Is_Full( ) )
    cout << "Queue is full" << endl;
  else {
    Q_Size++;
    Increment( Q_Rear );
    Q_Array[ Q_Rear ] = X;
  }
}

// Ex1 : complete the code for Dequeue
template <class Element_Type>
Element_Type Queue<Element_Type>::
Dequeue( ) {
  return Q_Array[ 0 ];
}
main ( ) {
  Queue<int> Q;
  Q.Enqueue(5);
  Q.Enqueue(3);
  cout << Q.Dequeue( ) << endl;           // output 5
}