Como usar mapas em c ++

O mapa C ++ é uma estrutura de dados da lista com pares de chave/valor. Uma estrutura de dados tem funções de membro. Em C ++, há um mapa, e há um não -ordenado_map. O mapa é realmente um mapa ordenado. A ordem do mapa pode ser ascendente ou descendente por chaves. O padrão é a ordem crescente por chaves. Os recursos para mapa ordenado e mapa não ordenado são tantos na medida em que apenas aqueles para mapa (i.e., mapa ordenado) será considerado neste artigo.

Os recursos do mapa podem ser classificados em construção, acesso a elementos, capacidade, iteradores, modificadores, observadores, operações e algoritmos especializados. Acontece também que os recursos do mapa são muitos. Portanto, apenas as funções básicas nessas categorias serão explicadas.

Um exemplo de uma lista de pares de chave/valor é a seguinte lista de frutas e suas cores comuns de pele madura:

BlackBerry => Blue-preto escuro
manga => amarelo
maracujá => roxo
Plum => roxo
banana => amarelo

As cordas à esquerda da lista formam as chaves; aqueles à direita formam os valores. Os pares de chave/valor não devem necessariamente ser de string/string. Pode ser de int/string, string/float, int/float, etc. Em um mapa C ++, um par de chave/valor é um elemento e esses elementos formam a lista de estrutura de dados. Uma estrutura de dados do mapa fornece uma rápida recuperação de dados com base nas chaves. As chaves são únicas e a estrutura do mapa é muitos para um. Isso significa que os valores podem ter duplicatas, mas as chaves não podem.

Para usar a biblioteca de mapas em um programa C ++, o programa deve começar com algo como:

#incluir
#incluir
usando namespace std;

Se as strings fizerem parte do mapa, usar #include em vez de será aconselhável. Este artigo explica como usar um mapa C ++.

Conteúdo do artigo

• Construção/destruição
• Pares de construção e ajuste
• Exibindo o conteúdo do mapa (impressão)
• Acesso ao elemento
• Capacidade
• Iteradores
• Modificadores
• Ordem ascendente ou descendente
• Operações
• Algoritmos especializados
• Conclusão

Construção/destruição

Um mapa é um recipiente associativo que deve ser construído a partir de uma classe de mapa.

MAP (Initializer_list, const compare & = compare (), const alocator & = alocator ())

A declaração a seguir constrói um mapa para a lista acima por inicialização:

mapa MP "BlackBerry", "Dark Blue-Black", "manga", "amarelo", "maracujá", "roxo", "Plum", "Purple", "banana" , "amarelo";

Observe como cada par foi demarcado.

a = il

A seguinte construção de inicialização, usa o operador de atribuição:

mapa mp = "BlackBerry", "escuro-azul-preto", "manga", "amarelo", "maracujá", "roxo", "plum", "roxo", "banana ", "amarelo";

Um mapa vazio pode ser criado com a expressão à esquerda e, em seguida, os elementos adicionados posteriormente - veja abaixo.

Destruição
Para destruir um mapa, deixe -o sair do escopo.

Pares de construção e ajuste

Para o mapa acima, um par consiste em uma chave de string e um valor de string. Um elemento de par pode ser construído independentemente do mapa. O segmento de código a seguir cria um objeto de par vazio de uma classe de par e, em seguida, atribui uma chave e um valor:

par PR;
pr.primeiro = "BlackBerry";
pr.segundo = "escuro-preto azul";

O nome da propriedade principal é o primeiro e o nome da propriedade Value é o segundo. O código a seguir cria um mapa vazio e insere dois pares usando a função de membro da inserção do mapa.

mapa mp;
par PR0;
pr0.primeiro = "BlackBerry";
pr0.segundo = "escuro-preto azul";
par PR1;
PR1.primeiro = "manga";
PR1.segundo = "amarelo";
MP.inserir (pr0);
MP.inserir (pr1);

Exibindo o conteúdo do mapa (impressão)

