`queue` (STL/CLR)

Makale
10/12/2023

Şablon sınıfı, ilk ilk çıkış erişimi olan öğelerin farklı uzunluk dizisini denetleen bir nesneyi açıklar. Temel alınan kapsayıcıyı kuyruk olarak yönetmek için kapsayıcı bağdaştırıcısını queue kullanın.

Aşağıdaki açıklamada, GValue ikincisi bir başvuru türü olmadığı sürece ile aynıdır Value ; bu durumda ise olur Value^. Benzer şekilde, GContainer ikincisi bir başvuru türü olmadığı sürece ile aynıdır Container ; bu Container^durumda olur.

Sözdizimi

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

Parametreler

Value
Denetlenen sıradaki öğenin türü.

Container
Temel alınan kapsayıcının türü.

Gereksinimler

Üstbilgi: <cliext/queue>

Ad alanı: cliext

Önemli

Bu konudaki örnekleri derlemek için, Visual Studio 2022'de C++/CLI desteğini yükleme bölümünde açıklandığı gibi C++/CLI desteğini yüklediğinizden emin olun. Proje türü için bir CLR Konsol uygulaması (.NET Framework) oluşturun.

Bildirimler

Tür tanımı	Açıklama
`queue::const_reference`	Bir öğe için sabit bir başvuru türü.
`queue::container_type`	Temel alınan kapsayıcının türü.
`queue::difference_type`	İki öğe arasındaki işaretli mesafenin türü.
`queue::generic_container`	Kapsayıcı bağdaştırıcısı için genel arabirimin türü.
`queue::generic_value`	Kapsayıcı bağdaştırıcısının genel arabirimi için bir öğenin türü.
`queue::reference`	Bir öğe için bir başvuru türü.
`queue::size_type`	İki öğe arasındaki işaretli mesafenin türü.
`queue::value_type`	Öğenin türü.

Üye işlevi	Açıklama
`queue::assign`	Tüm öğeleri değiştirir.
`queue::back`	Son öğeye erişir.
`queue::empty`	Bir öğe olup olmadığını sınar.
`queue::front`	İlk öğeye erişir.
`queue::get_container`	Temel kapsayıcıya erişir.
`queue::pop`	İlk öğeyi kaldırır.
`queue::push`	Yeni bir son öğe ekler.
`queue::queue`	Bir kapsayıcı nesnesi oluşturur.
`queue::size`	Öğe sayısını sayar.
`queue::to_array`	Denetimli diziyi yeni bir diziye kopyalar.

Özellik	Açıklama
`queue::back_item`	Son öğeye erişir.
`queue::front_item`	İlk öğeye erişir.

Operator	Açıklama
`queue::operator=`	Denetimli sıranın yerini alır.
`operator!=` (kuyruk)	Bir nesnenin başka `queue` bir `queue` nesneye eşit olup olmadığını belirler.
`operator<` (kuyruk)	Bir nesnenin başka `queue` bir `queue` nesneden küçük olup olmadığını belirler.
`operator<=` (kuyruk)	Bir nesnenin başka bir nesneden küçük veya başka bir `queue` `queue` nesneye eşit olup olmadığını belirler.
`operator==` (kuyruk)	Bir nesnenin başka `queue` bir `queue` nesneye eşit olup olmadığını belirler.
`operator>` (kuyruk)	Bir nesnenin başka `queue` bir `queue` nesneden büyük olup olmadığını belirler.
`operator>=` (kuyruk)	Bir nesnenin başka bir nesneden büyük veya başka bir `queue` `queue` nesneye eşit olup olmadığını belirler.

Arabirimler

Arabirim	Açıklama
ICloneable	Nesneyi çoğaltma.
`IQueue<Value, Container>`	Genel kapsayıcı bağdaştırıcısını koruyun.

Açıklamalar

nesnesi, öğeleri depolayan Value ve isteğe bağlı olarak büyüyen temel kapsayıcı türü Container aracılığıyla denetlediği sıra için depolama ayırır ve serbesttir. nesnesi, erişimi yalnızca ilk öğeyi gönderme ve son öğeyi açma, ilk gelen ilk çıkış kuyruğu (FIFO kuyruğu veya yalnızca kuyruk olarak da bilinir) uygulamayla kısıtlar.

Üyeler

`queue::assign`

Tüm öğeleri değiştirir.

Sözdizimi

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

Parametreler

right
Eklenecek kapsayıcı bağdaştırıcısı.

Açıklamalar

Üye işlevi, temel alınan kapsayıcıya atar right.get_container() . Kuyruğun tüm içeriğini değiştirmek için bunu kullanırsınız.

Örnek

// cliext_queue_assign.cpp
// compile with: /clr
#include "pch.h"
#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`

