sıradan ayır (STL/CLR)

Makale
10/12/2023

Şablon sınıfı, rastgele erişime sahip öğelerin farklı uzunlukta dizisini denetleen bir nesneyi açıklar. Kapsayıcıyı deque , bitişik bir depolama bloğu gibi görünen ancak kalan öğeleri kopyalamaya gerek kalmadan her iki uçta da büyüyebilen veya küçülebilen bir dizi öğeyi yönetmek için kullanırsınız. Bu nedenle verimli bir şekilde bir double-ended queueuygulayabilir. (Bu nedenle ad.)

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

Sözdizimi

template<typename Value>
    ref class deque
        :   public
        System::ICloneable,
        System::Collections::IEnumerable,
        System::Collections::ICollection,
        System::Collections::Generic::IEnumerable<GValue>,
        System::Collections::Generic::ICollection<GValue>,
        System::Collections::Generic::IList<GValue>,
        Microsoft::VisualC::StlClr::IDeque<GValue>
    { ..... };

Parametreler

GValue
Denetlenen dizideki bir öğenin genel türü.

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

Gereksinimler

Üst bilgi:<cliext/deque>

Ad alanı: cliext

Bildirimler

Tür Tanımı	Açıklama
deque::const_iterator (STL/CLR)	Denetlenen dizi için bir sabit yineleyici türü.
deque::const_reference (STL/CLR)	Bir öğe için sabit bir başvuru türü.
deque::const_reverse_iterator (STL/CLR)	Denetimli sıra için sabit bir ters yineleyici türü.
deque::difference_type (STL/CLR)	İki öğe arasındaki işaretli mesafenin türü.
deque::generic_container (STL/CLR)	Kapsayıcı için genel arabirimin türü.
deque::generic_iterator (STL/CLR)	Kapsayıcının genel arabirimi için yineleyici türü.
deque::generic_reverse_iterator (STL/CLR)	Kapsayıcının genel arabirimi için ters yineleyici türü.
deque::generic_value (STL/CLR)	Kapsayıcının genel arabirimi için bir öğenin türü.
deque::iterator (STL/CLR)	Denetlenen dizi için bir yineleyici türü.
deque::reference (STL/CLR)	Bir öğe için bir başvuru türü.
deque::reverse_iterator (STL/CLR)	Denetimli sıra için ters yineleyicinin türü.
deque::size_type (STL/CLR)	İki öğe arasındaki işaretli mesafenin türü.
deque::value_type (STL/CLR)	Öğenin türü.

Üye İşlevi	Açıklama
deque::assign (STL/CLR)	Tüm öğeleri değiştirir.
deque::at (STL/CLR)	Belirtilen konumdaki bir öğeye erişir.
deque::back (STL/CLR)	Son öğeye erişir.
deque::begin (STL/CLR)	Denetlenen dizinin başlangıcını belirtir.
deque::clear (STL/CLR)	Tüm öğeleri kaldırır.
deque::deque (STL/CLR)	Bir kapsayıcı nesnesi oluşturur.
deque::empty (STL/CLR)	Bir öğe olup olmadığını sınar.
deque::end (STL/CLR)	Denetlenen dizinin bitişini belirtir.
deque::erase (STL/CLR)	Belirtilen konumlardaki öğeleri kaldırır.
deque::front (STL/CLR)	İlk öğeye erişir.
deque::insert (STL/CLR)	Belirli bir konuma öğe ekler.
deque::pop_back (STL/CLR)	Son öğeyi kaldırır.
deque::pop_front (STL/CLR)	İlk öğeyi kaldırır.
deque::push_back (STL/CLR)	Yeni bir son öğe ekler.
deque::push_front (STL/CLR)	Yeni bir ilk öğe ekler.
deque::rbegin (STL/CLR)	Ters denetimli sıranın başlangıcını belirtir.
deque::rend (STL/CLR)	Ters denetimli sıranın sonunu belirtir.
deque::resize (STL/CLR)	Öğe sayısını değiştirir.
deque::size (STL/CLR)	Öğe sayısını sayar.
deque::swap (STL/CLR)	İki kapsayıcının içeriğinin yerini değiştirir.
deque::to_array (STL/CLR)	Denetimli diziyi yeni bir diziye kopyalar.

Özellik	Açıklama
deque::back_item (STL/CLR)	Son öğeye erişir.
deque::front_item (STL/CLR)	İlk öğeye erişir.

Operator	Açıklama
deque::operator!= (STL/CLR)	İki `deque` nesnenin eşit olup olmadığını belirler.
deque::operator(STL/CLR)	Belirtilen konumdaki bir öğeye erişir.
operator< (deque) (STL/CLR)	Bir nesnenin başka `deque` bir `deque` nesneden küçük olup olmadığını belirler.
operator<= (deque) (STL/CLR)	Bir nesnenin başka bir nesneden küçük veya başka bir `deque` `deque` nesneye eşit olup olmadığını belirler.
operator= (deque) (STL/CLR)	Denetimli sıranın yerini alır.
operator== (deque) (STL/CLR)	Bir nesnenin başka `deque` bir `deque` nesneye eşit olup olmadığını belirler.
operator> (deque) (STL/CLR)	Bir nesnenin başka `deque` bir `deque` nesneden büyük olup olmadığını belirler.
operator>= (deque) (STL/CLR)	Bir nesnenin başka bir nesneden büyük veya başka bir `deque` `deque` nesneye eşit olup olmadığını belirler.

Arabirimler

Arabirim	Açıklama
ICloneable	Nesneyi çoğaltma.
IEnumerable	Öğeler arasında sıralama.
ICollection	Öğe grubunu koruyun.
IEnumerable<T>	Yazılan öğeler arasında sıra.
ICollection<T>	Yazılan öğe grubunu koruyun.
IList<T>	Sıralı türlenmiş öğe grubunu koruyun.
IDeque<Değeri>	Genel kapsayıcıyı koruyun.

Açıklamalar

