queue (STL/CLR)

The template class describes an object that controls a varying-length sequence of elements that has first-in first-out access. You use the container adapter queue to manage an underlying container as a queue.

In the description below, GValue is the same as Value unless the latter is a ref type, in which case it is Value^. Similarly, GContainer is the same as Container unless the latter is a ref type, in which case it is Container^.

Syntax

template<typename Value,  
    typename Container>  
    ref class queue  
        :   public  
        System::ICloneable,  
        Microsoft::VisualC::StlClr::IQueue<GValue, GContainer>  
    { ..... };  

Parameters

Value
The type of an element in the controlled sequence.

Container
The type of the underlying container.

Requirements

Header: <cliext/queue>

Namespace: cliext

Declarations

Type Definition Description
queue::const_reference (STL/CLR) The type of a constant reference to an element.
queue::container_type (STL/CLR) The type of the underlying container.
queue::difference_type (STL/CLR) The type of a signed distance between two elements.
queue::generic_container (STL/CLR) The type of the generic interface for the container adapter.
queue::generic_value (STL/CLR) The type of an element for the generic interface for the container adapter.
queue::reference (STL/CLR) The type of a reference to an element.
queue::size_type (STL/CLR) The type of a signed distance between two elements.
queue::value_type (STL/CLR) The type of an element.
Member Function Description
queue::assign (STL/CLR) Replaces all elements.
queue::back (STL/CLR) Accesses the last element.
queue::empty (STL/CLR) Tests whether no elements are present.
queue::front (STL/CLR) Accesses the first element.
queue::get_container (STL/CLR) Accesses the underlying container.
queue::pop (STL/CLR) Removes the first element.
queue::push (STL/CLR) Adds a new last element.
queue::queue (STL/CLR) Constructs a container object.
queue::size (STL/CLR) Counts the number of elements.
queue::to_array (STL/CLR) Copies the controlled sequence to a new array.
Property Description
queue::back_item (STL/CLR) Accesses the last element.
queue::front_item (STL/CLR) Accesses the first element.
Operator Description
queue::operator= (STL/CLR) Replaces the controlled sequence.
operator!= (queue) (STL/CLR) Determines if a queue object is not equal to another queue object.
operator< (queue) (STL/CLR) Determines if a queue object is less than another queue object.
operator<= (queue) (STL/CLR) Determines if a queue object is less than or equal to another queue object.
operator== (queue) (STL/CLR) Determines if a queue object is equal to another queue object.
operator> (queue) (STL/CLR) Determines if a queue object is greater than another queue object.
operator>= (queue) (STL/CLR) Determines if a queue object is greater than or equal to another queue object.

Interfaces

Interface Description
ICloneable Duplicate an object.
IQueue<Value, Container> Maintain generic container adapter.

Remarks

The object allocates and frees storage for the sequence it controls through an underlying container, of type Container, that stores Value elements and grows on demand. The object restricts access to just pushing the first element and popping the last element, implementing a first-in first-out queue (also known as a FIFO queue, or simply a queue).

Members

queue::assign (STL/CLR)

Replaces all elements.

Syntax

void assign(queue<Value, Container>% right);  

Parameters

right
Container adapter to insert.

Remarks

The member function assigns right.get_container() to the underlying container. You use it to change the entire contents of the queue.

Example

// cliext_queue_assign.cpp   
// compile with: /clr   
#include <cliext/queue>   

typedef cliext::queue<wchar_t> Myqueue;   
int main()   
    {   
    Myqueue c1;   
    c1.push(L'a');   
    c1.push(L'b');   
    c1.push(L'c');   

// display initial contents " a b c"   
    for each (wchar_t elem in c1.get_container())   
        System::Console::Write(" {0}", elem);   
    System::Console::WriteLine();   

// assign a repetition of values   
    Myqueue c2;   
    c2.assign(c1);   
    for each (wchar_t elem in c2.get_container())   
        System::Console::Write(" {0}", elem);   
    System::Console::WriteLine();   
    return (0);   
    }  
a b c  
a b c  

queue::back (STL/CLR)

Accesses the last element.

Syntax

reference back();  

Remarks

The member function returns a reference to the last element of the controlled sequence, which must be non-empty. You use it to access the last element, when you know it exists.

Example

// cliext_queue_back.cpp   
// compile with: /clr   
#include <cliext/queue>   