Son öğeye erişir.

Sözdizimi

reference back();

Açıklamalar

Üye işlevi, denetlenen dizinin son öğesine başvuru döndürür ve bu öğe boş olmalıdır. Var olduğunu bildiğinizde son öğeye erişmek için bu öğeyi kullanırsınız.

Örnek

// cliext_queue_back.cpp
// compile with: /clr
#include "pch.h"
#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`

Son öğeye erişir.

Sözdizimi

property value_type back_item;

Açıklamalar

özelliği, denetlenen dizinin son öğesine erişir ve bu öğenin boş olması gerekir. Var olduğunu bildiğinizde son öğeyi okumak veya yazmak için bunu kullanırsınız.

Örnek

// cliext_queue_back_item.cpp
// compile with: /clr
#include "pch.h"
#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`

Bir öğe için sabit bir başvuru türü.

Sözdizimi

typedef value_type% const_reference;

Açıklamalar

türü, bir öğeye sabit başvuruyu açıklar.

Örnek

// cliext_queue_const_reference.cpp
// compile with: /clr
#include "pch.h"
#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`

Temel alınan kapsayıcının türü.

Sözdizimi

typedef Container value_type;

Açıklamalar

türü, şablon parametresi Containeriçin bir eş anlamlıdır.

Örnek

// cliext_queue_container_type.cpp
// compile with: /clr
#include "pch.h"
#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`

İki öğe arasındaki imzalı uzaklık türleri.

Sözdizimi

typedef int difference_type;

Açıklamalar

Türü, büyük olasılıkla negatif öğe sayısını açıklar.

Örnek

// cliext_queue_difference_type.cpp
// compile with: /clr
#include "pch.h"
#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`

Bir öğe olup olmadığını sınar.

Sözdizimi

bool empty();

Açıklamalar

Üye işlevi boş denetimli bir dizi için true döndürür. ile eşdeğerdir size() == 0. Boş olup olmadığını queue test etmek için bunu kullanırsınız.

Örnek

// cliext_queue_empty.cpp
// compile with: /clr
#include "pch.h"
#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`

İlk öğeye erişir.

Sözdizimi

reference front();

Açıklamalar

Üye işlevi, denetlenen dizinin ilk öğesine başvuru döndürür ve bu öğe boş olmalıdır. Var olduğunu bildiğinizde ilk öğeye erişmek için bu öğeyi kullanırsınız.

Örnek

// cliext_queue_front.cpp
// compile with: /clr
#include "pch.h"
#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`

İlk öğeye erişir.

Sözdizimi

property value_type front_item;

Açıklamalar

özelliği, denetimli dizinin ilk öğesine erişir ve bu öğenin boş olması gerekir. Var olduğunu bildiğinizde ilk öğeyi okumak veya yazmak için bunu kullanırsınız.

Örnek

// cliext_queue_front_item.cpp
// compile with: /clr
#include "pch.h"
#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`

Kapsayıcı bağdaştırıcısı için genel arabirimin türü.

Sözdizimi

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

Açıklamalar

türü, bu şablon kapsayıcı bağdaştırıcısı sınıfı için genel arabirimi açıklar.

Örnek

// cliext_queue_generic_container.cpp
// compile with: /clr
#include "pch.h"
#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`

Kapsayıcının genel arabirimiyle kullanılacak bir öğenin türü.

Sözdizimi

typedef GValue generic_value;

Açıklamalar

türü, bu şablon kapsayıcı sınıfı için genel arabirimle kullanılmak üzere depolanan öğe değerini açıklayan türdeki GValue bir nesneyi açıklar. (GValue veya value_type^ bir başvuru türüysevalue_type.)value_type

Örnek

// cliext_queue_generic_value.cpp
// compile with: /clr
#include "pch.h"
#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`

Temel kapsayıcıya erişir.

Sözdizimi

container_type^ get_container();

Açıklamalar

Üye işlevi temel kapsayıcıyı döndürür. Kapsayıcı sarmalayıcısı tarafından uygulanan kısıtlamaları atlamak için bunu kullanırsınız.

Örnek

// cliext_queue_get_container.cpp
// compile with: /clr
#include "pch.h"
#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=`

Denetimli sıranın yerini alır.

Sözdizimi

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

Parametreler

right
Kopyalanacak kapsayıcı bağdaştırıcısı.

Açıklamalar

Üye işleci nesnesine kopyalanır right ve döndürür *this. Denetimli sırayı içindeki rightdenetimli sıranın bir kopyasıyla değiştirmek için kullanırsınız.

Örnek

// cliext_queue_operator_as.cpp
// compile with: /clr
#include "pch.h"
#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`