nesnesi, öğe bloklarını Value belirten saklı bir tanıtıcı dizisi aracılığıyla denetleyebilen dizi için depolama ayırır ve serbesttir. Dizi isteğe bağlı olarak büyür. Büyüme, yeni bir öğeyi önceden gönderme veya ekleme maliyetinin sabit bir süre olması ve kalan hiçbir öğenin rahatsız olmaması şeklinde gerçekleşir. Bir öğeyi sabit zamanda ve kalan öğeleri rahatsız etmeden iki uçta da kaldırabilirsiniz. Bu nedenle deque, şablon sınıfı kuyruğu (STL/CLR) veya şablon sınıf yığını (STL/CLR) için temel kapsayıcı için iyi bir adaydır.

Nesne deque rastgele erişim yineleyicilerini destekler. Bu, ilk (ön) öğe için sıfırdan sayarak son (arka) öğe için deque::size (STL/CLR)() - 1 öğesine doğrudan sayısal konumu verilen bir öğeye başvurabileceğiniz anlamına gelir. Ayrıca, bir deque'nin şablon sınıfı priority_queue (STL/CLR) için temel kapsayıcı için iyi bir aday olduğu anlamına gelir.

Bir deque yineleyicisi, tanıtıcıyı ilişkili deque nesnesine ve onun belirlediğiniz öğenin yanlılığını depolar. Yineleyicileri yalnızca ilişkili kapsayıcı nesneleriyle kullanabilirsiniz. Bir deque öğesinin yanlılığı, konumuyla aynı olmayabilir . Eklenen ilk öğede sapma sıfır, bir sonraki eklenen öğede sapma 1, ancak bir sonraki ekli öğede sapma -1 var.

Her iki uca öğe eklemek veya silmek, geçerli bir sapmada depolanan bir öğenin değerini değiştirmez. Ancak iç öğe eklemek veya silmek, belirli bir sapmada depolanan öğe değerini değiştirebilir , böylece yineleyici tarafından belirlenen değer de değişebilir. (Kapsayıcının, eklemeden önce bir delik oluşturmak veya silmeden sonra bir delik doldurmak için öğeleri yukarı veya aşağı kopyalaması gerekebilir.) Bununla birlikte, bir deque yineleyicisi, yanlılığı geçerli bir öğe belirttiği sürece geçerli kalır. Ayrıca, geçerli bir yineleyicinin başvurusu kaldırılabilir durumda kalır ; sapma, tarafından end()döndürülen yineleyicinin yanlılığıyla eşit olmadığı sürece, bunu kullanarak belirttiği öğe değerine erişebilir veya bunları değiştirebilirsiniz.

Bir öğenin silinmesi veya kaldırılması, depolanmış değeri için yıkıcıyı çağırır. Kapsayıcıyı yok etmek tüm öğeleri siler. Bu nedenle, öğe türü ref sınıfı olan bir kapsayıcı, hiçbir öğenin kapsayıcıdan daha uzun yaşamasını sağlamaz. Ancak, bir tutamaç kapsayıcısının öğelerini yok etmediğini unutmayın.

Üyeler

deque::assign (STL/CLR)

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

Sözdizimi

void assign(size_type count, value_type val);
template<typename InIt>
    void assign(InIt first, InIt last);
void assign(System::Collections::Generic::IEnumerable<Value>^ right);

Parametreler

count
Eklenecek öğe sayısı.

birinci
Eklenecek aralığın başlangıcı.

son
Eklenecek aralık sonu.

Sağ
Eklenecek numaralandırma.

Val
Eklenecek öğenin değeri.

Açıklamalar

İlk üye işlevi, denetlenen sırayı değer değerinin sayı öğelerinin tekrarı ile değiştirir. Kapsayıcıyı aynı değere sahip öğelerle doldurmak için kullanırsınız.

Tamsayı türündeyse InIt , ikinci üye işlevi ile assign((size_type)first, (value_type)last)aynı şekilde davranır. Aksi takdirde, denetlenen sırayı [first, last) dizisiyle değiştirir. Bunu denetimli sırayı başka bir dizi kopyası yapmak için kullanırsınız.

Üçüncü üye işlevi, denetlenen sırayı numaralandırıcı hakkı tarafından belirlenen diziyle değiştirir. Bunu, denetimli sırayı bir numaralandırıcı tarafından açıklanan bir dizinin kopyası yapmak için kullanırsınız.

Örnek

// cliext_deque_assign.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
    cliext::deque<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

    // assign a repetition of values
    cliext::deque<wchar_t> c2;
    c2.assign(6, L'x');
    for each (wchar_t elem in c2)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // assign an iterator range
    c2.assign(c1.begin(), c1.end() - 1);
    for each (wchar_t elem in c2)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // assign an enumeration
    c2.assign(   // NOTE: cast is not needed
        (System::Collections::Generic::IEnumerable<wchar_t>^)%c1);
    for each (wchar_t elem in c2)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

x x x x x x
a b
a b c

deque::at (STL/CLR)

Belirtilen konumdaki bir öğeye erişir.

Sözdizimi

reference at(size_type pos);

Parametreler

Pos
Erişecek öğenin konumu.

Açıklamalar

Üye işlevi, konum konumundaki denetlenen sıranın öğesine bir başvuru döndürür. Konumunu bildiğiniz bir öğeyi okumak veya yazmak için bunu kullanırsınız.

Örnek

// cliext_deque_at.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
    cliext::deque<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

    // display contents " a b c" using at
    for (int i = 0; i < c1.size(); ++i)
        System::Console::Write("{0} ", c1.at(i));
    System::Console::WriteLine();

    // change an entry and redisplay
    c1.at(1) = L'x';
    for (int i = 0; i < c1.size(); ++i)
        System::Console::Write("{0} ", c1[i]);
    System::Console::WriteLine();
    return (0);
    }

a b c
a x c

deque::back (STL/CLR)

Son öğeye erişir.

Sözdizimi

reference back();

Açıklamalar

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

Örnek

// cliext_deque_back.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
    cliext::deque<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

    // display initial contents " a b c"
    for each (wchar_t elem in c1)
        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)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

a b c
back() = c
a b x

deque::back_item (STL/CLR)

Son öğeye erişir.

Sözdizimi