typedef cliext::queue<wchar_t> Myqueue;   
int main()   
    {   
    Myqueue c1;   
    c1.push(L'a');   
    c1.push(L'b');   
    c1.push(L'c');   

// display initial contents " a b c"   
    for each (wchar_t elem in c1.get_container())   
        System::Console::Write(" {0}", elem);   
    System::Console::WriteLine();   

// inspect last item   
    System::Console::WriteLine("back() = {0}", c1.back());   

// alter last item and reinspect   
    c1.back() = L'x';   
    for each (wchar_t elem in c1.get_container())   
        System::Console::Write(" {0}", elem);   
    System::Console::WriteLine();   
    return (0);   
    }  
 a b c  
back() = c  
 a b x  

queue::back_item (STL/CLR)

Accesses the last element.

Syntax

property value_type back_item;  

Remarks

The property accesses the last element of the controlled sequence, which must be non-empty. You use it to read or write the last element, when you know it exists.

Example

// cliext_queue_back_item.cpp   
// compile with: /clr   
#include <cliext/queue>   

typedef cliext::queue<wchar_t> Myqueue;   
int main()   
    {   
    Myqueue c1;   
    c1.push(L'a');   
    c1.push(L'b');   
    c1.push(L'c');   

// display initial contents " a b c"   
    for each (wchar_t elem in c1.get_container())   
        System::Console::Write(" {0}", elem);   
    System::Console::WriteLine();   

// inspect last item   
    System::Console::WriteLine("back_item = {0}", c1.back_item);   

// alter last item and reinspect   
    c1.back_item = L'x';   
    for each (wchar_t elem in c1.get_container())   
        System::Console::Write(" {0}", elem);   
    System::Console::WriteLine();   
    return (0);   
    }  
 a b c  
back_item = c  
 a b x  

queue::const_reference (STL/CLR)

The type of a constant reference to an element.

Syntax

typedef value_type% const_reference;  

Remarks

The type describes a constant reference to an element.

Example

// cliext_queue_const_reference.cpp   
// compile with: /clr   
#include <cliext/queue>   

typedef cliext::queue<wchar_t> Myqueue;   
int main()   
    {   
    Myqueue c1;   
    c1.push(L'a');   
    c1.push(L'b');   
    c1.push(L'c');   

// display contents " a b c"   
    for (; !c1.empty(); c1.pop())   
        {   // get a const reference to an element   
        Myqueue::const_reference cref = c1.front();   
        System::Console::Write(" {0}", cref);   
        }   
    System::Console::WriteLine();   
    return (0);   
    }  
a b c  

queue::container_type (STL/CLR)

The type of the underlying container.

Syntax

typedef Container value_type;  

Remarks

The type is a synonym for the template parameter Container.

Example

// cliext_queue_container_type.cpp   
// compile with: /clr   
#include <cliext/queue>   

typedef cliext::queue<wchar_t> Myqueue;   
int main()   
    {   
    Myqueue c1;   
    c1.push(L'a');   
    c1.push(L'b');   
    c1.push(L'c');   

// display contents " a b c" using container_type   
    Myqueue::container_type wc1 = c1.get_container();   
    for each (wchar_t elem in wc1)   
        System::Console::Write(" {0}", elem);   
    System::Console::WriteLine();   
    return (0);   
    }  
a b c  

queue::difference_type (STL/CLR)

The types of a signed distance between two elements.

Syntax

typedef int difference_type;  

Remarks

The type describes a possibly negative element count.

Example

// cliext_queue_difference_type.cpp   
// compile with: /clr   
#include <cliext/queue>   

typedef cliext::queue<wchar_t> Myqueue;   
int main()   
    {   
    Myqueue c1;   
    c1.push(L'a');   
    c1.push(L'b');   
    c1.push(L'c');   

// display initial contents " a b c"   
    for each (wchar_t elem in c1.get_container())   
        System::Console::Write(" {0}", elem);   
    System::Console::WriteLine();   

// compute negative difference   
    Myqueue::difference_type diff = c1.size();   
    c1.push(L'd');   
    c1.push(L'e');   
    diff -= c1.size();   
    System::Console::WriteLine("pushing 2 = {0}", diff);   

// compute positive difference   
    diff = c1.size();   
    c1.pop();   
    c1.pop();   
    c1.pop();   
    diff -= c1.size();   
    System::Console::WriteLine("popping 3 = {0}", diff);   
    return (0);   
    }  
 a b c  