İlk öğeyi kaldırır.

Sözdizimi

void pop();

Açıklamalar

Denetlenen sıranın ilk öğesini kaldırır ve bu öğenin boş olması gerekir.

Örnek

// cliext_queue_pop.cpp
// compile with: /clr
#include "pch.h"
#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`

Yeni bir son öğe ekler.

Sözdizimi

void push(value_type val);

Açıklamalar

üye işlevi, kuyruğun sonuna değeri val olan bir öğe ekler. Kuyruğa bir öğe eklemek için bunu kullanırsınız.

Örnek

// cliext_queue_push.cpp
// compile with: /clr
#include "pch.h"
#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`

Kapsayıcı bağdaştırıcısı nesnesi oluşturur.

Sözdizimi

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

Parametreler

right
Kopyalanacak nesne.

wrapped
Kullanılacak sarmalanmış kapsayıcı.

Açıklamalar

Oluşturucu:

queue();

boş bir sarmalanmış kapsayıcı oluşturur. Boş bir ilk denetimli sıra belirtmek için bunu kullanırsınız.

Oluşturucu:

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

, öğesinin bir kopyası right.get_container()olan sarmalanmış bir kapsayıcı oluşturur. bunu, nesnesi righttarafından denetlenen dizinin bir kopyası olan ilk denetimli diziyi queue belirtmek için kullanırsınız.

Oluşturucu:

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

, öğesinin bir kopyası right->get_container()olan sarmalanmış bir kapsayıcı oluşturur. bunu, nesnesi *righttarafından denetlenen dizinin bir kopyası olan ilk denetimli diziyi queue belirtmek için kullanırsınız.

Oluşturucu:

explicit queue(container_type wrapped);

var olan kapsayıcıyı wrapped sarmalanmış kapsayıcı olarak kullanır. Varolan bir kapsayıcıdan oluşturmak queue için bunu kullanırsınız.

Örnek

// cliext_queue_construct.cpp
// compile with: /clr
#include "pch.h"
#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`

Bir öğe için bir başvuru türü.

Sözdizimi

typedef value_type% reference;

Açıklamalar

türü, bir öğeye başvuruyu açıklar.

Örnek

// cliext_queue_reference.cpp
// compile with: /clr
#include "pch.h"
#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`

Öğe sayısını sayar.

Sözdizimi

size_type size();

Açıklamalar

Üye işlevi, denetlenen sıranın uzunluğunu döndürür. Şu anda denetimli dizideki öğelerin sayısını belirlemek için bunu kullanırsınız. Tek ilgilendiğiniz dizinin sıfır olmayan boyuta sahip olup olmadığıysa, bkz empty(). .

Örnek

// cliext_queue_size.cpp
// compile with: /clr
#include "pch.h"
#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`

İki öğe arasındaki işaretli mesafenin türü.

Sözdizimi

typedef int size_type;

Açıklamalar

Türü negatif olmayan öğe sayısını açıklar.

Örnek

// cliext_queue_size_type.cpp
// compile with: /clr
#include "pch.h"
#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`

Denetimli diziyi yeni bir diziye kopyalar.

Sözdizimi

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

Açıklamalar

üye işlevi, denetlenen diziyi içeren bir dizi döndürür. Denetimli sıranın bir kopyasını dizi biçiminde almak için bunu kullanırsınız.

Örnek

// cliext_queue_to_array.cpp
// compile with: /clr
#include "pch.h"
#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`

Öğenin türü.

Sözdizimi

typedef Value value_type;

Açıklamalar

türü, şablon parametresi Valueiçin bir eş anlamlıdır.

Örnek

// cliext_queue_value_type.cpp
// compile with: /clr
#include "pch.h"
#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!=` (kuyruk)

Queue eşit olmayan karşılaştırma.

Sözdizimi

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

Parametreler

left
Karşılaştırmak için sol kapsayıcı.

right
Karşılaştırmak için doğru kapsayıcı.

Açıklamalar

işleç işlevi döndürür !(left == right). İki kuyruğun öğeye göre karşılaştırıldığında olduğu gibi right sıralanıp sıralı olmadığını test left etmek için bunu kullanırsınız.

Örnek

// cliext_queue_operator_ne.cpp
// compile with: /clr
#include "pch.h"
#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<` (kuyruk)

Queue küçüktür karşılaştırması.

Sözdizimi

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

Parametreler

left
Karşılaştırmak için sol kapsayıcı.

right
Karşılaştırmak için doğru kapsayıcı.

Açıklamalar

işleç işlevi, aynı zamanda doğru olduğu en düşük konum i için !(right[i] < left[i]) ise true left[i] < right[i]döndürür. Aksi takdirde döndürür left->size() < right->size(). İki kuyruk öğeye göre karşılaştırıldığında önce right sıralanıp sıralı olmadığını left test etmek için bunu kullanırsınız.

