Como usar o mapa não ordenado C ++

How Use C Unordered Map



Um mapa, também conhecido como array associativo, é uma lista de elementos, onde cada elemento é um par chave / valor. Portanto, cada chave corresponde a um valor. Chaves diferentes podem ter o mesmo valor, para trabalho normal. Por exemplo, as chaves podem ser uma lista de frutas e os valores correspondentes, as cores das frutas. Em C ++, o mapa é implementado como uma estrutura de dados com funções de membro e operadores. Um mapa ordenado é aquele em que os pares de elementos foram ordenados por chaves. Um mapa não ordenado é aquele em que não há ordem. Este artigo explica como usar o mapa não ordenado C ++, escrito como unordered_map. Você precisa de conhecimento em ponteiros C ++ para entender este artigo. unordered_map faz parte da biblioteca padrão C ++.

Classe e Objetos

Uma classe é um conjunto de variáveis ​​e funções que funcionam juntas, onde as variáveis ​​não têm valores atribuídos. Quando os valores são atribuídos às variáveis, a classe se torna um objeto. Valores diferentes dados à mesma classe resultam em objetos diferentes; ou seja, objetos diferentes são a mesma classe com valores diferentes. A criação de um objeto a partir de uma classe é considerada uma instância do objeto.







O nome, unordered_map, é uma classe. Um objeto criado a partir da classe unordered_map tem um nome escolhido pelo programador.



Uma função que pertence a uma classe é necessária para instanciar um objeto da classe. Em C ++, essa função tem o mesmo nome que o nome da classe. Os objetos criados (instanciados) a partir da classe têm nomes diferentes dados a eles, pelo programador.



Criar um objeto da classe significa construir o objeto; também significa instanciar.





Um programa C ++ que usa a classe unordered_map começa com as seguintes linhas na parte superior do arquivo:

#incluir
#incluir
usando namespace std;

A primeira linha é para entrada / saída. A segunda linha é para permitir que o programa use todos os recursos da classe unordered_map. A terceira linha permite que o programa use os nomes no namespace padrão.



Sobrecarregando uma função

Quando duas ou mais assinaturas de função diferentes têm o mesmo nome, diz-se que esse nome está sobrecarregado. Quando uma função é chamada, o número e o tipo de argumentos determinam qual função é realmente executada.

Construção / cópia de construção

Construção Simples

Um mapa não ordenado pode ser construído e valores atribuídos da seguinte forma:

unordered_map<const Caracteres*, const Caracteres*>umap;

umap['banana'] = 'amarelo';
umap['uva'] = 'verde';
umap['FIG'] = 'roxa';

A declaração começa com a especialização do modelo com os tipos dos pares de chave e valor. Isso é seguido pelo nome escolhido pelo programador para o mapa; em seguida, um ponto e vírgula. O segundo segmento de código mostra como atribuir valores a suas chaves.
Construção por Initializer_list
Isso pode ser feito da seguinte forma:

unordered_map<const Caracteres*, const Caracteres*>umap({{'banana', 'amarelo'},
{'uva', 'verde'}, {'FIG', 'roxa'}});

Construção atribuindo Initializer_list
Exemplo:

unordered_map<const Caracteres*, const Caracteres*>umap= {{'banana', 'amarelo'},
{'uva', 'verde'}, {'FIG', 'roxa'}};

Construção copiando outro unordered_map
Exemplo:

unordered_map<const Caracteres*, const Caracteres*>umap1({{'banana', 'amarelo'},
{'uva', 'verde'}, {'FIG', 'roxa'}});
unordered_map<const Caracteres*, const Caracteres*>umap2(umap1);

O elemento par

O código a seguir mostra como criar e acessar o elemento de par:

par<Caracteres, const Caracteres*>pr= {'d', 'ser'};
custo<<pr.primeiro << ' n';
custo<<pr.segundo << ' n';

O resultado é:

d
ser

primeiro e segundo são palavras reservadas para os dois itens do par. Os valores do par ainda podem ser alterados usando o primeiro e o segundo.

Um par é chamado, value_type no tópico do mapa não ordenado.

Acesso ao elemento unordered_map

mapped_type & operator [] (key_type && k)
Retorna o valor da chave correspondente. Exemplo:

unordered_map<const Caracteres*, const Caracteres*>umap;

umap['banana'] = 'amarelo';
umap['uva'] = 'verde';
umap['FIG'] = 'roxa';

const Caracteres *direito=umap['uva'];

custo<<direito<<' n';

A saída é: verde. Os valores podem ser atribuídos da mesma forma - veja acima.

capacidade unordered_map

size_type size () const noexcept
Retorna o número de pares no mapa.

unordered_map<const Caracteres*, const Caracteres*>umap;

umap['banana'] = 'amarelo';
umap['uva'] = 'verde';
umap['FIG'] = 'roxa';

custo<<umap.Tamanho() <<' n';

A saída é 3.

bool empty () const noexcept

Retorna 1 para verdadeiro se o mapa não tiver par e 0 para falso se tiver pares. Exemplo:

unordered_map<const Caracteres*, const Caracteres*>umap;
custo<<umap.vazio() <<' n';

A saída é 1.

Retornando Iteradores e a Classe de mapa não ordenado

Um iterador é como um ponteiro, mas tem mais funcionalidade do que o ponteiro.

begin () noexcept

Retorna um iterador que aponta para o primeiro par do objeto de mapa, como no seguinte segmento de código:

unordered_map<const Caracteres*, const Caracteres*>umap;

umap['banana'] = 'amarelo';umap['uva'] = 'verde';umap['FIG'] = 'roxa';

unordered_map<const Caracteres*, const Caracteres*> ::iteradoriter=umap.começar();
par<const Caracteres*, const Caracteres*>pr= *iter;
custo<<pr.primeiro << ',' <<pr.segundo << ' n';

O resultado é: fig, roxo. O mapa não está ordenado.

begin () const noexcept;

Retorna um iterador que aponta para o primeiro elemento da coleção de objetos de mapa. Quando a construção do objeto é precedida por const, a expressão begin () const é executada em vez de begin (). Sob esta condição, os elementos no objeto não podem ser modificados. Ele é usado no código a seguir, por exemplo.

constunordered_map<const Caracteres*, const Caracteres*>umap({{'banana', 'amarelo'},
{'uva', 'verde'}, {'FIG', 'roxa'}});

unordered_map<const Caracteres*, const Caracteres*> ::const_iteratoriter=umap.começar();
par<const Caracteres*, const Caracteres*>pr= *iter;
custo<<pr.primeiro << ',' <<pr.segundo << ' n';

O resultado é: fig, roxo. O mapa não está ordenado. Observe que const_iterator foi usado desta vez, em vez de apenas iterador, para receber o iterador retornado.

end () noexcept

Retorna um iterador que aponta imediatamente além do último elemento do objeto de mapa.

end () const noexcept

Retorna um iterador que aponta imediatamente além do último elemento do objeto de mapa. Quando a construção do objeto de mapa é precedida por const, a expressão end () const é executada em vez de end ().

Operações unordered_map

iterador find (const key_type & k)

Pesquisa um par da chave fornecida no mapa. Se for encontrado, ele retorna o iterador. Se não for encontrado, ele retorna um iterador que aponta para o final do mapa, que não é um par. O código a seguir mostra como usar esta função de membro:

unordered_map<Caracteres,Caracteres>umap;

umap['para'] = 'b';umap['c'] = 'd';umap['E'] = 'f';

unordered_map<Caracteres,Caracteres> ::iteradoriter=umap.achar('c');
E se (umap.achar('c') ! =umap.fim())
{
par<Caracteres,Caracteres>pr= *iter;
custo<<pr.primeiro << ',' <<pr.segundo << ' n';
}

A saída é: c, d

const_iterator find (const key_type & k) const;

Esta versão da função é chamada, se a criação do mapa não ordenado começar com const, tornando todos os elementos do mapa somente leitura.

Modificadores unordered_map

inserção de par (tipo_valor && obj)
Um mapa não ordenado significa que os pares não estão em nenhuma ordem. Assim, o programa insere o par em qualquer lugar que achar conveniente. A função retorna, par. Se a inserção for bem-sucedida, o bool será 1 para verdadeiro, caso contrário, será 0 para falso. Se a inserção for bem-sucedida, o iterador apontará para o elemento recém-inserido. O código a seguir ilustra o uso:

unordered_map<const Caracteres*, const Caracteres*>umap;

umap['banana'] = 'amarelo';
umap['uva'] = 'verde';
umap['FIG'] = 'roxa';

umap.inserir({{'cereja', 'internet'}, {'morango', 'internet'}});

custo<<umap.Tamanho() << ' n';

O resultado é: 5. Mais de um par pode ser inserido.

size_type erase (const key_type & k)

Esta função apaga um par do unordered_map. O seguinte segmento de código ilustra:

unordered_map<const Caracteres*, const Caracteres*>umap;

umap['banana'] = 'amarelo';
umap['uva'] = 'verde';
umap['FIG'] = 'roxa';

intnum=umap.apagar('uva');

custo<<umap.Tamanho() << ' n';

A saída é 2.
void swap (unordered_map &)
Dois mapas não ordenados podem ser trocados, conforme ilustrado neste segmento de código:

unordered_map<const Caracteres*, const Caracteres*>umap1= {{'banana', 'amarelo'},
{'uva', 'verde'}, {'FIG', 'roxa'}, {'morango', 'internet'}};

unordered_map<const Caracteres*, const Caracteres*>umap2= {{'cereja', 'internet'}, {'Lima', 'verde'}};

umap1.troca(umap2);

unordered_map<const Caracteres*, const Caracteres*> ::iteradoriter1=umap1.começar();
par<const Caracteres*, const Caracteres*>pr1= *iter1;
unordered_map<const Caracteres*, const Caracteres*> ::iteradoriter2=umap2.começar();
par<const Caracteres*, const Caracteres*>pr2= *iter2;