pushing 2 = -2  
popping 3 = 3  

queue::empty (STL/CLR)

Tests whether no elements are present.

Syntax

bool empty();  

Remarks

The member function returns true for an empty controlled sequence. It is equivalent to queue::size (STL/CLR)() == 0. You use it to test whether the queue is empty.

Example

// cliext_queue_empty.cpp   
// compile with: /clr   
#include <cliext/queue>   

typedef cliext::queue<wchar_t> Myqueue;   
int main()   
    {   
    Myqueue c1;   
    c1.push(L'a');   
    c1.push(L'b');   
    c1.push(L'c');   

// display initial contents " a b c"   
    for each (wchar_t elem in c1.get_container())   
        System::Console::Write(" {0}", elem);   
    System::Console::WriteLine();   
    System::Console::WriteLine("size() = {0}", c1.size());   
    System::Console::WriteLine("empty() = {0}", c1.empty());   

// clear the container and reinspect   
    c1.pop();   
    c1.pop();   
    c1.pop();   
    System::Console::WriteLine("size() = {0}", c1.size());   
    System::Console::WriteLine("empty() = {0}", c1.empty());   
    return (0);   
    }  
 a b c  
size() = 3  
empty() = False  
size() = 0  
empty() = True  

queue::front (STL/CLR)

Accesses the first element.

Syntax

reference front();  

Remarks

The member function returns a reference to the first element of the controlled sequence, which must be non-empty. You use it to access the first element, when you know it exists.

Example

// cliext_queue_front.cpp   
// compile with: /clr   
#include <cliext/queue>   

typedef cliext::queue<wchar_t> Myqueue;   
int main()   
    {   
    Myqueue c1;   
    c1.push(L'a');   
    c1.push(L'b');   
    c1.push(L'c');   

// display initial contents " a b c"   
    for each (wchar_t elem in c1.get_container())   
        System::Console::Write(" {0}", elem);   
    System::Console::WriteLine();   

// inspect first item   
    System::Console::WriteLine("front() = {0}", c1.front());   

// alter first item and reinspect   
    c1.front() = L'x';   
    for each (wchar_t elem in c1.get_container())   
        System::Console::Write(" {0}", elem);   
    System::Console::WriteLine();   
    return (0);   
    }  
 a b c  
front() = a  
 x b c  

queue::front_item (STL/CLR)

Accesses the first element.

Syntax

property value_type front_item;  

Remarks

The property accesses the first element of the controlled sequence, which must be non-empty. You use it to read or write the first element, when you know it exists.

Example

// cliext_queue_front_item.cpp   
// compile with: /clr   
#include <cliext/queue>   

typedef cliext::queue<wchar_t> Myqueue;   
int main()   
    {   
    Myqueue c1;   
    c1.push(L'a');   
    c1.push(L'b');   
    c1.push(L'c');   

// display initial contents " a b c"   
    for each (wchar_t elem in c1.get_container())   
        System::Console::Write(" {0}", elem);   
    System::Console::WriteLine();   

// inspect last item   
    System::Console::WriteLine("front_item = {0}", c1.front_item);   

// alter last item and reinspect   
    c1.front_item = L'x';   
    for each (wchar_t elem in c1.get_container())   
        System::Console::Write(" {0}", elem);   
    System::Console::WriteLine();   
    return (0);   
    }  
 a b c  
front_item = a  
 x b c  

queue::generic_container (STL/CLR)

The type of the generic interface for the container adapter.

Syntax

typedef Microsoft::VisualC::StlClr::IQueue<Value>  
    generic_container;  

Remarks

The type describes the generic interface for this template container adapter class.

Example

// cliext_queue_generic_container.cpp   
// compile with: /clr   
#include <cliext/queue>   