O código a seguir usa um iterador (It), desenvolvido a partir do primeiro elemento do mapa, para exibir os pares de chave/valor, no console:

mapa mp = "Plum", "Purple", "manga", "amarelo", "BlackBerry", "Dark Blue-Black", "maracujá", "roxo", " banana "," amarelo ";
para (map :: iterator it = MP.começar(); isto!= MP.fim(); ++ it)
cout BlackBerry => Blue-preto escuro
manga => amarelo
maracujá => roxo
Plum => roxo

=> não tem significado C ++ aqui. É usado apenas para separar a chave do seu valor correspondente na tela. Para obter o valor de uma propriedade de um ponteiro (iterador), use -> entre o ponteiro (iterador) e o nome da propriedade. Então, -> tem significado em C++.

Observe que a lista foi exibida em ordem crescente de chaves, embora os elementos não tenham sido codificados.

Os pares de chave/valor ainda podem ser acessados ​​usando o esquema de elementos para elementos. O seguinte segmento de código ilustra o seguinte:

mapa mp = "Plum", "Purple", "manga", "amarelo", "BlackBerry", "Dark Blue-Black", "maracujá", "roxo", " banana "," amarelo ";
para (par elem: MP)
cout << elem.first < " << elem.second < yellow
BlackBerry => Blue-preto escuro
manga => amarelo
maracujá => roxo
Plum => roxo

Como antes. Observe que elem aqui é um nome de objeto e não um ponteiro (nem iterador). Portanto, é seguido por um ponto e não -> para acessar a propriedade.

Acesso ao elemento

T & Operator [] (key_type && x)

Um elemento que não está no mapa antes pode ser incluído usando sua chave através do operador []. O valor de um elemento, que já está no mapa, pode ser lido através do operador [] usando sua chave. O programa a seguir ilustra estos:

#incluir
#incluir
#incluir
usando namespace std;
int main ()

mapa mp;
mp ["plum"] = "roxo";
MP ["maracujá"] = "roxo";
MP ["BlackBerry"] = "Blue-preto escuro";
cout<cout<cout<retornar 0;

A saída é:

roxo
roxo
escuro azul-preto

const t & at (const key_type & x) const

Se o mapa for declarado constante, os valores das chaves não poderão ser alterados. No entanto, essa função de membro pode ser usada para ler os valores das chaves. O código a seguir ilustra o seguinte:

const map mp "plum", "roxo", "manga", "amarelo", "BlackBerry", "escuro-azul-preto";
cout<cout<cout<

A saída é:

roxo
amarelo
escuro azul-preto

Capacidade

size_type size () const Noexcept

O comprimento de um mapa pode ser determinado usando a função de membro do tamanho (), como mostra o código a seguir:

const map mp "plum", "roxo", "manga", "amarelo", "BlackBerry", "escuro-azul-preto";
cout<

A saída é 3.

[[nodiscard]] bool vazio () const Noexcept

Esta função de membro retorna true se o mapa estiver vazio e falso caso contrário. Exemplo:

const map mp;
cout<

A saída é 1 para verdadeira. Teria sido 0 para falso (caso contrário).

Iteradores

iterator Begin () NoExcept

Isso retorna um iterador bidirecional apontando para o primeiro elemento do mapa. O valor do elemento (par) para ele aponta, pode ser alterado. Exemplo Código:

mapa mp "Plum", "Purple", "manga", "amarelo", "BlackBerry", "escuro-azul-preto";
mapa :: iterator it;
para (it = MP.começar(); isto!= MP.fim(); It ++)
cout
coutpara (map :: iterator it = MP.começar(); isto!= MP.fim(); It ++)
cout manga => amarelo
Plum => roxo
BlackBerry => Blue-preto escuro
manga => branco
Plum => roxo

O valor do segundo par de chave/valor foi alterado. Observe o uso do final () iterador.

reverse_iterator rBegin () Noexcept

Isso retorna um iterador reverso bidirecional, apontando para o último elemento do mapa. O valor do elemento que aponta pode ser alterado. O código a seguir produz o mesmo resultado que o acima:

mapa mp "Plum", "Purple", "manga", "amarelo", "BlackBerry", "escuro-azul-preto";
map :: reverse_iterator it;
para (it = MP.rBegin (); isto!= MP.rend (); It ++)
cout
coutpara (map :: reverse_iterator it = MP.rBegin (); isto!= MP.rend (); It ++)
cout manga => amarelo
BlackBerry => Blue-preto escuro
Plum => roxo
manga => branco
BlackBerry => Blue-preto escuro

O mesmo valor para o segundo par de chave/valor foi alterado.

Modificadores

Com o mapa, como sempre será organizado (ordenado) por chaves, após a inserção, não importa se a inserção é direcionada pelo programador no início, dentro ou no final do mapa. Ordem ascendente por chaves é o resultado padrão.

Modificar o mapa lida com a inserção, a colocação, a extração, a apagamento e a limpeza. Inserir e empunhar são semelhantes, mas a colocação é melhor.

Emplace

par a_uniq.Emplace (args)

Esta função de membro insere os literais do par de chaves/valores, separados por vírgula, sem os colchetes encaracolados, como mostrado no código a seguir:

mapa mp = "BlackBerry", "escuro-azul-preto", "manga", "amarelo", "maracujá", "roxo";
par PR = MP.emplace ("banana", "amarelo");
para (Auto Elem: MP)
cout << elem.first < " << elem.second << endl;
cout<cout BlackBerry => Blue-preto escuro
manga => amarelo
maracujá => roxo
banana => 1

A função do membro emplace (args) retorna um par correspondente ao elemento inserido. A chave deste par de retorno é um iterador apontando para o elemento inserido. O valor desse par de retorno é verdadeiro (1) se a inserção ocorreu e falsa (0) se a inserção não ocorrer.

Observe a maneira como o tipo de retorno para Emplace (args) foi codificado. Além disso, o par de retorno não foi usado para obter a chave/valor do par de mapas inseridos na última instrução de saída. Existem dois tipos de pares aqui: o par para o mapa e o par de retorno. Eles não são compatíveis. Se a chave já existisse no mapa, o iterador retornado apontaria para a chave que existia; Então, o valor booleano seria falso.

Inserção

par insert (value_type && x)

Esta função de membro insere os literais do par de chaves/valores, separados por vírgula, com os colchetes encaracolados, conforme mostrado no código a seguir:

mapa mp = "BlackBerry", "escuro-azul-preto", "manga", "amarelo", "maracujá", "roxo";
par PR = MP.inserir ("banana", "amarelo");
para (Auto Elem: MP)
cout << elem.first < " << elem.second << endl;
cout<cout BlackBerry => Blue-preto escuro
manga => amarelo
maracujá => roxo
banana => 1

A explicação é semelhante ao caso acima para Emplace (args).

par inserir (const value_type & x)

O identificador de um par pode ser usado como argumento para a função insert (). Ilustração:

mapa mp = "BlackBerry", "escuro-azul-preto", "manga", "amarelo", "maracujá", "roxo";
par PR;
pr.primeiro = "banana";
pr.segundo = "amarelo";
par ib = MP.inserir (pr);
para (Auto Elem: MP)
cout << elem.first < " << elem.second << endl;
cout<cout BlackBerry => Blue-preto escuro
manga => amarelo
maracujá => roxo
banana => 1

A explicação é semelhante ao caso acima.

Void Insert (Initializer_list)

Uma lista inteira pode ser inserida. Imediatamente após a inserção, há rearranjo (em ordem ascendente). Ilustração:

mapa mp = "BlackBerry", "escuro-azul-preto", "manga", "amarelo", "maracujá", "roxo";
MP.inserir ("melancia", "verde", "uva", "rosa", "damasco", "laranja");
para (Auto Elem: MP)
cout << elem.first < " << elem.second < orange
BlackBerry => Blue-preto escuro
uva => rosa
manga => amarelo
maracujá => roxo
melancia => verde