property value_type back_item;

Açıklamalar

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

Örnek

// cliext_deque_back_item.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
    cliext::deque<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

    // display initial contents " a b c"
    for each (wchar_t elem in c1)
        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)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

a b c
back_item = c
a b x

deque::begin (STL/CLR)

Denetlenen dizinin başlangıcını belirtir.

Sözdizimi

iterator begin();

Açıklamalar

Üye işlevi, denetlenen dizinin ilk öğesini veya boş bir dizinin sonunun hemen ötesinde belirten rastgele erişim yineleyicisi döndürür. Denetimli sıranın current başlangıcını belirten bir yineleyici elde etmek için bunu kullanırsınız, ancak denetlenen sıranın uzunluğu değişirse durumu değişebilir.

Örnek

// cliext_deque_begin.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
    cliext::deque<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

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

    // inspect first two items
    cliext::deque<wchar_t>::iterator it = c1.begin();
    System::Console::WriteLine("*begin() = {0}", *it);
    System::Console::WriteLine("*++begin() = {0}", *++it);

    // alter first two items and reinspect
    *--it = L'x';
    *++it = L'y';
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

a b c
*begin() = a
*++begin() = b
x y c

deque::clear (STL/CLR)

Tüm öğeleri kaldırır.

Sözdizimi

void clear();

Açıklamalar

Üye işlevi etkili bir şekilde deque::erase (STL/CLR)( deque::begin (STL/CLR)(), deque::end (STL/CLR) çağrısında bulunur.()) Denetimli sıranın boş olduğundan emin olmak için bunu kullanırsınız.

Örnek

// cliext_deque_clear.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
    cliext::deque<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

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

    // clear the container and reinspect
    c1.clear();
    System::Console::WriteLine("size() = {0}", c1.size());

    // add elements and clear again
    c1.push_back(L'a');
    c1.push_back(L'b');

    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    c1.clear();
    System::Console::WriteLine("size() = {0}", c1.size());
    return (0);
    }

a b c
size() = 0
a b
size() = 0

deque::const_iterator (STL/CLR)

Denetlenen dizi için bir sabit yineleyici türü.

Sözdizimi

typedef T2 const_iterator;

Açıklamalar

türü, denetlenen dizi için sabit bir rastgele erişim yineleyicisi olarak hizmet verebilen belirtilmemiş türdeki T2 bir nesneyi açıklar.

Örnek

// cliext_deque_const_iterator.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
    cliext::deque<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

    // display contents " a b c"
    cliext::deque<wchar_t>::const_iterator cit = c1.begin();
    for (; cit != c1.end(); ++cit)
        System::Console::Write("{0} ", *cit);
    System::Console::WriteLine();
    return (0);
    }

a b c

deque::const_reference (STL/CLR)

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_deque_const_reference.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
    cliext::deque<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

    // display initial contents " a b c"
    cliext::deque<wchar_t>::const_iterator cit = c1.begin();
    for (; cit != c1.end(); ++cit)
        {   // get a const reference to an element
        cliext::deque<wchar_t>::const_reference cref = *cit;
        System::Console::Write("{0} ", cref);
        }
    System::Console::WriteLine();
    return (0);
    }

a b c

deque::const_reverse_iterator (STL/CLR)

Denetlenen sıra için sabit ters yineleyici türü..

Sözdizimi

typedef T4 const_reverse_iterator;

Açıklamalar

türü, denetlenen dizi için sabit bir ters yineleyici görevi görecek belirtilmemiş türdeki T4 bir nesneyi açıklar.

Örnek

// cliext_deque_const_reverse_iterator.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
    cliext::deque<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

    // display contents " a b c" reversed
    cliext::deque<wchar_t>::const_reverse_iterator crit = c1.rbegin();
    cliext::deque<wchar_t>::const_reverse_iterator crend = c1.rend();
    for (; crit != crend; ++crit)
        System::Console::Write("{0} ", *crit);
    System::Console::WriteLine();
    return (0);
    }

c b a

deque::deque (STL/CLR)

Bir kapsayıcı nesnesi oluşturur.

Sözdizimi

deque();
deque(deque<Value>% right);
deque(deque<Value>^ right);
explicit deque(size_type count);
deque(size_type count, value_type val);
template<typename InIt>
    deque(InIt first, InIt last);
deque(System::Collections::Generic::IEnumerable<Value>^ right);

Parametreler

count
Eklenecek öğe sayısı.

birinci
Eklenecek aralığın başlangıcı.

son
Eklenecek aralık sonu.

Sağ
Eklenecek nesne veya aralık.

Val
Eklenecek öğenin değeri.

Açıklamalar

Oluşturucu:

deque();

denetimli diziyi hiçbir öğe olmadan başlatır. Boş bir ilk denetimli sıra belirtmek için bunu kullanırsınız.

Oluşturucu:

deque(deque<Value>% right);

denetimli sırayı [right.begin(), right.end()) dizisiyle başlatır. Bunu, deque nesnesi tarafından denetlenen sıranın bir kopyası olan ilk denetimli diziyi belirtmek için kullanırsınız. Yineleyiciler hakkında daha fazla bilgi için bkz . deque::begin (STL/CLR) ve deque::end (STL/CLR).

Oluşturucu:

deque(deque<Value>^ right);

denetimli sırayı [right->begin(), right->end()) dizisiyle başlatır. Bunu, tanıtıcısı doğru olan deque nesnesi tarafından denetlenen sıranın bir kopyası olan ilk denetimli bir dizi belirtmek için kullanırsınız.

Oluşturucu:

explicit deque(size_type count);

denetimli sırayı, her birinin değeri value_type()olan sayı öğeleriyle başlatır. Kapsayıcıyı varsayılan değere sahip öğelerle doldurmak için kullanırsınız.

Oluşturucu:

deque(size_type count, value_type val);

, her birinin değer değeri olan sayı öğeleriyle denetlenen diziyi başlatır. Kapsayıcıyı aynı değere sahip öğelerle doldurmak için kullanırsınız.

Oluşturucu:

template<typename InIt>

deque(InIt first, InIt last);

