lista (STL/CLR)

A classe de modelo descreve um objeto que controla uma sequência de elementos de comprimento variável que tem acesso bidirecional. Use o contêiner list para gerenciar uma sequência de elementos como uma lista vinculada bidirecional de nós, cada um armazenando um elemento.

Na descrição abaixo, GValue é o mesmo que valor a menos que este último seja um tipo ref, caso em que é Value^.

Sintaxe

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

Parâmetros

valor
O tipo de um elemento na sequência controlada.

Requerimentos

Cabeçalho:<cliext/list>

Namespace: cliext

Declarações

Interfaces

Comentários

O objeto aloca e libera armazenamento para a sequência que controla como nós individuais em uma lista de links bidirecional. Ele reorganiza os elementos alterando as ligações entre nós, nunca copiando o conteúdo de um nó para outro. Isso significa que você pode inserir e remover elementos livremente sem perturbar os elementos restantes. Assim, uma lista é um bom candidato para o contêiner subjacente para de fila de de classe de modelo (STL/CLR) ou de pilha dede classe de modelo (STL/CLR).

Um objeto list suporta iteradores bidirecionais, o que significa que você pode passar para elementos adjacentes dado um iterador que designa um elemento na sequência controlada. Um nó principal especial corresponde ao iterador retornado por list::end (STL/CLR)(). Você pode diminuir esse iterador para alcançar o último elemento na sequência controlada, se presente. Você pode incrementar um iterador de lista para alcançar o nó principal e, em seguida, ele será comparado igual a end(). Mas você não pode cancelar a referência do iterador retornado por end().

Observe que você não pode se referir a um elemento de lista diretamente, dada sua posição numérica -- isso requer um iterador de acesso aleatório. Portanto, uma lista não é utilizável como o contêiner subjacente para a classe de modelo priority_queue (STL/CLR).

Um iterador de lista armazena um identificador para seu nó de lista associado, que, por sua vez, armazena um identificador para seu contêiner associado. Você pode usar iteradores somente com seus objetos de contêiner associados. Um iterador de lista permanece válido desde que seu nó de lista associado esteja associado a alguma lista. Além disso, um iterador válido é desreferendável -- você pode usá-lo para acessar ou alterar o valor do elemento que ele designa -- desde que não seja igual a end().

Apagar ou remover um elemento chama o destruidor por seu valor armazenado. Destruir o recipiente apaga todos os elementos. Assim, um contêiner cujo tipo de elemento é uma classe ref garante que nenhum elemento sobreviva ao contêiner. Note, no entanto, que um recipiente de alças não destruir seus elementos.

Membros

lista::atribuir (STL/CLR)

Substitui todos os elementos.

Sintaxe

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);

Parâmetros

contagem
Número de elementos a inserir.

primeira
Início do intervalo a inserir.

últimos
Fim do intervalo a inserir.

direito
Enumeração a inserir.

val
Valor do elemento a ser inserido.

Comentários

A primeira função de membro substitui a sequência controlada por uma repetição de contagem elementos de valor val. Você o usa para preencher o contêiner com elementos todos com o mesmo valor.

Se InIt for um tipo inteiro, a segunda função de membro se comportará da mesma forma que assign((size_type)first, (value_type)last). Caso contrário, substitui a sequência controlada pela sequência [first, last). Você o usa para fazer com que a sequência controlada copie outra sequência.

A função de terceiro membro substitui a sequência controlada pela sequência designada pelo enumerador direita. Você o usa para tornar a sequência controlada uma cópia de uma sequência descrita por um enumerador.

Exemplo

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

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

    // assign a repetition of values
    cliext::list<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
    cliext::list<wchar_t>::iterator it = c1.end();
    c2.assign(c1.begin(), --it);
    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

lista::voltar (STL/CLR)

Acessa o último elemento.

Sintaxe

reference back();

Comentários

A função de membro retorna uma referência ao último elemento da sequência controlada, que deve ser não-vazia. Você o usa para acessar o último elemento, quando sabe que ele existe.

Exemplo

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