Nota: nenhuma chave da lista já deve existir no mapa.

INSERT VOID (InputIterator Primeiro, InputIterator Último)

Um intervalo, [i, j) de outro mapa pode ser inserido. Aqui, eu e j somos iteradores. Ilustração:

mapa mp1 = "uva", "rosa", "damasco", "laranja", "strawberry", "vermelho", "pêssego", "amarelo escuro", "mamão", "laranja";
mapa :: iterator itb = mp1.começar();
ITB ++;
mapa :: iterator ite = mp1.fim();
eu te--; eu te--;
mapa mp2 = "BlackBerry", "escuro-azul-preto", "manga", "amarelo", "maracujá", "roxo";
MP2.inserir (itb, ITE);
para (Auto Elem: MP2)
cout << elem.first < " << elem.second < dark blue-black
uva => rosa
manga => amarelo
Papaya => laranja
maracujá => roxo

Observe que o elemento correspondente a J do primeiro mapa não foi inserido. Isso está de acordo com a notação, [i, j).

Apagar

size_type apagar (const key_type & x)

Apagam o elemento identificado pela chave e retorna o número de elementos apagados (deve ser 1 no caso de não multimap). Ilustração:

mapa mp = "BlackBerry", "escuro-azul-preto", "manga", "amarelo", "maracujá", "roxo";
int n = MP.apagar ("manga");
cout<para (Auto Elem: MP)
cout << elem.first < " << elem.second << endl;
cout <cout<maracujá => roxo
2

O elemento apagado é removido, no que diz respeito ao usuário. Portanto, o número de elementos é reduzido.

Erase do iterador (posição const_iterator)

Apagamento pode ser feito usando um iterador. Retorna um iterador apontando para o elemento após o que é apagado. Ilustração:

mapa mp = "BlackBerry", "escuro-azul-preto", "manga", "amarelo", "maracujá", "roxo";
mapa :: iterator it = MP.começar();
It ++;
mapa :: iterator iter = MP.apague isso);
cout para (Auto Elem: MP)
cout << elem.first < " << elem.second << endl;
cout <cout<BlackBerry => Blue-preto escuro
maracujá => roxo
2

Erase do iterador (const_iterator primeiro, const_iterator Último)

Isso usa iteradores para apagar um intervalo do mapa ordenado. Ele retorna um iterador apontando para o elemento após o intervalo apagado. Ilustração:

mapa mp = "uva", "rosa", "damasco", "laranja", "strawberry", "vermelho", "pêssego", "amarelo escuro", "mamão", "laranja";
para (Auto Elem: MP)
cout << elem.first < " << elem.second << endl;
cout <mapa :: iterator itb = MP.começar();
ITB ++;
mapa :: iterator ite = MP.fim();
eu te--; eu te--;
mapa :: iterator iter = MP.apagar (ITB, ITE);
cout para (Auto Elem: MP)
cout << elem.first < " << elem.second << endl;
cout <cout<uva => rosa
Papaya => laranja
pêssego => amarelo escuro
morango => vermelho
pêssego => amarelo escuro
damasco => laranja
pêssego => amarelo escuro
morango => vermelho
3

A ordem do conteúdo original do mapa é exibida pela primeira vez na saída para que o intervalo apagado possa ser apreciado. Observe que o elemento apontado pelo segundo argumento iterador não é apagado.

Claro

void clear () noexcept

Apaga todos os elementos do mapa, fazendo o tamanho do mapa, zero. Exemplo:

mapa mp = "uva", "rosa", "damasco", "laranja", "strawberry", "vermelho";
MP.claro();
cout<

A saída é 0.

Extração
Isso lida com node_type - veja mais tarde.

Fusão
Quando dois mapas são mesclados, os elementos se misturam em ordem (ascendente); Nenhum par de chave/valor é separado.

vazio a.mesclar (A2)

Um elemento em A2 com a mesma chave em A não é extraído. Isso lida com node_type - veja mais tarde.

Ordem ascendente ou descendente