denetimli sırayı [first, last) dizisiyle başlatır. Bunu, denetimli sırayı başka bir dizinin kopyası yapmak için kullanırsınız.

Oluşturucu:

deque(System::Collections::Generic::IEnumerable<Value>^ right);

, numaralandırıcı hakkı tarafından belirlenen diziyle denetimli diziyi başlatır. Bunu, denetimli sırayı bir numaralandırıcı tarafından açıklanan başka bir dizinin kopyası yapmak için kullanırsınız.

Örnek

// cliext_deque_construct.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
// construct an empty container
    cliext::deque<wchar_t> c1;
    System::Console::WriteLine("size() = {0}", c1.size());

    // construct with a repetition of default values
    cliext::deque<wchar_t> c2(3);
    for each (wchar_t elem in c2)
        System::Console::Write("{0} ", (int)elem);
    System::Console::WriteLine();

    // construct with a repetition of values
    cliext::deque<wchar_t> c3(6, L'x');
    for each (wchar_t elem in c3)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // construct with an iterator range
    cliext::deque<wchar_t>::iterator it = c3.end();
    cliext::deque<wchar_t> c4(c3.begin(), --it);
    for each (wchar_t elem in c4)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // construct with an enumeration
    cliext::deque<wchar_t> c5(   // NOTE: cast is not needed
        (System::Collections::Generic::IEnumerable<wchar_t>^)%c3);
    for each (wchar_t elem in c5)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // construct by copying another container
    cliext::deque<wchar_t> c7(c3);
    for each (wchar_t elem in c7)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // construct by copying a container handle
    cliext::deque<wchar_t> c8(%c3);
    for each (wchar_t elem in c8)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    return (0);
    }

size() = 0
0 0 0
x x x x x x
x x x x x
x x x x x x
x x x x x x
x x x x x x

deque::difference_type (STL/CLR)

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

Sözdizimi

typedef int difference_type;

Açıklamalar

Türü, imzalı öğe sayısını açıklar.

Örnek

// cliext_deque_difference_type.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
    cliext::deque<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

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

    // compute positive difference
    cliext::deque<wchar_t>::difference_type diff = 0;
    for (cliext::deque<wchar_t>::iterator it = c1.begin();
        it != c1.end(); ++it) ++diff;
    System::Console::WriteLine("end()-begin() = {0}", diff);

    // compute negative difference
    diff = 0;
    for (cliext::deque<wchar_t>::iterator it = c1.end();
        it != c1.begin(); --it) --diff;
    System::Console::WriteLine("begin()-end() = {0}", diff);
    return (0);
    }

a b c
end()-begin() = 3
begin()-end() = -3

deque::empty (STL/CLR)

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. Deque::size (STL/CLR)() == 0 ile eşdeğerdir. Deque'nin boş olup olmadığını test etmek için bunu kullanırsınız.

Örnek

// cliext_deque_empty.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
    cliext::deque<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

    // display initial contents " a b c"
    for each (wchar_t elem in c1)
        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.clear();
    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

deque::end (STL/CLR)

Denetlenen dizinin bitişini belirtir.

Sözdizimi

iterator end();

Açıklamalar

Üye işlevi, denetlenen sıranın sonunun hemen ötesine işaret eden rastgele erişim yineleyicisi döndürür. Denetimli sıranın current sonunu belirten bir yineleyici elde etmek için bunu kullanırsınız, ancak denetlenen sıranın uzunluğu değişirse durumu değişebilir.

Örnek

// cliext_deque_end.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
    cliext::deque<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

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

    // inspect last two items
    cliext::deque<wchar_t>::iterator it = c1.end();
    --it;
    System::Console::WriteLine("*-- --end() = {0}", *--it);
    System::Console::WriteLine("*--end() = {0}", *++it);

    // alter first two items and reinspect
    *--it = L'x';
    *++it = L'y';
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

a b c
*-- --end() = b
*--end() = c
a x y

deque::erase (STL/CLR)

Belirtilen konumlardaki öğeleri kaldırır.

Sözdizimi

iterator erase(iterator where);
iterator erase(iterator first, iterator last);

Parametreler

birinci
Silinecek aralığın başlangıcı.

son
Silinecek aralığın sonu.

nerede
Silinecek öğe.

Açıklamalar

İlk üye işlevi, denetimli dizinin nereye işaret ettiği öğesini kaldırır. Tek bir öğeyi kaldırmak için bunu kullanırsınız.

İkinci üye işlevi , [first, last) aralığındaki denetlenen dizinin öğelerini kaldırır. Sıfır veya daha fazla bitişik öğeyi kaldırmak için bunu kullanırsınız.

Her iki üye işlevi de kaldırılan öğelerin ötesinde kalan ilk öğeyi belirten bir yineleyici döndürür veya böyle bir öğe yoksa deque::end (STL/CLR)() döndürür.

Öğeleri silirken, öğe kopyalarının sayısı, silme işleminin sonu ile sıranın daha yakın ucu arasındaki öğe sayısında doğrusaldır. (Sıranın herhangi bir ucundaki bir veya daha fazla öğeyi sildiğinde, öğe kopyası gerçekleşmez.)

Örnek

// cliext_deque_erase.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
    cliext::deque<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

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

    // erase an element and reinspect
    System::Console::WriteLine("erase(begin()) = {0}",
        *c1.erase(c1.begin()));

    // add elements and display " b c d e"
    c1.push_back(L'd');
    c1.push_back(L'e');
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // erase all but end
    cliext::deque<wchar_t>::iterator it = c1.end();
    System::Console::WriteLine("erase(begin(), end()-1) = {0}",
        *c1.erase(c1.begin(), --it));
    System::Console::WriteLine("size() = {0}", c1.size());
    return (0);
    }

a b c
erase(begin()) = b
b c d e
erase(begin(), end()-1) = e
size() = 1

deque::front (STL/CLR)

İlk öğeye erişir.

Sözdizimi

reference front();

Açıklamalar

Üye işlevi, denetlenen dizinin ilk öğesine boş olmayan bir başvuru döndürür. Var olduğunu bildiğinizde ilk öğeyi okumak veya yazmak için bunu kullanırsınız.