typedef cliext::queue<wchar_t> Myqueue;   
int main()   
    {   
    Myqueue c1;   
    c1.push(L'a');   
    c1.push(L'b');   
    c1.push(L'c');   

// display contents " a b c"   
    for each (wchar_t elem in c1.get_container())   
        System::Console::Write(" {0}", elem);   
    System::Console::WriteLine();   

// construct a generic container   
    Myqueue::generic_container^ gc1 = %c1;   
    for each (wchar_t elem in gc1->get_container())   
        System::Console::Write(" {0}", elem);   
    System::Console::WriteLine();   

// modify generic and display original   
    gc1->push(L'd');   
    for each (wchar_t elem in c1.get_container())   
        System::Console::Write(" {0}", elem);   
    System::Console::WriteLine();   

// modify original and display generic   
    c1.push(L'e');   
    for each (wchar_t elem in gc1->get_container())   
        System::Console::Write(" {0}", elem);   
    System::Console::WriteLine();   
    return (0);   
    }  
a b c  
a b c  
a b c d  
a b c d e  

queue::generic_value (STL/CLR)

The type of an element for use with the generic interface for the container.

Syntax

typedef GValue generic_value;  

Remarks

The type describes an object of type GValue that describes the stored element value for use with the generic interface for this template container class. (GValue is either value_type or value_type^ if value_type is a ref type.)

Example

// cliext_queue_generic_value.cpp   
// compile with: /clr   
#include <cliext/queue>   

typedef cliext::queue<wchar_t> Myqueue;   
int main()   
    {   
    Myqueue c1;   
    c1.push(L'a');   
    c1.push(L'b');   
    c1.push(L'c');   

// display contents " a b c"   
    for each (wchar_t elem in c1.get_container())   
        System::Console::Write(" {0}", elem);   
    System::Console::WriteLine();   

// get interface to container   
    Myqueue::generic_container^ gc1 = %c1;   
    for each (wchar_t elem in gc1->get_container())   
        System::Console::Write(" {0}", elem);   
    System::Console::WriteLine();   

// display in order using generic_value   
    for (; !gc1->empty(); gc1->pop())   
        {   
        Myqueue::generic_value elem = gc1->front();   

        System::Console::Write(" {0}", elem);   
        }   
    System::Console::WriteLine();   
    return (0);   
    }  
a b c  
a b c  
a b c  

queue::get_container (STL/CLR)

Accesses the underlying container.

Syntax

container_type^ get_container();  

Remarks

The member function returns the underlying container. You use it to bypass the restrictions imposed by the container wrapper.

Example

// cliext_queue_get_container.cpp   
// compile with: /clr   
#include <cliext/queue>   

typedef cliext::queue<wchar_t> Myqueue;   
int main()   
    {   
    Myqueue c1;   
    c1.push(L'a');   
    c1.push(L'b');   
    c1.push(L'c');   

// display initial contents " a b c"   
    for each (wchar_t elem in c1.get_container())   
        System::Console::Write(" {0}", elem);   
    System::Console::WriteLine();   
    return (0);   
    }  
a b c  

queue::operator= (STL/CLR)

Replaces the controlled sequence.

Syntax

queue <Value, Container>% operator=(queue <Value, Container>% right);  

Parameters

right
Container adapter to copy.

Remarks

The member operator copies right to the object, then returns *this. You use it to replace the controlled sequence with a copy of the controlled sequence in right.

Example

// cliext_queue_operator_as.cpp   
// compile with: /clr   
#include <cliext/queue>   

typedef cliext::queue<wchar_t> Myqueue;   
int main()   
    {   
    Myqueue c1;   
    c1.push(L'a');   
    c1.push(L'b');   
    c1.push(L'c');   

// display contents " a b c"   
    for each (wchar_t elem in c1.get_container())   
        System::Console::Write(" {0}", elem);   
    System::Console::WriteLine();   

// assign to a new container   
    Myqueue c2;   
    c2 = c1;   
    for each (wchar_t elem in c2.get_container())   
        System::Console::Write(" {0}", elem);   
    System::Console::WriteLine();   
    return (0);   
    }   
a b c  
a b c  

queue::pop (STL/CLR)

Removes the last element.

Syntax

void pop();  

Remarks

The member function removes the last element of the controlled sequence, which must be non-empty. You use it to shorten the queue by one element at the back.

Example

// cliext_queue_pop.cpp   
// compile with: /clr   
#include <cliext/queue>   

typedef cliext::queue<wchar_t> Myqueue;   
int main()   
    {   
    Myqueue c1;   
    c1.push(L'a');   
    c1.push(L'b');   
    c1.push(L'c');   

// display contents " a b c"   
    for each (wchar_t elem in c1.get_container())   
        System::Console::Write(" {0}", elem);   
    System::Console::WriteLine();   

// pop an element and redisplay   
    c1.pop();   
    for each (wchar_t elem in c1.get_container())   
        System::Console::Write(" {0}", elem);   
    System::Console::WriteLine();   
    return (0);   
    }  