Por padrão, um mapa aumenta pelas chaves logo após a criação. Pode ser feito descendente. Nos suportes de ângulo de modelo, o terceiro parâmetro tem o tipo padrão, menos. E assim, não precisa ser digitado. Para fazer com que o mapa descesse por Key, Greater deve ser usado, como no código a seguir:

mapa mp = "uva", "rosa", "dram", "laranja", "strawberry", "Red";
para (Auto Elem: MP)
cout << elem.first < " << elem.second < red
uva => rosa
damasco => laranja

Assim que um mapa é criado, ele é ordenado ascendente ou descendente (ascendente por padrão). menos ou maior é conhecido como um objeto de comparação.

Operações

ITERATOR ENCONTRO (const key_type & x)

Retorna o iterador do elemento cuja chave é o argumento para encontrar (). Ilustração:

mapa mp = "uva", "rosa", "dram", "laranja", "strawberry", "Red";
mapa :: iterator it = MP.encontre ("uva");
cout

iterator inferior_bound (const key_type & x)

Em um mapa, os elementos são organizados por chave, em ordem ascendente, por padrão. Se o programador quiser conhecer o iterador que aponta para o elemento que não é inferior ao de uma chave específica, ele deve usar essa função de membro. Ilustração:

mapa mp = "uva", "rosa", "damasco", "laranja", "strawberry", "vermelho", "pêssego", "amarelo escuro", "mamão", "laranja";
para (Auto Elem: MP)
cout << elem.first < " << elem.second << endl;
cout <mapa :: iterator it = MP.inferior_bound ("mamão");
cout uva => rosa
Papaya => laranja
pêssego => amarelo escuro
morango => vermelho
Papaya => laranja

Nesta situação, o iterador aponta para o elemento com chave. Se a chave não for encontrada, a função retornará um iterador que aponta logo após o final do mapa. Nesta situação, é cíclico e seria o primeiro elemento do mapa.

iterator Upper_bound (const key_type & x)

Se o programador quiser conhecer o iterador que aponta para o elemento com chave maior que k, ele deve usar essa função de membro. Ilustração:

mapa mp = "uva", "rosa", "damasco", "laranja", "strawberry", "vermelho", "pêssego", "amarelo escuro", "mamão", "laranja";
para (Auto Elem: MP)
cout << elem.first < " << elem.second << endl;
cout <mapa :: iterator it = MP.Upper_bound ("Papaya");
cout uva => rosa
Papaya => laranja
pêssego => amarelo escuro
morango => vermelho
pêssego => amarelo escuro

Um iterador apontando para o elemento logo após o elemento com chave foi devolvido. Se a chave for para o último elemento, uma exceção deve ser lançada. Se a chave não existir, o resultado não é confiável.

Algoritmos especializados

A seguir, é apresentada a sintaxe de uma função de algoritmo especializada:

modelo
Void Swap (mapa & x, map & y) Noexcept (NoExcept (x.troca (y)));

A sintaxe a seguir pode ser usada:

Void Swap (mapa &)

Isso troca os pares dos dois mapas, que não precisam ser do mesmo tamanho. Exemplo:

mapa mp1 = "plum", "roxo", "manga", "amarelo", "blackberry", "escuro-preto", "maracujá", "roxo", " banana "," amarelo ";
mapa mp2 = "melancia", "verde", "uva", "rosa", "damasco", "laranja", "strawberry", "vermelho", "pêssego", " amarelo escuro ", " mamão "," laranja ";
MP1.troca (MP2);
cout << "New mp1:" << endl;
para (Auto Elem: MP1)
cout << elem.first < " << elem.second << endl;
cout<cout << "New mp2:" << endl;
para (Auto Elem: MP2)
cout << elem.first < " << elem.second << endl;

Conclusão

Um mapa consiste em pares de chave/valor. É ordenado por chaves, ascendentes ou descendentes. A ordem padrão está ascendendo. Funções básicas de membro para o mapa: map (), operador [], em (), size (), vazio (), begin (), end (), rbegin (), rend (), emplace (), insert () .