Örnek

// cliext_deque_front.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
    cliext::deque<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

    // display initial contents " a b c"
    for each (wchar_t elem in c1)
        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)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

a b c
front() = a
x b c

deque::front_item (STL/CLR)

İlk öğeye erişir.

Sözdizimi

property value_type front_item;

Açıklamalar

özelliği, denetlenen dizinin ilk öğesine erişir ve bu öğe boş olmamalıdır. Var olduğunu bildiğinizde ilk öğeyi okumak veya yazmak için bunu kullanırsınız.

Örnek

// cliext_deque_front_item.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
    cliext::deque<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

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

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

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

a b c
front_item = a
x b c

deque::generic_container (STL/CLR)

Kapsayıcı için genel arabirimin türü.

Sözdizimi

typedef Microsoft::VisualC::StlClr::
    IDeque<generic_value>
    generic_container;

Açıklamalar

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

Örnek

// cliext_deque_generic_container.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
    cliext::deque<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

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

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

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

    // modify original and display generic
    c1.push_back(L'e');

    System::Collections::IEnumerator^ enum1 =
        gc1->GetEnumerator();
    while (enum1->MoveNext())
        System::Console::Write("{0} ", enum1->Current);
    System::Console::WriteLine();
    return (0);
    }

a b c
a b c
a b c d
a b c d e

deque::generic_iterator (STL/CLR)

Kapsayıcının genel arabirimiyle kullanılacak bir yineleyicinin türü.

Sözdizimi

typedef Microsoft::VisualC::StlClr::Generic::
    ContainerRandomAccessIterator<generic_value> generic_iterator;

Açıklamalar

türü, bu şablon kapsayıcı sınıfı için genel arabirimle kullanılabilecek genel bir yineleyiciyi açıklar.

Örnek

// cliext_deque_generic_iterator.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
    cliext::deque<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

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

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

    // modify generic and display original
    cliext::deque<wchar_t>::generic_iterator gcit = gc1->begin();
    cliext::deque<wchar_t>::generic_value gcval = *gcit;
    *++gcit = gcval;
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

a b c
a b c
a a c

deque::generic_reverse_iterator (STL/CLR)

Kapsayıcının genel arabirimiyle kullanılacak ters yineleyicinin türü.

Sözdizimi

typedef Microsoft::VisualC::StlClr::Generic::
    ReverseRandomAccessIterator<generic_value> generic_reverse_iterator;

Açıklamalar

türü, bu şablon kapsayıcı sınıfı için genel arabirimle kullanılabilecek genel bir ters yineleyiciyi açıklar.

Örnek

// cliext_deque_generic_reverse_iterator.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
    cliext::deque<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

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

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

    // modify generic and display original
    cliext::deque<wchar_t>::generic_reverse_iterator gcit = gc1->rbegin();
    cliext::deque<wchar_t>::generic_value gcval = *gcit;
    *++gcit = gcval;
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

a b c
a b c
a c c

deque::generic_value (STL/CLR)

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.

Örnek

// cliext_deque_generic_value.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
    cliext::deque<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

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

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

    // modify generic and display original
    cliext::deque<wchar_t>::generic_iterator gcit = gc1->begin();
    cliext::deque<wchar_t>::generic_value gcval = *gcit;
    *++gcit = gcval;
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

a b c
a b c
a a c

deque::insert (STL/CLR)

Belirli bir konuma öğe ekler.

Sözdizimi

iterator insert(iterator where, value_type val);
void insert(iterator where, size_type count, value_type val);
template<typename InIt>
    void insert(iterator where, InIt first, InIt last);
void insert(iterator where,
    System::Collections::Generic::IEnumerable<Value>^ right);

Parametreler

count
Eklenecek öğe sayısı.

birinci
Eklenecek aralığın başlangıcı.

son
Eklenecek aralık sonu.

Sağ
Eklenecek numaralandırma.

Val
Eklenecek öğenin değeri.

nerede
Kapsayıcıda daha önce eklenecek yer.

Açıklamalar

Üye işlevlerin her biri, öğe tarafından işaret edilen öğeden önce denetimli dizide kalan işlenenler tarafından belirtilen bir sıra ekler.

İlk üye işlevi değer değeri olan bir öğe ekler ve yeni eklenen öğeyi belirten bir yineleyici döndürür. Bunu, yineleyici tarafından belirlenen bir yerden önce tek bir öğe eklemek için kullanırsınız.

İkinci üye işlevi, değer değerinin sayı öğelerinin tekrarını ekler. Bunu, aynı değerin tüm kopyaları olan sıfır veya daha fazla bitişik öğe eklemek için kullanırsınız.

Tamsayı türündeyse InIt , üçüncü üye işlevi ile insert(where, (size_type)first, (value_type)last)aynı şekilde davranır. Aksi takdirde, [first, last) dizisini ekler. Bunu, başka bir diziden kopyalanan sıfır veya daha fazla bitişik öğe eklemek için kullanırsınız.

Dördüncü üye işlevi, sağ tarafından belirlenen diziyi ekler. Bunu bir numaralandırıcı tarafından açıklanan bir dizi eklemek için kullanırsınız.

Tek bir öğe eklerken, öğe kopyalarının sayısı, ekleme noktası ile sıranın daha yakın ucu arasındaki öğe sayısında doğrusaldır. (Sıranın herhangi bir sonuna bir veya daha fazla öğe eklerken hiçbir öğe kopyası gerçekleşmez.) Giriş yineleyicisi ise InIt , üçüncü üye işlevi sırayla her öğe için etkili bir şekilde tek bir ekleme gerçekleştirir. Aksi takdirde, öğe eklerken N öğe kopyalarının sayısı doğrusaldır N ve ekleme noktası ile dizinin daha yakın ucu arasındaki öğe sayısıdır.

Örnek