a b c  
b c  

queue::push (STL/CLR)

Adds a new last element.

Syntax

void push(value_type val);  

Remarks

The member function adds an element with value val at the end of the queue. You use it to append an element to the queue.

Example

// cliext_queue_push.cpp   
// compile with: /clr   
#include <cliext/queue>   

typedef cliext::queue<wchar_t> Myqueue;   
int main()   
    {   
    Myqueue c1;   
    c1.push(L'a');   
    c1.push(L'b');   
    c1.push(L'c');   

// display contents " a b c"   
    for each (wchar_t elem in c1.get_container())   
        System::Console::Write(" {0}", elem);   
    System::Console::WriteLine();   
    return (0);   
    }  
a b c  

queue::queue (STL/CLR)

Constructs a container adapter object.

Syntax

queue();  
queue(queue<Value, Container>% right);  
queue(queue<Value, Container>^ right);  
explicit queue(container_type% wrapped);  

Parameters

right
Object to copy.

wrapped
Wrapped container to use.

Remarks

The constructor:

queue();

creates an empty wrapped container. You use it to specify an empty initial controlled sequence.

The constructor:

queue(queue<Value, Container>% right);

creates a wrapped container that is a copy of right.get_container(). You use it to specify an initial controlled sequence that is a copy of the sequence controlled by the queue object right.

The constructor:

queue(queue<Value, Container>^ right);

creates a wrapped container that is a copy of right->get_container(). You use it to specify an initial controlled sequence that is a copy of the sequence controlled by the queue object *right.

The constructor:

explicit queue(container_type wrapped);

uses the existing container wrapped as the wrapped container. You use it to construct a queue from an existing container.

Example

// cliext_queue_construct.cpp   
// compile with: /clr   
#include <cliext/queue>   
#include <cliext/list>   

typedef cliext::queue<wchar_t> Myqueue;   
typedef cliext::list<wchar_t> Mylist;   
typedef cliext::queue<wchar_t, Mylist> Myqueue_list;   
int main()   
    {   
// construct an empty container   
    Myqueue c1;   
    System::Console::WriteLine("size() = {0}", c1.size());   

// construct from an underlying container   
    Mylist v2(5, L'x');   
    Myqueue_list c2(v2);       
    for each (wchar_t elem in c2.get_container())   
        System::Console::Write(" {0}", elem);   
    System::Console::WriteLine();   

// construct by copying another container   
    Myqueue_list c3(c2);   
    for each (wchar_t elem in c3.get_container())   
        System::Console::Write(" {0}", elem);   
    System::Console::WriteLine();   

// construct by copying another container through handle   
    Myqueue_list c4(%c2);   
    for each (wchar_t elem in c4.get_container())   
        System::Console::Write(" {0}", elem);   
    System::Console::WriteLine();   
    return (0);   
    }  
size() = 0  
 x x x x x  
 x x x x x  
 x x x x x  

queue::reference (STL/CLR)

The type of a reference to an element.

Syntax

typedef value_type% reference;  

Remarks

The type describes a reference to an element.

Example

// cliext_queue_reference.cpp   
// compile with: /clr   
#include <cliext/queue>   

typedef cliext::queue<wchar_t> Myqueue;   
int main()   
    {   
    Myqueue c1;   
    c1.push(L'a');   
    c1.push(L'b');   
    c1.push(L'c');   

// display initial contents " a b c"   
    for each (wchar_t elem in c1.get_container())   
        System::Console::Write(" {0}", elem);   
    System::Console::WriteLine();   

// modify back of queue and redisplay   
    Myqueue::reference ref = c1.back();   
    ref = L'x';   
    for each (wchar_t elem in c1.get_container())   
        System::Console::Write(" {0}", elem);   
    System::Console::WriteLine();   
    return (0);   
    }  
a b c  
a b x  

queue::size (STL/CLR)

Counts the number of elements.

Syntax

size_type size();  

Remarks

The member function returns the length of the controlled sequence. You use it to determine the number of elements currently in the controlled sequence. If all you care about is whether the sequence has nonzero size, see queue::empty (STL/CLR)().

