map (STL/CLR)

Artigo
06/10/2015

A classe do modelo descreve um objeto que controla uma sequência de variar- comprimento de elementos que tenha acesso bidirecional. Você usa o contêiner map para gerenciar uma sequência de elementos como (quase) equilibrou a árvore ordenada de nós, cada um elemento armazenando. Um elemento consiste em uma chave, para ordenar a sequência, e um valor mapeado, desde que vai para o passeio.

Na descrição abaixo, GValue é o mesmo que:

Microsoft::VisualC::StlClr::GenericPair<GKey, GMapped>

onde:

GKey é o mesmo que Key a menos que o último é um tipo de referência, nesse caso é Key^

GMapped é o mesmo que Mapped a menos que o último é um tipo de referência, nesse caso é Mapped^

template<typename Key,
    typename Mapped>
    ref class map
        :   public
        System::ICloneable,
        System::Collections::IEnumerable,
        System::Collections::ICollection,
        System::Collections::Generic::IEnumerable<GValue>,
        System::Collections::Generic::ICollection<GValue>,
        System::Collections::Generic::IList<GValue>,
        System::Collections::Generic::IDictionary<Gkey, GMapped>,
        Microsoft::VisualC::StlClr::ITree<Gkey, GValue>
    { ..... };

Parâmetros

Chave
O tipo de componente principal de um elemento na sequência controlada.
Mapeado
O tipo de componente adicional de um elemento na sequência controlada.

Membros

Definição de tipo	Descrição
map::const_iterator (STL/CLR)	O tipo de um iterador de constante para a sequência controlada.
map::const_reference (STL/CLR)	O tipo de uma referência constante para um elemento.
map::const_reverse_iterator (STL/CLR)	O tipo de um iterador invertido constante para a sequência controlada.
map::difference_type (STL/CLR)	O tipo de distância de possivelmente (assinado) entre dois elementos.
map::generic_container (STL/CLR)	O tipo de interface genérica para o contêiner.
map::generic_iterator (STL/CLR)	O tipo de um iterador para a interface genérica para o contêiner.
map::generic_reverse_iterator (STL/CLR)	O tipo de um iterador de cima para baixo para a interface genérica para o contêiner.
map::generic_value (STL/CLR)	O tipo de um elemento para a interface genérica para o contêiner.
map::iterator (STL/CLR)	O tipo de um iterador para a sequência controlada.
map::key_compare (STL/CLR)	O delegado de ordenação para duas chaves.
map::key_type (STL/CLR)	O tipo de uma chave classificação.
map::mapped_type (STL/CLR)	O tipo do valor mapeado associado a cada chave.
map::reference (STL/CLR)	O tipo de uma referência para um elemento.
map::reverse_iterator (STL/CLR)	O tipo de um iterador de cima para baixo para a sequência controlada.
map::size_type (STL/CLR)	O tipo de distância (não negativo) de entre dois elementos.
map::value_compare (STL/CLR)	O delegado de ordenação para dois valores do elemento.
map::value_type (STL/CLR)	O tipo de um elemento.

Função de membro	Descrição
map::begin (STL/CLR)	Designa o início da sequência controlada.
map::clear (STL/CLR)	Remove todos os elementos.
map::count (STL/CLR)	Conta os elementos que correspondem a uma chave especificada.
map::empty (STL/CLR)	Testa se nenhum elemento estiver presente.
map::end (STL/CLR)	Designa o término da sequência controlada.
map::equal_range (STL/CLR)	Encontra variam que corresponde a uma chave especificada.
map::erase (STL/CLR)	Remove os elementos nas posições especificadas.
map::find (STL/CLR)	Localiza um elemento que corresponde a uma chave especificada.
map::insert (STL/CLR)	Adiciona os elementos.
map::key_comp (STL/CLR)	Copia o representante de ordenação para duas chaves.
map::lower_bound (STL/CLR)	Localiza o início do intervalo que corresponde a uma chave especificada.
map::make_value (STL/CLR)	Cria um objeto de valor.
map::map (STL/CLR)	Cria um objeto contêiner.
map::rbegin (STL/CLR)	Designa o início da sequência controlada invertida.
map::rend (STL/CLR)	Designa o término da sequência controlada invertida.
map::size (STL/CLR)	Conta o número de elementos.
map::swap (STL/CLR)	Alterna o conteúdo de dois contêineres.
map::to_array (STL/CLR)	Copia a sequência controlada a uma nova matriz.
map::upper_bound (STL/CLR)	Localiza de extremidade do intervalo que corresponde a uma chave especificada.
map::value_comp (STL/CLR)	Copia o representante de ordenação para dois valores do elemento.