// cliext_deque_insert.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
    cliext::deque<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

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

    // insert a single value using iterator
    cliext::deque<wchar_t>::iterator it = c1.begin();
    System::Console::WriteLine("insert(begin()+1, L'x') = {0}",
        *c1.insert(++it, L'x'));
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // insert a repetition of values
    cliext::deque<wchar_t> c2;
    c2.insert(c2.begin(), 2, L'y');
    for each (wchar_t elem in c2)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // insert an iterator range
    it = c1.end();
    c2.insert(c2.end(), c1.begin(), --it);
    for each (wchar_t elem in c2)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // insert an enumeration
    c2.insert(c2.begin(),   // NOTE: cast is not needed
        (System::Collections::Generic::IEnumerable<wchar_t>^)%c1);
    for each (wchar_t elem in c2)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

a b c
insert(begin()+1, L'x') = x
a x b c
y y
y y a x b
a x b c y y a x b

deque::iterator (STL/CLR)

Denetlenen dizi için bir yineleyici türü.

Sözdizimi

typedef T1 iterator;

Açıklamalar

türü, denetlenen dizi için rastgele erişim yineleyicisi olarak hizmet verebilen belirtilmemiş türdeki T1 bir nesneyi açıklar.

Örnek

// cliext_deque_iterator.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
    cliext::deque<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

    // display contents " a b c"
    cliext::deque<wchar_t>::iterator it = c1.begin();
    for (; it != c1.end(); ++it)
        System::Console::Write("{0} ", *it);
    System::Console::WriteLine();

    // alter first element and redisplay
    it = c1.begin();
    *it = L'x';
    for (; it != c1.end(); ++it)
        System::Console::Write("{0} ", *it);
    System::Console::WriteLine();
    return (0);
    }

a b c
x b c

deque::operator!= (STL/CLR)

Deque eşit karşılaştırma değil.

Sözdizimi

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

Parametreler

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

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

Açıklamalar

işleç işlevi döndürür !(left == right). İki deque öğesi öğeye göre karşılaştırıldığında, left öğesinin sağ ile aynı sıralanıp sıralanmadığını test etmek için kullanırsınız.

Örnek

// cliext_deque_operator_ne.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
    cliext::deque<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

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

    // assign to a new container
    cliext::deque<wchar_t> c2;
    c2.push_back(L'a');
    c2.push_back(L'b');
    c2.push_back(L'd');

    // display contents " a b d"
    for each (wchar_t elem in c2)
        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

deque::operator(STL/CLR)

Belirtilen konumdaki bir öğeye erişir.

Sözdizimi

reference operator[](size_type pos);

Parametreler

Pos
Erişecek öğenin konumu.

Açıklamalar

Üye işleci konum pos öğesi için bir başvuru döndürür. Konumunu bildiğiniz bir öğeye erişmek için bunu kullanırsınız.

Örnek

// cliext_deque_operator_sub.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
    cliext::deque<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

    // display contents " a b c" using subscripting
    for (int i = 0; i < c1.size(); ++i)
        System::Console::Write("{0} ", c1[i]);
    System::Console::WriteLine();

    // change an entry and redisplay
    c1[1] = L'x';
    for (int i = 0; i < c1.size(); ++i)
        System::Console::Write("{0} ", c1[i]);
    System::Console::WriteLine();
    return (0);
    }

a b c
a x c

deque::pop_back (STL/CLR)

Son öğeyi kaldırır.

Sözdizimi

void pop_back();

Açıklamalar

Üye işlevi, denetlenen dizinin boş olmayan son öğesini kaldırır. Deque'yi arkadaki bir öğeye göre kısaltmak için kullanırsınız.

Örnek

// cliext_deque_pop_back.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
    cliext::deque<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

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

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

a b c
a b

deque::pop_front (STL/CLR)

İlk öğeyi kaldırır.

Sözdizimi

void pop_front();

Açıklamalar

Üye işlevi, denetlenen dizinin ilk öğesini kaldırır ve bu öğe boş olmamalıdır. Bunu, deque'yi öndeki bir öğeye göre kısaltmak için kullanırsınız.

Örnek

// cliext_deque_pop_front.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
    cliext::deque<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

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

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

a b c
b c

deque::push_back (STL/CLR)

Yeni bir son öğe ekler.

Sözdizimi

void push_back(value_type val);

Açıklamalar

üye işlevi, denetlenen sıranın sonuna değer val içeren bir öğe ekler. Bunu, deque'ye başka bir öğe eklemek için kullanırsınız.

Örnek

// cliext_deque_push_back.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
    cliext::deque<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

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

a b c

deque::push_front (STL/CLR)

Yeni bir ilk öğe ekler.

Sözdizimi

void push_front(value_type val);

Açıklamalar

üye işlevi, denetlenen sıranın başına değer val içeren bir öğe ekler. Bunu, başka bir öğeyi deque'ye eklemek için kullanırsınız.

Örnek

// cliext_deque_push_front.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
    cliext::deque<wchar_t> c1;
    c1.push_front(L'a');
    c1.push_front(L'b');
    c1.push_front(L'c');

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

c b a

deque::rbegin (STL/CLR)

Ters denetimli sıranın başlangıcını belirtir.

Sözdizimi

reverse_iterator rbegin();

Açıklamalar

Üye işlevi, denetlenen dizinin son öğesini veya boş bir dizinin başlangıcının hemen ötesinde belirten bir ters yineleyici döndürür. Bu nedenle, ters sıranın öğesini belirtir beginning . Ters sırada görülen denetimli sıranın current başlangıcını belirten bir yineleyici elde etmek için bunu kullanırsınız, ancak denetlenen sıranın uzunluğu değişirse durumu değişebilir.

Örnek

// cliext_deque_rbegin.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
    cliext::deque<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

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

    // inspect first two items in reversed sequence
    cliext::deque<wchar_t>::reverse_iterator rit = c1.rbegin();
    System::Console::WriteLine("*rbegin() = {0}", *rit);
    System::Console::WriteLine("*++rbegin() = {0}", *++rit);

    // alter first two items and reinspect
    *--rit = L'x';
    *++rit = L'y';
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

a b c
*rbegin() = c
*++rbegin() = b
a y x