int main()
    {
    cliext::list<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

lista::back_item (STL/CLR)

Acessa o último elemento.

Sintaxe

property value_type back_item;

Comentários

A propriedade acessa o último elemento da sequência controlada, que deve estar não vazia. Você o usa para ler ou escrever o último elemento, quando sabe que ele existe.

Exemplo

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

int main()
    {
    cliext::list<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

lista::begin (STL/CLR)

Designa o início da sequência controlada.

Sintaxe

iterator begin();

Comentários

A função de membro retorna um iterador de acesso aleatório que designa o primeiro elemento da sequência controlada, ou logo após o final de uma sequência vazia. Você o usa para obter um iterador que designa o início current da sequência controlada, mas seu status pode mudar se o comprimento da sequência controlada mudar.

Exemplo

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

int main()
    {
    cliext::list<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::list<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

lista::clear (STL/CLR)

Remove todos os elementos.

Sintaxe

void clear();

Comentários

A função de membro efetivamente chama list::erase (STL/CLR)(list::begin (STL/CLR)(),list::end (STL/CLR)()). Use-o para garantir que a sequência controlada esteja vazia.

Exemplo

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

int main()
    {
    cliext::list<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

lista::const_iterator (STL/CLR)

O tipo de iterador constante para a sequência controlada.

Sintaxe

typedef T2 const_iterator;

Comentários

O tipo descreve um objeto de tipo não especificado T2 que pode servir como um iterador de acesso aleatório constante para a sequência controlada.

Exemplo

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

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

    // display contents " a b c"
    cliext::list<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

lista::const_reference (STL/CLR)

O tipo de referência constante a um elemento.

Sintaxe

typedef value_type% const_reference;

Comentários

O tipo descreve uma referência constante a um elemento.

Exemplo

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

int main()
    {
    cliext::list<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::list<wchar_t>::const_iterator cit = c1.begin();
    for (; cit != c1.end(); ++cit)
        {   // get a const reference to an element
        cliext::list<wchar_t>::const_reference cref = *cit;
        System::Console::Write("{0} ", cref);
        }
    System::Console::WriteLine();
    return (0);
    }

a b c

lista::const_reverse_iterator (STL/CLR)

O tipo de iterador reverso constante para a sequência controlada.

Sintaxe

typedef T4 const_reverse_iterator;

Comentários

O tipo descreve um objeto de tipo não especificado T4 que pode servir como um iterador reverso constante para a sequência controlada.

Exemplo

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

int main()
    {
    cliext::list<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::list<wchar_t>::const_reverse_iterator crit = c1.rbegin();
    cliext::list<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

lista::d ifference_type (STL/CLR)

Os tipos de uma distância assinada entre dois elementos.

Sintaxe

typedef int difference_type;

Comentários

O tipo descreve uma contagem de elementos assinados.

Exemplo

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

int main()
    {
    cliext::list<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::list<wchar_t>::difference_type diff = 0;
    for (cliext::list<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::list<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

lista::vazio (STL/CLR)

Testa se nenhum elemento está presente.

Sintaxe

bool empty();

Comentários

A função de membro retorna true para uma sequência controlada vazia. É equivalente a list::size (STL/CLR)() == 0. Use-o para testar se a lista está vazia.

Exemplo

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

int main()
    {
    cliext::list<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

lista::fim (STL/CLR)

Designa o final da sequência controlada.

Sintaxe

iterator end();

Comentários

A função de membro retorna um iterador de acesso aleatório que aponta logo além do final da sequência controlada. Você o usa para obter um iterador que designa o final da sequência controlada; seu status não muda se o comprimento da sequência controlada mudar.

Exemplo

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

int main()
    {
    cliext::list<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::list<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

list::erase (STL/CLR)

Remove elementos em posições especificadas.

Sintaxe

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

Parâmetros

primeira
Início do intervalo para apagar.

últimos
Fim do intervalo para apagar.

onde
Elemento a apagar.

Comentários

A primeira função de membro remove o elemento da sequência controlada apontada por onde. Você o usa para remover um único elemento.

A função de segundo membro remove os elementos da sequência controlada no intervalo [first, last). Use-o para remover zero ou mais elementos contíguos.

Ambas as funções de membro retornam um iterador que designa o primeiro elemento restante além de quaisquer elementos removidos, ou list::end (STL/CLR)() se tal elemento não existir.

Ao apagar elementos, o número de cópias de elementos é linear no número de elementos entre o final da eliminação e o final mais próximo da sequência. (Ao apagar um ou mais elementos em qualquer extremidade da sequência, nenhuma cópia de elemento ocorre.)

Exemplo

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

int main()
    {
    cliext::list<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::list<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

lista::frente (STL/CLR)

Acessa o primeiro elemento.

Sintaxe

reference front();

Comentários

A função member retorna uma referência ao primeiro elemento da sequência controlada, que deve ser não-vazia. Você o usa para ler ou escrever o primeiro elemento, quando sabe que ele existe.

Exemplo

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

int main()
    {
    cliext::list<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

lista::front_item (STL/CLR)

Acessa o primeiro elemento.

Sintaxe

property value_type front_item;

Comentários

A propriedade acessa o primeiro elemento da sequência controlada, que deve ser não-vazia. Você o usa para ler ou escrever o primeiro elemento, quando sabe que ele existe.

Exemplo

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

int main()
    {
    cliext::list<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

lista::generic_container (STL/CLR)

O tipo da interface genérica para o contêiner.

Sintaxe

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

Comentários

O tipo descreve a interface genérica para essa classe de contêiner de modelo.

Exemplo

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

int main()
    {
    cliext::list<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::list<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

lista::generic_iterator (STL/CLR)

O tipo de um iterador para uso com a interface genérica para o contêiner.

Sintaxe

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

Comentários

O tipo descreve um iterador genérico que pode ser usado com a interface genérica para essa classe de contêiner de modelo.

Exemplo

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

int main()
    {
    cliext::list<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::list<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::list<wchar_t>::generic_iterator gcit = gc1->begin();
    cliext::list<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

lista::generic_reverse_iterator (STL/CLR)

O tipo de iterador reverso para uso com a interface genérica para o contêiner.

Sintaxe

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

Comentários

O tipo descreve um iterador reverso genérico que pode ser usado com a interface genérica para essa classe de contêiner de modelo.

Exemplo

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

int main()
    {
    cliext::list<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::list<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::list<wchar_t>::generic_reverse_iterator gcit = gc1->rbegin();
    cliext::list<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

lista::generic_value (STL/CLR)

O tipo de um elemento para uso com a interface genérica para o contêiner.

Sintaxe

typedef GValue generic_value;

Comentários

O tipo descreve um objeto do tipo GValue que descreve o valor do elemento armazenado para uso com a interface genérica para essa classe de contêiner de modelo.

Exemplo

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

int main()
    {
    cliext::list<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::list<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::list<wchar_t>::generic_iterator gcit = gc1->begin();
    cliext::list<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

lista::inserir (STL/CLR)

Adiciona elementos em uma posição especificada.

Sintaxe

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);

Parâmetros

contagem
Número de elementos a inserir.

primeira
Início do intervalo a inserir.

últimos
Fim do intervalo a inserir.

direito
Enumeração a inserir.

val
Valor do elemento a ser inserido.

onde
Onde no recipiente para inserir antes.

Comentários

Cada uma das funções de membro insere, antes do elemento apontado por onde na sequência controlada, uma sequência especificada pelos operandos restantes.

A primeira função de membro insere um elemento com valor val e retorna um iterador que designa o elemento recém-inserido. Você o usa para inserir um único elemento antes de um local designado por um iterador.

A segunda função de membro insere uma repetição de contagem elementos de valor val. Você o usa para inserir zero ou mais elementos contíguos, que são todas cópias do mesmo valor.

Se InIt for um tipo inteiro, a função de terceiro membro se comportará da mesma forma que insert(where, (size_type)first, (value_type)last). Caso contrário, insere a sequência [first, last). Use-o para inserir zero ou mais elementos contíguos copiados de outra sequência.

A função de quarto membro insere a sequência designada pelo direito. Você o usa para inserir uma sequência descrita por um enumerador.

Ao inserir um único elemento, o número de cópias de elementos é linear no número de elementos entre o ponto de inserção e a extremidade mais próxima da sequência. (Ao inserir um ou mais elementos em qualquer extremidade da sequência, nenhuma cópia de elemento ocorre.) Se InIt é um iterador de entrada, a função de terceiro membro efetivamente executa uma única inserção para cada elemento na sequência. Caso contrário, ao inserir N elementos, o número de cópias de elementos é linear em N mais o número de elementos entre o ponto de inserção e a extremidade mais próxima da sequência.

Exemplo

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

int main()
    {
    cliext::list<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::list<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::list<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();

    // insert a single value using index
    it = c2.begin();
    ++it, ++it, ++it;
    c2.insert(it, L'z');
    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

lista::iterador (STL/CLR)

O tipo de iterador para a sequência controlada.

Sintaxe

typedef T1 iterator;

Comentários

O tipo descreve um objeto de tipo não especificado T1 que pode servir como um iterador de acesso aleatório para a sequência controlada.

Exemplo

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

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

    // display contents " a b c"
    cliext::list<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

lista::lista (STL/CLR)

Constrói um objeto de contêiner.

Sintaxe

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

Parâmetros

contagem
Número de elementos a inserir.

primeira
Início do intervalo a inserir.

últimos
Fim do intervalo a inserir.

direito
Objeto ou intervalo a ser inserido.

val
Valor do elemento a ser inserido.

Comentários

O construtor:

list();

Inicializa a sequência controlada sem elementos. Você o usa para especificar uma sequência controlada inicial vazia.

O construtor:

list(list<Value>% right);

Inicializa a sequência controlada com a sequência [right.begin(), right.end()). Você o usa para especificar uma sequência controlada inicial que é uma cópia da sequência controlada pelo objeto list direito.

O construtor:

list(list<Value>^ right);

Inicializa a sequência controlada com a sequência [right->begin(), right->end()). Você o usa para especificar uma sequência controlada inicial que é uma cópia da sequência controlada pelo objeto list cujo identificador é direito.

O construtor:

explicit list(size_type count);

Inicializa a sequência controlada com contagem elementos, cada um com valor value_type(). Você o usa para preencher o contêiner com elementos todos com o valor padrão.

O construtor:

list(size_type count, value_type val);

Inicializa a sequência controlada com contagem elementos, cada um com valor val. Você o usa para preencher o contêiner com elementos todos com o mesmo valor.

O construtor:

template<typename InIt>

list(InIt first, InIt last);

Inicializa a sequência controlada com a sequência [first, last). Você o usa para tornar a sequência controlada uma cópia de outra sequência.

O construtor:

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

Inicializa a sequência controlada com a sequência designada pelo enumerador direita. Você o usa para tornar a sequência controlada uma cópia de outra sequência descrita por um enumerador.

Exemplo

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

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

    // construct with a repetition of default values
    cliext::list<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::list<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::list<wchar_t>::iterator it = c3.end();
    cliext::list<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::list<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::list<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::list<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

lista::mesclar (STL/CLR)

Mescla duas sequências controladas ordenadas.

Sintaxe

void merge(list<Value>% right);
template<typename Pred2>
    void merge(list<Value>% right, Pred2 pred);

Parâmetros

pred
Comparador para pares de elementos.

direito
Contêiner para mesclar.

Comentários

A primeira função de membro remove todos os elementos da sequência controlada por direito e insere-os na sequência controlada. Ambas as sequências devem ser ordenadas previamente por operator< -- os elementos não devem diminuir de valor à medida que você progride em qualquer sequência. A sequência resultante também é ordenada por operator<. Use essa função de membro para mesclar duas sequências que aumentam de valor em uma sequência que também aumenta de valor.

A função de segundo membro se comporta da mesma forma que a primeira, exceto que as sequências são ordenadas por pred -- pred(X, Y) deve ser falsa para qualquer elemento X que segue o elemento Y na sequência. Você o usa para mesclar duas sequências ordenadas por um predicado, função ou delegado que você especificar.

Ambas as funções executam uma mesclagem estável -- nenhum par de elementos em qualquer uma das sequências controladas originais é revertido na sequência controlada resultante. Além disso, se um par de elementos X e Y na sequência controlada resultante tiver ordenação equivalente -- !(X < Y) && !(X < Y) -- um elemento da sequência controlada original aparecerá antes de um elemento da sequência controlada por direito.

Exemplo

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

typedef cliext::list<wchar_t> Mylist;
int main()
    {
    cliext::list<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'c');
    c1.push_back(L'e');

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

    cliext::list<wchar_t> c2;
    c2.push_back(L'b');
    c2.push_back(L'd');
    c2.push_back(L'f');

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

    // merge and display
    cliext::list<wchar_t> c3(c1);
    c3.merge(c2);
    for each (wchar_t elem in c3)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    System::Console::WriteLine("c2.size() = {0}", c2.size());

    // sort descending, merge descending, and redisplay
    c1.sort(cliext::greater<wchar_t>());
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    c3.sort(cliext::greater<wchar_t>());
    for each (wchar_t elem in c3)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    c3.merge(c1, cliext::greater<wchar_t>());
    for each (wchar_t elem in c3)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    System::Console::WriteLine("c1.size() = {0}", c1.size());
    return (0);
    }

a c e
b d f
a b c d e f
c2.size() = 0
e c a
f e d c b a
f e e d c c b a a
c1.size() = 0

lista::operador= (STL/CLR)

Substitui a sequência controlada.

Sintaxe

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

Parâmetros

direito
Recipiente para copiar.

Comentários

O operador membro copia direita para o objeto e, em seguida, retorna *this. Use-o para substituir a sequência controlada por uma cópia da sequência controlada no direito.

Exemplo

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

int main()
    {
    cliext::list<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::list<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

lista::p op_back (STL/CLR)

Remove o último elemento.

Sintaxe

void pop_back();

Comentários

A função de membro remove o último elemento da sequência controlada, que deve estar não vazia. Você o usa para encurtar a lista por um elemento na parte de trás.

Exemplo

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

int main()
    {
    cliext::list<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

lista::p op_front (STL/CLR)

Remove o primeiro elemento.

Sintaxe

void pop_front();

Comentários

A função de membro remove o primeiro elemento da sequência controlada, que deve ser não-vazia. Você o usa para encurtar a lista por um elemento na frente.

Exemplo

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

int main()
    {
    cliext::list<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

lista::p ush_back (STL/CLR)

Adiciona um novo último elemento.

Sintaxe

void push_back(value_type val);

Comentários

A função membro insere um elemento com valor val no final da sequência controlada. Use-o para acrescentar outro elemento à lista.

Exemplo

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

int main()
    {
    cliext::list<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

lista::p ush_front (STL/CLR)

Adiciona um novo primeiro elemento.

Sintaxe

void push_front(value_type val);

Comentários

A função de membro insere um elemento com valor val no início da sequência controlada. Você o usa para inserir outro elemento na lista.

Exemplo

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

int main()
    {
    cliext::list<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

lista::rbegin (STL/CLR)

Designa o início da sequência controlada invertida.

Sintaxe

reverse_iterator rbegin();

Comentários

A função de membro retorna um iterador reverso que designa o último elemento da sequência controlada, ou logo após o início de uma sequência vazia. Assim, designa o beginning da sequência inversa. Você o usa para obter um iterador que designa o início current da sequência controlada vista em ordem inversa, mas seu status pode mudar se o comprimento da sequência controlada mudar.

Exemplo

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

int main()
    {
    cliext::list<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::list<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

lista::referência (STL/CLR)

O tipo de referência a um elemento.

Sintaxe

typedef value_type% reference;

Comentários

O tipo descreve uma referência a um elemento.

Exemplo

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

int main()
    {
    cliext::list<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::list<wchar_t>::iterator it = c1.begin();
    for (; it != c1.end(); ++it)
        {   // get a reference to an element
        cliext::list<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::list<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

lista::remover (STL/CLR)

Remove um elemento com um valor especificado.

Sintaxe

void remove(value_type val);

Parâmetros

val
Valor do elemento a ser removido.

Comentários

A função de membro remove um elemento na sequência controlada para o qual ((System::Object^)val)->Equals((System::Object^)x) é verdadeiro (se houver). Você o usa para apagar um elemento arbitrário com o valor especificado.

Exemplo

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

int main()
    {
    cliext::list<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();

    // fail to remove and redisplay
    c1.remove(L'A');
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // remove and redisplay
    c1.remove(L'b');
    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

lista::remove_if (STL/CLR)

Remove elementos que passam em um teste especificado.

Sintaxe

template<typename Pred1>
    void remove_if(Pred1 pred);

Parâmetros

pred
Teste os elementos a serem removidos.

Comentários

A função de membro remove da sequência controlada (apaga) todos os elementos X para os quais pred(X) é verdadeira. Você o usa para remover todos os elementos que satisfazem uma condição especificada como uma função ou delegado.

Exemplo

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

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

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

    // fail to remove and redisplay
    c1.remove_if(cliext::binder2nd<cliext::equal_to<wchar_t> >(
        cliext::equal_to<wchar_t>(), L'd'));
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // remove and redisplay
    c1.remove_if(cliext::binder2nd<cliext::not_equal_to<wchar_t> >(
        cliext::not_equal_to<wchar_t>(), L'b'));
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

a b b b c
a b b b c
b b b

lista::rend (STL/CLR)

Designa o final da sequência controlada invertida.

Sintaxe

reverse_iterator rend();

Comentários

A função de membro retorna um iterador reverso que aponta logo além do início da sequência controlada. Assim, designa o end da sequência inversa. Você o usa para obter um iterador que designa a extremidade current da sequência controlada vista em ordem inversa, mas seu status pode mudar se o comprimento da sequência controlada mudar.

Exemplo

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

int main()
    {
    cliext::list<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::list<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

lista::redimensionamento (STL/CLR)

Altera o número de elementos.

Sintaxe

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

Parâmetros

new_size
Novo tamanho da sequência controlada.

val
Valor do elemento de preenchimento.

Comentários

As funções de membro garantem que list::size (STL/CLR)() doravante retorne new_size. Se tiver de tornar a sequência controlada mais longa, a função de primeiro membro acrescenta elementos com valor value_type(), enquanto a função de segundo membro acrescenta elementos com valor val. Para tornar a sequência controlada mais curta, ambas as funções de membro efetivamente apagam o último elemento list::size (STL/CLR)() -new_size vezes. Use-o para garantir que a sequência controlada tenha tamanho new_size, cortando ou preenchendo a sequência controlada atual.

Exemplo

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

int main()
    {
// construct an empty container and pad with default values
    cliext::list<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

lista::reverso (STL/CLR)

Inverte a sequência controlada.

Sintaxe

void reverse();

Comentários

A função de membro inverte a ordem de todos os elementos na sequência controlada. Você o usa para refletir uma lista de elementos.

Exemplo

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

int main()
    {
    cliext::list<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();

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

a b c
c b a

lista::reverse_iterator (STL/CLR)

O tipo de iterador reverso para a sequência controlada.

Sintaxe

typedef T3 reverse_iterator;

Comentários

O tipo descreve um objeto de tipo não especificado T3 que pode servir como um iterador reverso para a sequência controlada.

Exemplo

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

int main()
    {
    cliext::list<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::list<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

lista::tamanho (STL/CLR)

Conta o número de elementos.

Sintaxe

size_type size();

Comentários

A função de membro retorna o comprimento da sequência controlada. Você o usa para determinar o número de elementos atualmente na sequência controlada. Se tudo o que lhe interessa é se a sequência tem um tamanho diferente de zero, consulte list::empty (STL/CLR)().

Exemplo

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

int main()
    {
    cliext::list<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

lista::size_type (STL/CLR)

O tipo de distância assinada entre dois elementos.

Sintaxe

typedef int size_type;

Comentários

O tipo descreve uma contagem de elementos não negativos.

Exemplo

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

int main()
    {
    cliext::list<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::list<wchar_t>::size_type diff = 0;
    for (cliext::list<wchar_t>::iterator it = c1.begin();
        it != c1.end(); ++it)
        ++diff;
    System::Console::WriteLine("end()-begin() = {0}", diff);
    return (0);
    }

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

lista::sort (STL/CLR)

Ordena a sequência controlada.

Sintaxe

void sort();
template<typename Pred2>
    void sort(Pred2 pred);

Parâmetros

pred
Comparador para pares de elementos.

Comentários

A primeira função de membro reorganiza os elementos na sequência controlada para que eles sejam ordenados por operator< -- os elementos não diminuem de valor à medida que você progride pela sequência. Você usa essa função de membro para classificar a sequência em ordem crescente.

A segunda função de membro se comporta da mesma forma que a primeira, exceto que a sequência é ordenada por pred -- pred(X, Y) é falsa para qualquer elemento X que segue o elemento Y na sequência resultante. Você o usa para classificar a sequência em uma ordem especificada por um predicado, função ou delegado.

Ambas as funções executam uma classificação estável -- nenhum par de elementos na sequência controlada original é revertido na sequência controlada resultante.

Exemplo

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

int main()
    {
    cliext::list<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();

    // sort descending and redisplay
    c1.sort(cliext::greater<wchar_t>());
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

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

a b c
c b a
a b c

lista::emenda (STL/CLR)

Restitch links entre nós.

Sintaxe

void splice(iterator where, list<Value>% right);
void splice(iterator where, list<Value>% right,
    iterator first);
void splice(iterator where, list<Value>% right,
    iterator first, iterator last);

Parâmetros

primeira
Início do intervalo para emendar.

últimos
Fim do intervalo para emendar.

direito
Recipiente para emendar.

onde
Onde no recipiente para emendar antes.

Comentários

A primeira função de membro insere a sequência controlada por direito antes do elemento na sequência controlada apontado por onde. Ele também remove todos os elementos do direito. (%right não deve ser igual a this.) Você o usa para emendar toda uma lista em outra.

A função de segundo membro remove o elemento apontado por primeiro na sequência controlada por direita e o insere antes do elemento na sequência controlada apontada por onde. (Se where==first||where== ++first, nenhuma alteração ocorre.) Você o usa para emendar um único elemento de uma lista em outra.

A função de terceiro membro insere o subintervalo designado por [first, last) a partir da sequência controlada por direito antes do elemento na sequência controlada apontado por onde. Ele também remove o subintervalo original da sequência controlada por direita. (Se right == this, o intervalo [first, last) não deve incluir o elemento apontado por em que.) Você o usa para emendar uma subsequência de zero ou mais elementos de uma lista em outra.

Exemplo

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

int main()
    {
    cliext::list<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();

    // splice to a new list
    cliext::list<wchar_t> c2;
    c2.splice(c2.begin(), c1);
    System::Console::WriteLine("c1.size() = {0}", c1.size());
    for each (wchar_t elem in c2)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // return one element
    c1.splice(c1.end(), c2, c2.begin());
    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 remaining elements
    c1.splice(c1.begin(), c2, c2.begin(), c2.end());
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    System::Console::WriteLine("c2.size() = {0}", c2.size());
    return (0);
    }

a b c
c1.size() = 0
a b c
a
b c
b c a
c2.size() = 0

lista::swap (STL/CLR)

Troca o conteúdo de dois contêineres.

Sintaxe

void swap(list<Value>% right);

Parâmetros

direito
Recipiente com o qual trocar conteúdo.

Comentários

A função de membro troca as sequências controladas entre *this e direito. Fá-lo em tempo constante e não abre exceções. Você o usa como uma maneira rápida de trocar o conteúdo de dois recipientes.

Exemplo

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

int main()
    {
    cliext::list<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::list<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

lista::to_array (STL/CLR)

Copia a sequência controlada para uma nova matriz.

Sintaxe

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

Comentários

A função de membro retorna uma matriz que contém a sequência controlada. Você o usa para obter uma cópia da sequência controlada em forma de matriz.

Exemplo

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

int main()
    {
    cliext::list<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

lista::unique (STL/CLR)

Remove elementos adjacentes que passam em um teste especificado.

Sintaxe

void unique();
template<typename Pred2>
    void unique(Pred2 pred);

Parâmetros

pred
Comparador para pares de elementos.

Comentários

A primeira função de membro remove da sequência controlada (apaga) todos os elementos que se comparam de forma igual ao seu elemento anterior -- se o elemento X precede o elemento Y e X == Y, a função de membro remove Y. Você o usa para remover todas, exceto uma, cópia de cada subsequência de elementos adjacentes que comparam iguais. Observe que, se a sequência controlada for ordenada, como chamando list::sort (STL/CLR)(), a função membro deixará apenas elementos com valores exclusivos. (Daí o nome).

A função de segundo membro se comporta da mesma forma que a primeira, exceto que remove cada elemento Y seguindo um elemento X para o qual pred(X, Y). Você o usa para remover todas, exceto uma, cópia de cada subsequência de elementos adjacentes que satisfazem um predicado, função ou delegado que você especificar. Observe que, se a sequência controlada for ordenada, como chamando sort(pred), a função membro deixará apenas elementos que não têm ordenação equivalente com quaisquer outros elementos.

Exemplo

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

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

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

    // display contents after unique
    cliext::list<wchar_t> c2(c1);
    c2.unique();
    for each (wchar_t elem in c2)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // display contents after unique(not_equal_to)
    c2 = c1;
    c2.unique(cliext::not_equal_to<wchar_t>());
    for each (wchar_t elem in c2)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

a a b c
a b c
a a

lista::value_type (STL/CLR)

O tipo de um elemento.

Sintaxe

typedef Value value_type;

Comentários

O tipo é um sinônimo para o parâmetro de modelo Value.

Exemplo

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

int main()
    {
    cliext::list<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::list<wchar_t>::iterator it = c1.begin();
        it != c1.end(); ++it)
        {   // store element in value_type object
        cliext::list<wchar_t>::value_type val = *it;

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

a b c

operador!= (lista) (STL/CLR)

Lista não igual comparação.

Sintaxe

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

Parâmetros

deixou
Recipiente esquerdo para comparar.

direito
Recipiente certo para comparar.

Comentários

A função de operador retorna !(left == right). Você o usa para testar se esquerdo não está ordenado da mesma forma que direito quando as duas listas são comparadas elemento por elemento.

Exemplo

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

int main()
    {
    cliext::list<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::list<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< (lista) (STL/CLR)

Listar menos do que comparação.

Sintaxe

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

Parâmetros

deixou
Recipiente esquerdo para comparar.

direito
Recipiente certo para comparar.

Comentários

A função do operador retorna true se, para a posição mais baixa i para a qual !(right[i] < left[i]) também é verdade que left[i] < right[i]. Caso contrário, ele retornará left->size() < right->size() Você usá-lo para testar se esquerdo é ordenado antes direita quando as duas listas são comparadas elemento por elemento.

Exemplo

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

int main()
    {
    cliext::list<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::list<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<= (lista) (STL/CLR)

Listar comparação menor ou igual.

Sintaxe

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

Parâmetros

deixou
Recipiente esquerdo para comparar.

direito
Recipiente certo para comparar.

Comentários

A função de operador retorna !(right < left). Você o usa para testar se esquerdo não é ordenado após direito quando as duas listas são comparadas elemento por elemento.

Exemplo

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

int main()
    {
    cliext::list<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::list<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

operador== (lista) (STL/CLR)

Listar comparação igual.

Sintaxe

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

Parâmetros

deixou
Recipiente esquerdo para comparar.

direito
Recipiente certo para comparar.

Comentários

A função de operador retorna true somente se as sequências controladas por esquerda e direita tiverem o mesmo comprimento e, para cada posição i, left[i] ==right[i]. Você o usa para testar se esquerdo está ordenado da mesma forma que direita quando as duas listas são comparadas elemento por elemento.

Exemplo

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

int main()
    {
    cliext::list<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::list<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> (lista) (STL/CLR)

Lista maior do que comparação.

Sintaxe

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

Parâmetros

deixou
Recipiente esquerdo para comparar.

direito
Recipiente certo para comparar.

Comentários

A função de operador retorna right<left. Você o usa para testar se esquerdo é ordenado após direito quando as duas listas são comparadas elemento por elemento.

Exemplo

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

int main()
    {
    cliext::list<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::list<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>= (lista) (STL/CLR)

Lista maior ou igual à comparação.

Sintaxe

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

Parâmetros

deixou
Recipiente esquerdo para comparar.

direito
Recipiente certo para comparar.

Comentários

A função de operador retorna !(left<right). Você o usa para testar se esquerdo não está ordenado antes direito quando as duas listas são comparadas elemento por elemento.

Exemplo

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

int main()
    {
    cliext::list<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::list<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