Standard C++	Library
 		 Copyright 1996, Rogue Wave Software, Inc.

 NAME

   queue	 - A container adaptor that behaves like a queue (first	in,
   first out).

   This page describes ANSI queue class.	If you would like information
   on the HP C++ task queue class, use	the command:

        help cxxl

 SYNOPSIS

   #include <queue>

   template <class T, class Container = deque<T>	> class	queue ;

 DESCRIPTION

   The queue container adaptor lets a container function	as a queue.
   In	a queue, items are pushed into the back	of the container and
   removed from the front.  The first items pushed into the queue are
   the	first items to be popped off of	the queue (first in,  first
   out,	or "FIFO").

   queue	can adapt any container	that supports the front(), back(),
   push_back() and pop_front() operations.  In particular, deque	and
   list can be used.

 INTERFACE

   template <class T, class Container = deque<T>	>
   class	queue {

   public:

   // typedefs

     typedef typename Container::value_type value_type;
     typedef typename Container::size_type size_type;
     typedef typename Container::allocator_type allocator_type;

   // Construct/Copy/Destroy
     explicit queue (const allocator_type& = allocator_type());
     allocator_type get_allocator () const;

   // Accessors

     bool empty () const;
     size_type size () const;
     value_type&	front ();
     const value_type& front () const;
     value_type&	back ();
     const value_type& back () const;
     void push (const value_type&);
     void pop ();
   };

   // Non-member	Operators

   template <class T, class Container>
   bool operator== (const queue<T, Container>&,
 		   const queue<T, Container>&);

   template <class T, class Container>
   bool operator!= (const queue<T, Container>&,
 		   const queue<T, Container>&);

   template <class T, class Container>
   bool operator< (const	queue<T, Container>&,
 		  const	queue<T, Container>&);

   template <class T, class Container>
   bool operator> (const	queue<T, Container>&,
 		  const	queue<T, Container>&);

   template <class T, class Container>
   bool operator<= (const queue<T, Container>&,
 		  const	queue<T, Container>&);

   template <class T, class Container>
   bool operator>= (const queue<T, Container>&,
 		  const	queue<T, Container>&);

 CONSTRUCTORS

   explicit queue (const	allocator_type&	alloc= allocator_type());
      Creates a queue of	zero elements.	The queue will use the
      allocator alloc for all storage management.

 ALLOCATOR

   allocator_type get_allocator () const;
      Returns a copy of the allocator used by self for storage
      management.

 MEMBER FUNCTIONS

   value_type&
   back ();
      Returns a reference to the	item at	the back of the	queue (the
      last	item pushed into the queue).

   const	value_type&
   back() const;
      Returns a constant	reference to the item at the back of the queue
      as a const_value_type.

   bool
   empty	() const;
      Returns true if the queue is empty, otherwise false.

   value_type&
   front	();
      Returns a reference to the	item at	the front of the queue.	  This
      will be the first item pushed onto	the queue unless pop()  has
      been	called since then.

   const	value_type&
   front	() const;
      Returns a constant	reference to  the item at the front of the
      queue as a const_value_type.

   void
   pop ();
      Removes the item at the front of the queue.

   void
   push (const value_type& x);
      Pushes x onto the back of the queue.

   size_type
   size () const;
      Returns the number	of elements on the queue.

 NON-MEMBER OPERATORS

   template <class T, class Container>
    bool	operator== (const queue<T, Container>& x,
 		    const queue<T, Container>& y);
      Equality operator.  Returns true if x	is the  same as y.

   template <class T, class Container>
    bool	operator!= (const queue<T, Container>& x,
 		    const queue<T, Container>& y);
      Inequality operator.	Returns	!(x==y).

   template <class T, class Container>
    bool	operator< (const queue<T, Container>& x,
 		   const queue<T, Container>& y);
      Returns true if the queue	defined	by the  elements
      contained in	x is	lexicographically  less than the
      queue defined by the elements  contained	in y.

   template <class T, class Container>
    bool	operator> (const queue<T, Container>& x,
 		   const queue<T, Container>& y);
 		      Returns y	< x.

   template <class T, class Container>
    bool	operator< (const queue<T, Container>& x,
 		   const queue<T, Container>& y);
 		      Returns !(y < x).

   template <class T, class Container>
    bool	operator< (const queue<T, Container>& x,
 		   const queue<T, Container>& y);
 		      Returns !(x < y).

 EXAMPLE

   //
   // queue.cpp
   //
    #include <queue>
    #include <string>
    #include <deque>
    #include <list>
    #include <iostream.h>

   int main(void)
    {
      //	Make a queue using a list container
      queue<int,	list<int>> q;

      //	Push a couple of values	on then	pop them off
     q.push(1);
     q.push(2);
     cout << q.front() << endl;
     q.pop();
     cout << q.front() << endl;
     q.pop();

      //	Make a queue of	strings	using a	deque container
      queue<string,deque<string>> qs;

      //	Push on	a few strings then pop them back off
     int	i;
     for	(i = 0;	i < 10;	i++)
      {
       qs.push(string(i+1,'a'));
       cout << qs.front() << endl;
      }
     for	(i = 0;	i < 10;	i++)
      {
       cout << qs.front() << endl;
       qs.pop();
      }

     return 0;
    }

   Output :
   1
   2
   a
   a
   a
   a
   a
   a
   a
   a
   a
   a
   a
   aa
   aaa
   aaaa
   aaaaa
   aaaaaa
   aaaaaaa
   aaaaaaaa
   aaaaaaaaa
   aaaaaaaaaa

 WARNINGS

   If your compiler does	not support default template  parameters, you
   must always provide a Container template	parameter.  For
   example you would not be able to write:

   queue<int> var;

   rather, you would have to write,

   queue<int, deque<int>	> var;

 SEE ALSO

   allocator, Containers, priority_queue

 STANDARDS CONFORMANCE
   ANSI X3J16/ISO WG21 Joint C++	Committee