deque::reference (STL/CLR)

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_deque_reference.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
    cliext::deque<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

    // display initial contents " a b c"
    cliext::deque<wchar_t>::iterator it = c1.begin();
    for (; it != c1.end(); ++it)
        {   // get a reference to an element
        cliext::deque<wchar_t>::reference ref = *it;
        System::Console::Write("{0} ", ref);
        }
    System::Console::WriteLine();

    // modify contents " a b c"
    for (it = c1.begin(); it != c1.end(); ++it)
        {   // get a reference to an element
        cliext::deque<wchar_t>::reference ref = *it;

        ref += (wchar_t)(L'A' - L'a');
        System::Console::Write("{0} ", ref);
        }
    System::Console::WriteLine();
    return (0);
    }

a b c
A B C

deque::rend (STL/CLR)

Ters denetimli sıranın sonunu belirtir.

Sözdizimi

reverse_iterator rend();

Açıklamalar

Üye işlevi, denetlenen sıranın başlangıcının hemen ötesine işaret eden bir ters yineleyici döndürür. Bu nedenle, ters sıranın öğesini belirtir end . Ters sırada görülen denetimli sıranın current sonunu belirten bir yineleyici elde etmek için bunu kullanırsınız, ancak denetlenen sıranın uzunluğu değişirse durumu değişebilir.

Örnek

// cliext_deque_rend.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
    cliext::deque<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

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

    // inspect first two items
    cliext::deque<wchar_t>::reverse_iterator rit = c1.rend();
    --rit;
    System::Console::WriteLine("*-- --rend() = {0}", *--rit);
    System::Console::WriteLine("*--rend() = {0}", *++rit);

    // alter first two items and reinspect
    *--rit = L'x';
    *++rit = L'y';
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

a b c
*-- --rend() = b
*--rend() = a
y x c

deque::resize (STL/CLR)

Öğe sayısını değiştirir.

Sözdizimi

void resize(size_type new_size);
void resize(size_type new_size, value_type val);

Parametreler

new_size
Denetlenen sıranın yeni boyutu.

Val
Doldurma öğesinin değeri.

Açıklamalar

Üye işlevlerinin her ikisi deque::size (STL/CLR)() işlevinin new_size döndürdüğünden emin olur. Denetlenen sırayı daha uzun hale getirmesi gerekiyorsa, ilk üye işlevi değeri value_type()olan öğeleri eklerken, ikinci üye işlevi değer değeri olan öğeleri ekler. Denetimli sırayı daha kısa hale getirmek için her iki üye işlevi deque::size (STL/CLR)() - new_size son öğe sürelerini etkili bir şekilde siler. Geçerli denetimli sırayı kırparak veya doldurarak denetimli sıranın boyut new_size olduğundan emin olmak için bunu kullanırsınız.

Örnek

// cliext_deque_resize.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
// construct an empty container and pad with default values
    cliext::deque<wchar_t> c1;
    System::Console::WriteLine("size() = {0}", c1.size());
    c1.resize(4);
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", (int)elem);
    System::Console::WriteLine();

    // resize to empty
    c1.resize(0);
    System::Console::WriteLine("size() = {0}", c1.size());

    // resize and pad
    c1.resize(5, L'x');
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

size() = 0
0 0 0 0
size() = 0
x x x x x

deque::reverse_iterator (STL/CLR)

Denetimli sıra için ters yineleyicinin türü.

Sözdizimi

typedef T3 reverse_iterator;

Açıklamalar

türü, denetlenen dizi için ters yineleyici görevi görecek belirtilmemiş türdeki T3 bir nesneyi açıklar.

Örnek

// cliext_deque_reverse_iterator.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
    cliext::deque<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

    // display contents " a b c" reversed
    cliext::deque<wchar_t>::reverse_iterator rit = c1.rbegin();
    for (; rit != c1.rend(); ++rit)
        System::Console::Write("{0} ", *rit);
    System::Console::WriteLine();

    // alter first element and redisplay
    rit = c1.rbegin();
    *rit = L'x';
    for (; rit != c1.rend(); ++rit)
        System::Console::Write("{0} ", *rit);
    System::Console::WriteLine();
    return (0);
    }

c b a
x b a

deque::size (STL/CLR)

Öğ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 bir boyuta sahip olup olmadığıysa bkz . deque::empty (STL/CLR)().

Örnek

// cliext_deque_size.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
    cliext::deque<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

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

    // clear the container and reinspect
    c1.clear();
    System::Console::WriteLine("size() = {0} after clearing", c1.size());

    // add elements and clear again
    c1.push_back(L'a');
    c1.push_back(L'b');
    System::Console::WriteLine("size() = {0} after adding 2", c1.size());
    return (0);
    }

a b c
size() = 3 starting with 3
size() = 0 after clearing
size() = 2 after adding 2

deque::size_type (STL/CLR)

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

Sözdizimi

typedef int size_type;

Açıklamalar

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

Örnek

// cliext_deque_size_type.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
    cliext::deque<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

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

    // compute positive difference
    cliext::deque<wchar_t>::size_type diff = c1.end() - c1.begin();
    System::Console::WriteLine("end()-begin() = {0}", diff);
    return (0);
    }

a b c
end()-begin() = 3

deque::swap (STL/CLR)

İki kapsayıcının içeriğinin yerini değiştirir.

Sözdizimi

void swap(deque<Value>% right);

Parametreler

Sağ
İçindekileri değiştirecek kapsayıcı.

Açıklamalar

Üye işlevi, denetimli dizileri ile sağ arasında *this değiştirir. Bunu sürekli olarak yapar ve hiçbir özel durum oluşturmaz. bunu, iki kapsayıcının içeriğini değiştirmek için hızlı bir yol olarak kullanırsınız.

Örnek

// cliext_deque_swap.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
    cliext::deque<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

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

    // construct another container with repetition of values
    cliext::deque<wchar_t> c2(5, L'x');
    for each (wchar_t elem in c2)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // swap and redisplay
    c1.swap(c2);
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    for each (wchar_t elem in c2)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

a b c
x x x x x
x x x x x
a b c

deque::to_array (STL/CLR)

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_deque_to_array.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
    cliext::deque<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

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

    c1.push_back(L'd');
    for each (wchar_t elem in c1)
        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

