Dentre as diversas operações disponíveis para “std::map”, a função “erase” se destaca como uma ferramenta crucial para remover os elementos com base em suas chaves. Um “std::map” é um contêiner associativo organizado que compreende pares de valores-chave. A disposição dos elementos dentro de um “std::map” é consistentemente classificada de acordo com suas chaves, facilitando operações eficazes como pesquisa, inserção e exclusão com base em valores-chave.
Dentro do domínio C++, a função “std::map::erase” serve como uma função membro da classe “std::map”, permitindo a eliminação de elementos específicos do mapa. Ele vem em vários formatos, proporcionando flexibilidade na especificação de quais elementos apagar. Neste artigo, iremos nos aprofundar nos detalhes de “std::map::erase”, fornecendo vários exemplos para ilustrar sua versatilidade.
Exemplo 1: Apagar por chave
A capacidade de apagar os elementos por chave no “std::map” é um recurso fundamental fornecido pela C++ Standard Template Library. Esta operação é comumente usada quando você precisa gerenciar e manipular os pares de valores-chave em um programa e fornece uma maneira conveniente de remover elementos específicos com base em suas chaves. Criaremos um exemplo para demonstrar como usar “std::map” para criar um mapa, apagar um elemento por chave e então exibir o mapa modificado.
#include
#include
principal interno ( ) {
std::mapa < int, std::string > meuMapa;
meu mapa [ 1 ] = 'Vermelho' ;
meu mapa [ 2 ] = 'Azul' ;
meu mapa [ 3 ] = 'Verde' ;
meuMap.erase ( 2 ) ;
para ( const automático & par: meuMap ) {
std::cout << par.primeiro << ':' << par.segundo << std::endl;
}
retornar 0 ;
}
Neste exemplo, começamos incluindo as bibliotecas padrão C++ necessárias, como
Para mostrar o estado resultante do mapa, empregamos um loop “for” que itera através de cada par de valores-chave em “myMap”. Utilizamos o objeto “std::cout” dentro do loop para imprimir cada par de valores-chave no console. Finalmente, a instrução “return 0” conclui a função “main” que sinaliza a execução bem-sucedida do nosso programa.
A saída exibe os pares de valores-chave restantes no “std::map” após o elemento com chave 2 (“Azul”) ser apagado, o que resulta na saída “1: Vermelho” e “3: Verde”.
Exemplo 2: Apagando por Iterador
Em C++, iteradores são objetos que facilitam a navegação de elementos dentro de um contêiner, oferecendo um meio de acessar, modificar ou remover os elementos. A função “std::map::erase” também pode ser usada com iteradores para remover os elementos.
Aqui está um exemplo:
#include#include
principal interno ( ) {
std::mapa < int, std::string > pasta de frutas;
pasta de frutas [ 1 ] = 'Manga' ;
pasta de frutas [ 2 ] = 'Laranja' ;
pasta de frutas [ 3 ] = 'Abacaxi' ;
pasta de frutas [ 4 ] = 'Uvas' ;
auto it = frutaMap.find ( 2 ) ;
se ( isto ! = frutaMap.end ( ) ) {
frutaMap.erase ( isto ) ;
}
para ( const automático & par: frutaMap ) {
std::cout << par.primeiro << ':' << par.segundo << std::endl;
}
retornar 0 ;
}
O código C++ fornecido começa declarando um “std::map” chamado “fruitMap” para armazenar os pares chave-valor, associando os inteiros aos nomes das frutas correspondentes. Preenchemos o mapa com entradas para quatro frutas diferentes: “Manga”, “Laranja”, “Abacaxi” e “Uvas”. Depois disso, utilizamos a função “find” para obter um iterador (it) que aponta para o elemento com o valor chave 2 dentro do “fruitMap”. Em seguida, verificamos se o iterador não é igual a “end()” para garantir que o elemento com a chave especificada existe no mapa.
No bloco condicional, apagamos o elemento apontado pelo iterador “it” usando a função “erase”. Finalmente, iteramos pelos elementos restantes no “fruitMap” modificado usando um loop “for”.
A saída final exibe o conteúdo modificado do “fruitMap” após o apagamento.
Exemplo 3: Apagando um intervalo
O contêiner “std::map” em C++ fornece um método conveniente para apagar os elementos dentro de um intervalo especificado. A função “apagar” permite remover os elementos do mapa com base em iteradores que representam o início e o fim do intervalo a ser excluído.
Agora, vamos explorar o conceito de apagar um intervalo usando “std::map” com um exemplo:
#include#include
principal interno ( ) {
std::mapa < int, std::string > novoMapa;
novoMapa [ 1 ] = 'Cavalo' ;
novoMapa [ 2 ] = 'Leão' ;
novoMapa [ 3 ] = 'Tigre' ;
novoMapa [ 4 ] = 'Gato' ;
novoMap.erase ( novoMap.lower_bound ( 2 ) , newMap.upper_bound ( 3 ) ) ;
para ( const automático & par: novoMapa ) {
std::cout << par.primeiro << ':' << par.segundo << std::endl;
}
retornar 0 ;
}
O programa começa declarando um “std::map” chamado “newMap” que associa as chaves inteiras aos valores de string correspondentes. Depois disso, preenchemos o mapa com pares de valores-chave usando o operador de colchetes. Por exemplo, atribuímos os pares de valores-chave de (1, “Cavalo”), (2, “Leão”), (3, “Tigre”) e (4, “Gato”) a “novoMapa”.
A próxima operação significativa envolve o uso de iteradores para apagar os elementos do mapa. A função apagar é empregada com os argumentos “newMap.lower_bound(2)” e “newMap.upper_bound(3)”. Isso apaga os elementos com chaves que estão no intervalo (2, 3). Em outras palavras, remove as entradas “Leão” e “Tigre” do mapa. Após esta operação, o mapa contém apenas os elementos com chaves 1 e 4, correspondentes a “Cavalo” e “Gato”.
Por fim, usamos um loop “for” baseado em intervalo para iterar pelos elementos restantes no mapa e imprimir seus pares de valores-chave no console.
Como resultado, a saída exibe o seguinte:
Exemplo 4: Apagar com base em um predicado
Apagar com base em um predicado refere-se à remoção de elementos de uma estrutura de dados, como um contêiner, com base em uma condição ou critério especificado. O “std::map::erase” também pode ser usado com uma função de predicado para remover os elementos condicionalmente. Vamos considerar o seguinte exemplo:
#include#include
#incluir
principal interno ( ) {
std::mapa < int, std::string > meuMapa = {
{ 1 , 'Janeiro' } ,
{ 2 , 'Fevereiro' } ,
{ 3 , 'Marchar' } ,
{ 4 , 'Abril' } ,
{ 5 , 'Poderia' }
} ;
predicado automático = [ ] ( const std::par < int, std::string >& elemento ) {
retornar elemento.segundo.comprimento ( ) < 5 ;
} ;
meuMap.erase ( std::remove_if ( meuMap.begin ( ) , meuMap.end ( ) , predicado ) , meuMap.end ( ) ) ;
std::cout << ' \n Mapear após apagar elementos com base no predicado:' << std::endl;
para ( const automático & par: meuMap ) {
std::cout << par.primeiro << ':' << par.segundo << std::endl;
}
retornar 0 ;
}
O programa começa incluindo os arquivos de cabeçalho necessários. Um “std::map” chamado “myMap” é declarado e inicializado na função “main”. Ele contém os pares de valores-chave que representam os nomes dos meses e seus respectivos valores numéricos. Posteriormente, é definida uma função “lambda” (predicado). Esta função “lambda” serve como predicado para o algoritmo “std::remove_if”. Ele verifica se o comprimento do valor da string associado a um elemento do mapa é menor que cinco caracteres.
O algoritmo “std::remove_if’ é então usado em conjunto com a função “erase” do “std::map”. Esta combinação remove os elementos do mapa com base na validade do predicado.
Após a execução do programa, os elementos com chaves menores que cinco são removidos do mapa original, demonstrando o apagamento baseado em um predicado utilizando “std::map”.
Conclusão
Concluindo, a função “std::map::erase” é uma ferramenta versátil em C++ para remover os elementos de “std::map”. Seja apagando por chave, iterador, intervalo ou com base em um predicado, a função “std::map::erase” oferece flexibilidade e facilidade de uso. Ao dominar esta função, os desenvolvedores C++ podem gerenciar e manipular com eficiência os dados dentro dos contêineres “std::map”, tornando seu código mais forte e mais fácil de manter.