Example

// cliext_queue_size.cpp   
// compile with: /clr   
#include <cliext/queue>   

typedef cliext::queue<wchar_t> Myqueue;   
int main()   
    {   
    Myqueue c1;   
    c1.push(L'a');   
    c1.push(L'b');   
    c1.push(L'c');   

// display initial contents " a b c"   
    for each (wchar_t elem in c1.get_container())   
        System::Console::Write(" {0}", elem);   
    System::Console::WriteLine();   
    System::Console::WriteLine("size() = {0} starting with 3", c1.size());   

// pop an item and reinspect   
    c1.pop();   
    System::Console::WriteLine("size() = {0} after popping", c1.size());   

// add two elements and reinspect   
    c1.push(L'a');   
    c1.push(L'b');   
    System::Console::WriteLine("size() = {0} after adding 2", c1.size());   
    return (0);   
    }  
 a b c  
size() = 3 starting with 3  
size() = 2 after popping  
size() = 4 after adding 2  

queue::size_type (STL/CLR)

The type of a signed distance between two element.

Syntax

typedef int size_type;  

Remarks

The type describes a non-negative element count.

Example

// cliext_queue_size_type.cpp   
// compile with: /clr   
#include <cliext/queue>   

typedef cliext::queue<wchar_t> Myqueue;   
int main()   
    {   
    Myqueue c1;   
    c1.push(L'a');   
    c1.push(L'b');   
    c1.push(L'c');   

// display initial contents " a b c"   
    for each (wchar_t elem in c1.get_container())   
        System::Console::Write(" {0}", elem);   
    System::Console::WriteLine();   

// compute positive difference   
    Myqueue::size_type diff = c1.size();   
    c1.pop();   
    c1.pop();   
    diff -= c1.size();   
    System::Console::WriteLine("size difference = {0}", diff);   
    return (0);   
    }  
 a b c  
size difference = 2  

queue::to_array (STL/CLR)

Copies the controlled sequence to a new array.

Syntax

cli::array<Value>^ to_array();  

Remarks

The member function returns an array containing the controlled sequence. You use it to obtain a copy of the controlled sequence in array form.

Example

// cliext_queue_to_array.cpp   
// compile with: /clr   
#include <cliext/queue>   

typedef cliext::queue<wchar_t> Myqueue;   
int main()   
    {   
    Myqueue c1;   
    c1.push(L'a');   
    c1.push(L'b');   
    c1.push(L'c');   

// copy the container and modify it   
    cli::array<wchar_t>^ a1 = c1.to_array();   

    c1.push(L'd');   
    for each (wchar_t elem in c1.get_container())   
        System::Console::Write(" {0}", elem);   
    System::Console::WriteLine();   

// display the earlier array copy   
    for each (wchar_t elem in a1)   
        System::Console::Write(" {0}", elem);   
    System::Console::WriteLine();   
    return (0);   
    }  
a b c d  
a b c  

queue::value_type (STL/CLR)

The type of an element.

Syntax

typedef Value value_type;  

Remarks

The type is a synonym for the template parameter Value.

Example

// cliext_queue_value_type.cpp   
// compile with: /clr   
#include <cliext/queue>   

typedef cliext::queue<wchar_t> Myqueue;   
int main()   
    {   
    Myqueue c1;   
    c1.push(L'a');   
    c1.push(L'b');   
    c1.push(L'c');   

// display reversed contents " a b c" using value_type   
    for (; !c1.empty(); c1.pop())   
        {   // store element in value_type object   
        Myqueue::value_type val = c1.front();   

        System::Console::Write(" {0}", val);   
        }   
    System::Console::WriteLine();   
    return (0);   
    }   
a b c  

operator!= (queue) (STL/CLR)

Queue not equal comparison.

Syntax

template<typename Value,  
    typename Container>  
    bool operator!=(queue<Value, Container>% left,  
        queue<Value, Container>% right);  

Parameters

left
Left container to compare.

right
Right container to compare.

Remarks

The operator function returns !(left == right). You use it to test whether left is not ordered the same as right when the two queues are compared element by element.

Example

// cliext_queue_operator_ne.cpp   
// compile with: /clr   
#include <cliext/queue>   