Operador	Descrição
map::operator= (STL/CLR)	Substitui a sequência controlada.
map::operator[] (STL/CLR)	Mapeia uma chave para o valor mapeado associado.
operador!= (map) (STL/CLR)	Determina se um objeto de map não é igual a outro objeto de map .
operador< (map) (STL/CLR)	Determina se um objeto de map é menor que outro objeto de map .
operador<= (map) (STL/CLR)	Determina se um objeto de map é menor ou igual a outro objeto de map .
operador== (map) (STL/CLR)	Determina se um objeto de map é igual a outro objeto de map .
operador> (map) (STL/CLR)	Determina se um objeto de map é maior que outro objeto de map .
operador>= (map) (STL/CLR)	Determina se um objeto de map é maior ou igual a outro objeto de map .

Interfaces

Interface	Descrição
ICloneable	Duplica um objeto.
IEnumerable	Sequência por meio dos elementos.
ICollection	Mantenha o grupo de elementos.
IEnumerable	Sequência por meio dos elementos digitados.
ICollection	Mantenha o grupo de elementos de tipo.
IDictionary	Mantenha o grupo {} valor de chave, o par.
ITreeKey<, valor>	Mantenha o contêiner genérico.

Comentários

O objeto aloca e libera armazenamento para a sequência que controla como nós individuais. Insere os elementos da (quase) equilibrou a árvore que mantém ordenado alterando os links entre nós, nunca copiar o conteúdo de um nó para outro. Isso significa que você pode inserir e remover os elementos livremente sem os outros elementos de perturbação.

O objeto classifica a sequência que controla chamando um objeto armazenado delegado do tipo map::key_compare (STL/CLR). Você pode especificar o objeto armazenado delegado quando você constrói o mapa; se você não especificar um objeto de delegação, o padrão será a comparação operator<(key_type, key_type). Você acessa esse objeto armazenado chamando a função de membro map::key_comp (STL/CLR)().

Esse objeto de delegação restrita deve impor a ordenação fraco em chaves do tipo map::key_type (STL/CLR). Isso significa que, para algumas duas chaves X e Y:

key_comp()(X, Y) retorna o mesmo resultado booliano em cada chamada.

Se key_comp()(X, Y) é true, então key_comp()(Y, X) deve ser false.

Se key_comp()(X, Y) é true, então X seriam ordenado antes de Y.

Se !key_comp()(X, Y) && !key_comp()(Y, X) é true, então X e Y são ditos ter ordenação equivalente.

Para qualquer elemento X que preceder Y na sequência controlada, key_comp()(Y, X) será false. (Para o objeto padrão de delegação, as chaves nunca diminuem em valor.) Ao contrário da classe map (STL/CLR)do modelo, um objeto da classe map do modelo não exige que as chaves para todos os elementos são exclusivos. (Dois ou mais chaves podem ter ordenação equivalente.)

Cada elemento contém uma chave separada e um valor mapeado. A sequência é representada de forma a permitir que a pesquisa, inserir, e a remoção de um elemento com um número arbitrário de operações proporcionais ao logaritmo o número de elementos na sequência (hora logarítmicos). Além disso, inserindo um elemento não invalida iteradores, e removendo um elemento invalida apenas os iteradores que apontam no elemento removido.

Um mapa oferece suporte aos iteradores bidirecionais, o que significa que você pode avançar para os elementos adjacentes um iterador dados que designa um elemento na sequência controlada. Um nó principal especial corresponde ao iterador retornado por map::end (STL/CLR)(). Você pode diminuir este iterador para alcançar o elemento o mais recente na sequência controlada, se houver. É possível incrementar um iterador do mapa para alcançar o nó principal, e comparará no igual a end(). Mas você não pode desreferenciar o iterador retornado por end().

Observe que você não pode se referir a um elemento do mapa determinado diretamente a posição numérica -- isso requer um iterador de acesso aleatório.

Um iterador do mapa armazena um identificador para o nó associado do mapa, por sua vez que armazena um identificador para o contêiner associado. Você pode usar iteradores apenas com seus objetos de contêiner associados. Um iterador do mapa permanece válido desde que o nó associado do mapa é associado a um mapa. Além disso, um iterador válido é dereferencable -- você pode usá-lo para acessar ou modificar o valor do elemento que designa -- contanto que não é igual a end().

Apagando ou removendo um elemento chama o destruidor para seu valor armazenado. Destruir o contêiner apaga todos os elementos. Assim, um contêiner cujo tipo de elemento é uma classe de referência garante que nenhum elemento é maior que o contêiner. A observe, entretanto, que manipula um contêiner faz not destrói seus elementos.