Örnek

// cliext_queue_operator_lt.cpp
// compile with: /clr
#include "pch.h"
#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<=` (kuyruk)

Queue küçük veya eşit karşılaştırma.

Sözdizimi

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

Parametreler

left
Karşılaştırmak için sol kapsayıcı.

right
Karşılaştırmak için doğru kapsayıcı.

Açıklamalar

işleç işlevi döndürür !(right < left). İki kuyruk öğeye göre karşılaştırıldıktan sonra right sıralanıp left sıralı olmadığını test etmek için bunu kullanırsınız.

Örnek

// cliext_queue_operator_le.cpp
// compile with: /clr
#include "pch.h"
#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==` (kuyruk)

Queue eşittir karşılaştırması.

Sözdizimi

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

Parametreler

left
Karşılaştırmak için sol kapsayıcı.

right
Karşılaştırmak için doğru kapsayıcı.

Açıklamalar

işleç işlevi yalnızca tarafından left denetlenen ve right her konum ileft[i] == right[i]için aynı uzunluğa sahip olan diziler için true döndürür. İki kuyruğun öğeye göre karşılaştırıldığında olduğu gibi right sıralanıp sıralı olmadığını left test etmek için bunu kullanırsınız.

Örnek

// cliext_queue_operator_eq.cpp
// compile with: /clr
#include "pch.h"
#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>` (kuyruk)

Queue karşılaştırmadan büyük.

Sözdizimi

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

Parametreler

left
Karşılaştırmak için sol kapsayıcı.

right
Karşılaştırmak için doğru kapsayıcı.

Açıklamalar

işleç işlevi döndürür right < left. İki kuyruk öğeye göre karşılaştırıldıktan sonra right sıralanıp sıralı olmadığını left test etmek için bunu kullanırsınız.

Örnek

// cliext_queue_operator_gt.cpp
// compile with: /clr
#include "pch.h"
#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>=` (kuyruk)

Queue büyük veya eşit karşılaştırma.

Sözdizimi

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

Parametreler

left
Karşılaştırmak için sol kapsayıcı.

right
Karşılaştırmak için doğru kapsayıcı.

Açıklamalar

işleç işlevi döndürür !(left < right). İki kuyruğun öğeye göre karşılaştırıldığında önce right sıralanıp left sıralı olmadığını test etmek için bunu kullanırsınız.

Örnek

// cliext_queue_operator_ge.cpp
// compile with: /clr
#include "pch.h"
#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

Aracılığıyla paylaş

queue (STL/CLR)

Sözdizimi

Parametreler

Gereksinimler

Bildirimler

Arabirimler

Açıklamalar

Üyeler

queue::assign

Sözdizimi

Parametreler

Açıklamalar

Örnek

queue::back

Sözdizimi

Açıklamalar

Örnek

queue::back_item

Sözdizimi

Açıklamalar

Örnek

queue::const_reference

Sözdizimi

Açıklamalar

Örnek

queue::container_type

Sözdizimi

Açıklamalar

Örnek

queue::difference_type

Sözdizimi

Açıklamalar

Örnek

queue::empty

Sözdizimi

Açıklamalar

Örnek

queue::front

Sözdizimi

Açıklamalar

Örnek

queue::front_item

Sözdizimi

Açıklamalar

Örnek

queue::generic_container

Sözdizimi

Açıklamalar

Örnek

queue::generic_value

Sözdizimi

Açıklamalar

Örnek

queue::get_container

Sözdizimi

Açıklamalar

Örnek

queue::operator=

Sözdizimi

Parametreler

Açıklamalar

Örnek

queue::pop

Sözdizimi

Açıklamalar

Örnek

queue::push

Sözdizimi

Açıklamalar

Örnek

queue::queue

Sözdizimi

Parametreler

Açıklamalar

Örnek

queue::reference

Sözdizimi

Açıklamalar

Örnek

`queue` (STL/CLR)

`queue::assign`

`queue::back`

`queue::back_item`

`queue::const_reference`

`queue::container_type`

`queue::difference_type`

`queue::empty`

`queue::front`

`queue::front_item`

`queue::generic_container`

`queue::generic_value`

`queue::get_container`

`queue::operator=`

`queue::pop`

`queue::push`

`queue::queue`

`queue::reference`

`queue::size`

`queue::size_type`

`queue::to_array`

`queue::value_type`

`operator!=` (kuyruk)

`operator<` (kuyruk)

`operator<=` (kuyruk)

`operator==` (kuyruk)

`operator>` (kuyruk)

`operator>=` (kuyruk)