deque::value_type (STL/CLR)

Öğenin türü.

Sözdizimi

typedef Value value_type;

Açıklamalar

Tür, Value şablon parametresinin eş anlamlısıdır.

Örnek

// cliext_deque_value_type.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
    cliext::deque<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

    // display contents " a b c" using value_type
    for (cliext::deque<wchar_t>::iterator it = c1.begin();
        it != c1.end(); ++it)
        {   // store element in value_type object
        cliext::deque<wchar_t>::value_type val = *it;

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

a b c

`operator<` (deque) (STL/CLR)

Karşılaştırmadan küçük bir sorgu.

Sözdizimi

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

Parametreler

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

Sağ
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, iki deque öğesi öğeye göre karşılaştırıldığında soldan önce sıralanıp sıralı olmadığını test etmek için kullanırsınız döndürürleft->size() < right->size().

Örnek

// cliext_deque_operator_lt.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
    cliext::deque<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

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

    // assign to a new container
    cliext::deque<wchar_t> c2;
    c2.push_back(L'a');
    c2.push_back(L'b');
    c2.push_back(L'd');

    // display contents " a b d"
    for each (wchar_t elem in c2)
        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<=` (deque) (STL/CLR)

Küçük veya eşit karşılaştırmayı deque.

Sözdizimi

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

Parametreler

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

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

Açıklamalar

işleç işlevi döndürür !(right < left). İki deque öğesi öğeye göre karşılaştırıldığında soldan sonra sıralanıp sıralanmadığını test etmek için kullanırsınız.

Örnek

// cliext_deque_operator_le.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
    cliext::deque<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

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

    // assign to a new container
    cliext::deque<wchar_t> c2;
    c2.push_back(L'a');
    c2.push_back(L'b');
    c2.push_back(L'd');

    // display contents " a b d"
    for each (wchar_t elem in c2)
        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= (deque) (STL/CLR)

Denetimli sıranın yerini alır.

Sözdizimi

deque<Value>% operator=(deque<Value>% right);

Parametreler

Sağ
Kopyalanacak kapsayıcı.

Açıklamalar

Üye işleci doğrudan nesnesine kopyalanır ve döndürür*this. Bunu, denetimli sırayı sağda denetimli sıranın bir kopyasıyla değiştirmek için kullanırsınız.

Örnek

// cliext_deque_operator_as.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
    cliext::deque<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

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

    // assign to a new container
    cliext::deque<wchar_t> c2;
    c2 = c1;
    for each (wchar_t elem in c2)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

a b c
a b c

operator== (deque) (STL/CLR)

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

Sözdizimi

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

Parametreler

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

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

Açıklamalar

işleç işlevi yalnızca sol ve sağ tarafından denetlenen dizilerin uzunluğu aynıysa ve her konum iiçin , left[i] == right[i]işlevi için true döndürür. İki deque öğesi öğeye göre karşılaştırıldığında, left öğesinin sağ ile aynı sıralanıp sıralı olmadığını test etmek için bunu kullanırsınız.

Örnek

// cliext_deque_operator_eq.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
    cliext::deque<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

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

    // assign to a new container
    cliext::deque<wchar_t> c2;
    c2.push_back(L'a');
    c2.push_back(L'b');
    c2.push_back(L'd');

    // display contents " a b d"
    for each (wchar_t elem in c2)
        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>` (deque) (STL/CLR)

Karşılaştırmadan daha büyük bir sorgu.

Sözdizimi

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

Parametreler

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

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

Açıklamalar

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

Örnek

// cliext_deque_operator_gt.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
    cliext::deque<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

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

    // assign to a new container
    cliext::deque<wchar_t> c2;
    c2.push_back(L'a');
    c2.push_back(L'b');
    c2.push_back(L'd');

    // display contents " a b d"
    for each (wchar_t elem in c2)
        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>=` (deque) (STL/CLR)

Büyük veya eşit karşılaştırmayı deque.

Sözdizimi

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

Parametreler

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

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

Açıklamalar

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

Örnek

// cliext_deque_operator_ge.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
    cliext::deque<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

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

    // assign to a new container
    cliext::deque<wchar_t> c2;
    c2.push_back(L'a');
    c2.push_back(L'b');
    c2.push_back(L'd');

    // display contents " a b d"
    for each (wchar_t elem in c2)
        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ş

sıradan ayır (STL/CLR)

Sözdizimi

Parametreler

Gereksinimler

Bildirimler

Arabirimler

Açıklamalar

Üyeler

deque::assign (STL/CLR)

Sözdizimi

Parametreler

Açıklamalar

Örnek

deque::at (STL/CLR)

Sözdizimi

Parametreler

Açıklamalar

Örnek

deque::back (STL/CLR)

Sözdizimi

Açıklamalar

Örnek

deque::back_item (STL/CLR)

Sözdizimi

Açıklamalar

Örnek

deque::begin (STL/CLR)

Sözdizimi

Açıklamalar

Örnek

deque::clear (STL/CLR)

Sözdizimi

Açıklamalar

Örnek

deque::const_iterator (STL/CLR)

Sözdizimi

Açıklamalar

Örnek

deque::const_reference (STL/CLR)

Sözdizimi

Açıklamalar

Örnek

deque::const_reverse_iterator (STL/CLR)

Sözdizimi

Açıklamalar

Örnek

deque::deque (STL/CLR)

Sözdizimi

Parametreler

Açıklamalar

Örnek

deque::difference_type (STL/CLR)

Sözdizimi

Açıklamalar

Örnek

deque::empty (STL/CLR)

Sözdizimi

Açıklamalar

Örnek

deque::end (STL/CLR)

Sözdizimi

Açıklamalar

Örnek

deque::erase (STL/CLR)

Sözdizimi

Parametreler

Açıklamalar

Örnek

deque::front (STL/CLR)

Sözdizimi

Açıklamalar

Örnek

deque::front_item (STL/CLR)

Sözdizimi

Açıklamalar

Örnek

deque::generic_container (STL/CLR)

Sözdizimi

Açıklamalar