typedef cliext::queue<wchar_t> Myqueue;   
int main()   
    {   
    Myqueue c1;   
    c1.push(L'a');   
    c1.push(L'b');   
    c1.push(L'c');   

// display contents " a b c"   
    for each (wchar_t elem in c1.get_container())   
        System::Console::Write(" {0}", elem);   
    System::Console::WriteLine();   

// assign to a new container   
    Myqueue c2;   
    c2.push(L'a');   
    c2.push(L'b');   
    c2.push(L'd');   

// display contents " a b d"   
    for each (wchar_t elem in c2.get_container())   
        System::Console::Write(" {0}", elem);   
    System::Console::WriteLine();   

    System::Console::WriteLine("[a b c] != [a b c] is {0}",   
        c1 != c1);   
    System::Console::WriteLine("[a b c] != [a b d] is {0}",   
        c1 != c2);   
    return (0);   
    }  
 a b c  
 a b d  
[a b c] != [a b c] is False  
[a b c] != [a b d] is True  

operator< (queue) (STL/CLR)

Queue less than comparison.

Syntax

template<typename Value,  
    typename Container>  
    bool operator<(queue<Value, Container>% left,  
        queue<Value, Container>% right);  

Parameters

left
Left container to compare.

right
Right container to compare.

Remarks

The operator function returns true if, for the lowest position i for which !(right[i] < left[i]) it is also true that left[i] < right[i]. Otherwise, it returns left->queue::size (STL/CLR)() < right->size() You use it to test whether left is ordered before right when the two queues are compared element by element.

Example

// cliext_queue_operator_lt.cpp   
// compile with: /clr   
#include <cliext/queue>   

typedef cliext::queue<wchar_t> Myqueue;   
int main()   
    {   
    Myqueue c1;   
    c1.push(L'a');   
    c1.push(L'b');   
    c1.push(L'c');   

// display contents " a b c"   
    for each (wchar_t elem in c1.get_container())   
        System::Console::Write(" {0}", elem);   
    System::Console::WriteLine();   

// assign to a new container   
    Myqueue c2;   
    c2.push(L'a');   
    c2.push(L'b');   
    c2.push(L'd');   

// display contents " a b d"   
    for each (wchar_t elem in c2.get_container())   
        System::Console::Write(" {0}", elem);   
    System::Console::WriteLine();   

    System::Console::WriteLine("[a b c] < [a b c] is {0}",   
        c1 < c1);   
    System::Console::WriteLine("[a b c] < [a b d] is {0}",   
        c1 < c2);   
    return (0);   
    }   
 a b c  
 a b d  
[a b c] < [a b c] is False  
[a b c] < [a b d] is True  

operator<= (queue) (STL/CLR)

Queue less than or equal comparison.

Syntax

template<typename Value,  
    typename Container>  
    bool operator<=(queue<Value, Container>% left,  
        queue<Value, Container>% right);  

Parameters

left
Left container to compare.

right
Right container to compare.

Remarks

The operator function returns !(right < left). You use it to test whether left is not ordered after right when the two queues are compared element by element.

Example

// cliext_queue_operator_le.cpp   
// compile with: /clr   
#include <cliext/queue>   

typedef cliext::queue<wchar_t> Myqueue;   
int main()   
    {   
    Myqueue c1;   
    c1.push(L'a');   
    c1.push(L'b');   
    c1.push(L'c');   

// display contents " a b c"   
    for each (wchar_t elem in c1.get_container())   
        System::Console::Write(" {0}", elem);   
    System::Console::WriteLine();   

// assign to a new container   
    Myqueue c2;   
    c2.push(L'a');   
    c2.push(L'b');   
    c2.push(L'd');   

// display contents " a b d"   
    for each (wchar_t elem in c2.get_container())   
        System::Console::Write(" {0}", elem);   
    System::Console::WriteLine();   

    System::Console::WriteLine("[a b c] <= [a b c] is {0}",   
        c1 <= c1);   
    System::Console::WriteLine("[a b d] <= [a b c] is {0}",   
        c2 <= c1);   
    return (0);   
    }   
 a b c  
 a b d  
[a b c] <= [a b c] is True  
[a b d] <= [a b c] is False  

operator== (queue) (STL/CLR)

Queue equal comparison.

Syntax

template<typename Value,  
    typename Container>  
    bool operator==(queue<Value, Container>% left,  
        queue<Value, Container>% right);  

Parameters

left
Left container to compare.

right
Right container to compare.