custo<< 'Primeira chave e tamanho de umap1:'<<pr1.primeiro <<','<<umap1.Tamanho() << ' n';
custo<< 'Primeira chave e tamanho de umap2'<<pr2.primeiro <<','<<umap2.Tamanho() << ' n';
unordered_map<const Caracteres*, const Caracteres*>umap1= {{'banana', 'amarelo'},
{'uva', 'verde'}, {'FIG', 'roxa'}, {'morango', 'internet'}};
unordered_map<const Caracteres*, const Caracteres*>umap2= {{'cereja', 'internet'}, {'Lima', 'verde'}};

umap1.troca(umap2);

unordered_map<const Caracteres*, const Caracteres*> ::iteradoriter1=umap1.começar();
par<const Caracteres*, const Caracteres*>pr1= *iter1;
unordered_map<const Caracteres*, const Caracteres*> ::iteradoriter2=umap2.começar();
par<const Caracteres*, const Caracteres*>pr2= *iter2;

custo<< 'Primeira chave e tamanho de umap1:'<<pr1.primeiro <<','<<umap1.Tamanho() << ' n';
custo<< 'Primeira chave e tamanho de umap2'<<pr2.primeiro <<','<<umap2.Tamanho() << ' n';

O resultado é:

Primeira chave e tamanho de umap1: limão, 2

Primeira chave e tamanho de umap2 morango, 4

O mapa não está ordenado. Observe que o comprimento de um mapa é aumentado, se necessário. Os tipos de dados devem ser os mesmos.

Classe e seus objetos instanciados

Um valor está para um tipo de dados, assim como um objeto instanciado está para uma classe. A construção do mapa não ordenado também pode aceitar uma classe como um tipo de dados. O programa a seguir ilustra isso:

#incluir
#incluir
usando namespace std;

classe TheCla
{
público:
intnum;
estático CaracteresCH;

vaziofunção(Caracteresnão, const Caracteres *p)
{
custo<< 'Existem ' <<num<< 'livros que valem' <<não<<p<< ' na loja.' << ' n';
}
estático vazioDiversão(CaracteresCH)
{
E se (CH== 'para')
custo<< 'Função de membro estático oficial' << ' n';
}
};

inta Principal()
{
TheCla obj1;TheCla obj2;TheCla obj3;TheCla obj4;TheCla obj5;

unordered_map<const Caracteres*,TheCla>umap;
umap= {{'banana',obj1}, {'uva',obj2}, {'FIG',obj3}, {'morango',obj4}, {'Lima',obj5}};

custo<<umap.Tamanho() << ' n';

Retorna 0;
}

O resultado é: 5.

A definição de classe tem dois membros públicos de dados e duas funções de membro público. Na função main (), diferentes objetos para a classe são instanciados. Um mapa não ordenado é então instanciado, onde cada par consiste no nome de uma fruta e um objeto da classe. O tamanho do mapa é exibido. O programa é compilado sem aviso ou mensagem de erro.

Aplicação do Mapa

A matriz associa um índice a um valor. Os pares de chave / valor existem em muitas situações na vida, que podem ser programados. O par chave / valor de fruta / cor é apenas um exemplo. Outro exemplo é o nome das pessoas e suas idades. Nesse caso, o par será de um tipo, par. Também pode ser par. Neste último caso, será aplicada a diretiva de pré-processamento. Um par de chave / valor ainda pode ser o nome de casais. Em países onde há poligamia, haverá esposas diferentes para um homem.

Formação de um Mapa

Um mapa não é uma matriz bidimensional com duas colunas. Um mapa funciona com uma função hash. A chave é codificada pela função hash, em um inteiro de uma matriz. É essa matriz que contém os valores. Portanto, há na verdade uma matriz com os valores, e as chaves são mapeadas para os índices da matriz e, portanto, as correspondências entre as chaves e os valores são feitas. O hash é um tópico extenso e não é abordado neste artigo.

Conclusão

Um mapa, também conhecido como array associativo, é uma lista de elementos, onde cada elemento é um par chave / valor. Portanto, cada chave corresponde a um valor. Em C ++, o mapa é implementado como uma estrutura de dados com funções de membro e operadores. Um mapa ordenado é aquele em que os pares de elementos foram ordenados por chaves. Um mapa não ordenado é aquele em que não há ordenação.

Tecnicamente, um hash consiste em elementos de pares. Na verdade, o par é uma estrutura de dados completa com suas funções-membro e operadores. Os dois parâmetros de modelo para o par são os mesmos dois parâmetros de modelo para unordered_map.

A initializer_list para o mapa é uma matriz literal de literais. Cada literal interno consiste em dois objetos, o par chave / valor.

As funções de membro e operadores para unordered_map podem ser categorizados sob os seguintes títulos: unordered_map construction / copy build, unordered_map Capacity, unordered_map iterator, unordered_map Operations e unordered_map Modifiers.

Um mapa não ordenado é usado quando uma chave precisa ser mapeada para um valor.

Chrys