Remarks

The operator function returns true only if the sequences controlled by left and right have the same length and, for each position i, left[i] == right[i]. You use it to test whether left is ordered the same as right when the two queues are compared element by element.

Example

// cliext_queue_operator_eq.cpp   
// compile with: /clr   
#include <cliext/queue>   

typedef cliext::queue<wchar_t> Myqueue;   
int main()   
    {   
    Myqueue c1;   
    c1.push(L'a');   
    c1.push(L'b');   
    c1.push(L'c');   

// display contents " a b c"   
    for each (wchar_t elem in c1.get_container())   
        System::Console::Write(" {0}", elem);   
    System::Console::WriteLine();   

// assign to a new container   
    Myqueue c2;   
    c2.push(L'a');   
    c2.push(L'b');   
    c2.push(L'd');   

// display contents " a b d"   
    for each (wchar_t elem in c2.get_container())   
        System::Console::Write(" {0}", elem);   
    System::Console::WriteLine();   

    System::Console::WriteLine("[a b c] == [a b c] is {0}",   
        c1 == c1);   
    System::Console::WriteLine("[a b c] == [a b d] is {0}",   
        c1 == c2);   
    return (0);   
    }   
 a b c  
 a b d  
[a b c] == [a b c] is True  
[a b c] == [a b d] is False  

operator> (queue) (STL/CLR)

Queue greater than comparison.

Syntax

template<typename Value,  
    typename Container>  
    bool operator>(queue<Value, Container>% left,  
        queue<Value, Container>% right);  

Parameters

left
Left container to compare.

right
Right container to compare.

Remarks

The operator function returns right < left. You use it to test whether left is ordered after right when the two queues are compared element by element.

Example

// cliext_queue_operator_gt.cpp   
// compile with: /clr   
#include <cliext/queue>   

typedef cliext::queue<wchar_t> Myqueue;   
int main()   
    {   
    Myqueue c1;   
    c1.push(L'a');   
    c1.push(L'b');   
    c1.push(L'c');   

// display contents " a b c"   
    for each (wchar_t elem in c1.get_container())   
        System::Console::Write(" {0}", elem);   
    System::Console::WriteLine();   

// assign to a new container   
    Myqueue c2;   
    c2.push(L'a');   
    c2.push(L'b');   
    c2.push(L'd');   

// display contents " a b d"   
    for each (wchar_t elem in c2.get_container())   
        System::Console::Write(" {0}", elem);   
    System::Console::WriteLine();   

    System::Console::WriteLine("[a b c] > [a b c] is {0}",   
        c1 > c1);   
    System::Console::WriteLine("[a b d] > [a b c] is {0}",   
        c2 > c1);   
    return (0);   
    }   
 a b c  
 a b d  
[a b c] > [a b c] is False  
[a b d] > [a b c] is True  

operator>= (queue) (STL/CLR)

Queue greater than or equal comparison.

Syntax

template<typename Value,  
    typename Container>  
    bool operator>=(queue<Value, Container>% left,  
        queue<Value, Container>% right);  

Parameters

left
Left container to compare.

right
Right container to compare.

Remarks

The operator function returns !(left < right). You use it to test whether left is not ordered before right when the two queues are compared element by element.

Example

// cliext_queue_operator_ge.cpp   
// compile with: /clr   
#include <cliext/queue>   

typedef cliext::queue<wchar_t> Myqueue;   
int main()   
    {   
    Myqueue c1;   
    c1.push(L'a');   
    c1.push(L'b');   
    c1.push(L'c');   

// display contents " a b c"   
    for each (wchar_t elem in c1.get_container())   
        System::Console::Write(" {0}", elem);   
    System::Console::WriteLine();   

// assign to a new container   
    Myqueue c2;   
    c2.push(L'a');   
    c2.push(L'b');   
    c2.push(L'd');   

// display contents " a b d"   
    for each (wchar_t elem in c2.get_container())   
        System::Console::Write(" {0}", elem);   
    System::Console::WriteLine();   

    System::Console::WriteLine("[a b c] >= [a b c] is {0}",   
        c1 >= c1);   
    System::Console::WriteLine("[a b c] >= [a b d] is {0}",   
        c1 >= c2);   
    return (0);   
    }   
 a b c  
 a b d  
[a b c] >= [a b c] is True  
[a b c] >= [a b d] is False