Entre las muchas operaciones disponibles para 'std::map', la función 'borrar' se destaca como una herramienta crucial para eliminar elementos según sus claves. Un 'std::map' es un contenedor asociativo organizado que se compone de pares clave-valor. La disposición de los elementos dentro de un “std::map” se ordena consistentemente según sus claves, lo que facilita operaciones efectivas como búsqueda, inserción y eliminación basadas en valores clave.
Dentro del ámbito de C++, la función “std::map::erase” sirve como función miembro de la clase “std::map”, permitiendo la eliminación de elementos específicos del mapa. Viene en varias formas, lo que brinda flexibilidad para especificar qué elementos borrar. En este artículo, profundizaremos en los detalles de “std::map::erase”, proporcionando múltiples ejemplos para ilustrar su versatilidad.
Ejemplo 1: Borrar por clave
La capacidad de borrar los elementos por clave en “std::map” es una característica fundamental proporcionada por la biblioteca de plantillas estándar de C++. Esta operación se usa comúnmente cuando necesita administrar y manipular los pares clave-valor en un programa y proporciona una manera conveniente de eliminar elementos específicos según sus claves. Crearemos un ejemplo para demostrar cómo usar “std::map” para crear un mapa, borrar un elemento por clave y luego mostrar el mapa modificado.
#incluir
#incluir
ent principal ( ) {
std::mapa < int, std::cadena > mi mapa;
mi mapa [ 1 ] = 'Rojo' ;
mi mapa [ 2 ] = 'Azul' ;
mi mapa [ 3 ] = 'Verde' ;
myMap.erase ( 2 ) ;
para ( constante automática & par: miMapa ) {
std::cout << par.primero << ': ' << par.segundo << std::endl;
}
devolver 0 ;
}
En este ejemplo, comenzamos incluyendo las bibliotecas estándar de C++ necesarias, como
Para mostrar el estado resultante del mapa, empleamos un bucle 'for' que recorre cada par clave-valor dentro de 'myMap'. Utilizamos el objeto 'std::cout' dentro del bucle para imprimir cada par clave-valor en la consola. Finalmente, la declaración 'return 0' concluye la función 'principal' que señala la ejecución exitosa de nuestro programa.
La salida muestra los pares clave-valor restantes en el 'std::map' después de borrar el elemento con la clave 2 ('Azul'), lo que da como resultado la salida '1: Rojo' y '3: Verde'.
Ejemplo 2: borrado por iterador
En C++, los iteradores son objetos que facilitan la navegación de elementos dentro de un contenedor, ofreciendo un medio para acceder, modificar o eliminar los elementos. La función “std::map::erase” también se puede utilizar con iteradores para eliminar los elementos.
He aquí un ejemplo:
#incluir#incluir
ent principal ( ) {
std::mapa < int, std::cadena > Carpeta de frutas;
carpeta de frutas [ 1 ] = 'Mango' ;
carpeta de frutas [ 2 ] = 'Naranja' ;
carpeta de frutas [ 3 ] = 'Piña' ;
carpeta de frutas [ 4 ] = 'Uvas' ;
auto it = mapa de frutas.find ( 2 ) ;
si ( él ! = mapa de frutas.end ( ) ) {
fruitMap.erase ( él ) ;
}
para ( constante automática & par : frutaMapa ) {
std::cout << par.primero << ': ' << par.segundo << std::endl;
}
devolver 0 ;
}
El código C++ proporcionado comienza declarando un 'std::map' llamado 'fruitMap' para almacenar los pares clave-valor, asociando los números enteros con los nombres de frutas correspondientes. Completamos el mapa con entradas para cuatro frutas diferentes: “Mango”, “Naranja”, “Piña” y “Uvas”. Después de eso, utilizamos la función 'buscar' para obtener un iterador (it) que apunta al elemento con el valor clave de 2 dentro del 'fruitMap'. Luego, verificamos si el iterador no es igual a 'end ()' para asegurarnos de que el elemento con la clave especificada exista en el mapa.
En el bloque condicional, borramos el elemento al que apunta el iterador 'it' usando la función 'borrar'. Finalmente, iteramos a través de los elementos restantes en el “fruitMap” modificado usando un bucle “for”.
El resultado final muestra el contenido modificado del “fruitMap” después del borrado.
Ejemplo 3: borrar un rango
El contenedor 'std::map' en C++ proporciona un método conveniente para borrar los elementos dentro de un rango específico. La función “borrar” le permite eliminar los elementos del mapa en función de iteradores que representan el inicio y el final del rango a eliminar.
Ahora, exploremos el concepto de borrar un rango usando 'std::map' con un ejemplo:
#incluir#incluir
ent principal ( ) {
std::mapa < int, std::cadena > nuevoMapa;
nuevoMapa [ 1 ] = 'Caballo' ;
nuevoMapa [ 2 ] = 'León' ;
nuevoMapa [ 3 ] = 'Tigre' ;
nuevoMapa [ 4 ] = 'Gato' ;
nuevoMap.erase ( nuevoMapa.lower_bound ( 2 ) , nuevoMapa.upper_bound ( 3 ) ) ;
para ( constante automática & par: nuevoMapa ) {
std::cout << par.primero << ': ' << par.segundo << std::endl;
}
devolver 0 ;
}
El programa comienza declarando un 'std::map' llamado 'newMap' que asocia las claves enteras con los valores de cadena correspondientes. Después de eso, completamos el mapa con pares clave-valor usando el operador de corchetes. Por ejemplo, asignamos los pares clave-valor de (1, 'Caballo'), (2, 'León'), (3, 'Tigre') y (4, 'Gato') a 'nuevoMapa'.
La siguiente operación importante implica el uso de iteradores para borrar los elementos del mapa. La función de borrado se emplea con los argumentos “newMap.lower_bound(2)” y “newMap.upper_bound(3)”. Esto borra los elementos con claves que se encuentran en el rango (2, 3). En otras palabras, elimina las entradas 'León' y 'Tigre' del mapa. Luego de esta operación, el mapa contiene solo los elementos con las claves 1 y 4, correspondientes a “Caballo” y “Gato”.
Finalmente, utilizamos un bucle 'for' basado en rango para recorrer los elementos restantes en el mapa e imprimir sus pares clave-valor en la consola.
Como resultado, el resultado muestra lo siguiente:
Ejemplo 4: borrado basado en un predicado
El borrado basado en un predicado se refiere a eliminar los elementos de una estructura de datos, como un contenedor, según una condición o criterio específicos. El “std::map::erase” también se puede usar con una función de predicado para eliminar los elementos condicionalmente. Consideremos el siguiente ejemplo:
#incluir#incluir
#incluir
ent principal ( ) {
std::mapa < int, std::cadena > miMapa = {
{ 1 , 'Enero' } ,
{ 2 , 'Febrero' } ,
{ 3 , 'Marzo' } ,
{ 4 , 'Abril' } ,
{ 5 , 'Puede' }
} ;
predicado automático = [ ] ( constante estándar::par < int, std::cadena >& elemento ) {
devolver elemento.segundo.longitud ( ) < 5 ;
} ;
myMap.erase ( std::remove_if ( miMapa.comenzar ( ) , miMapa.end ( ) , predicado ) , miMapa.end ( ) ) ;
std::cout << ' \norte Mapa después de borrar elementos según el predicado:' << std::endl;
para ( constante automática & par: miMapa ) {
std::cout << par.primero << ': ' << par.segundo << std::endl;
}
devolver 0 ;
}
El programa comienza incluyendo los archivos de encabezado necesarios. Un 'std::map' llamado 'myMap' se declara e inicializa en la función 'principal'. Contiene los pares clave-valor que representan los nombres de los meses y sus respectivos valores numéricos. Posteriormente se define una función “lambda” (predicado). Esta función 'lambda' sirve como predicado para el algoritmo 'std::remove_if'. Verifica si la longitud del valor de cadena asociado con un elemento de mapa es inferior a cinco caracteres.
El algoritmo 'std::remove_if' se utiliza junto con la función 'borrar' del 'std::map'. Esta combinación elimina los elementos del mapa según la validez del predicado.
Después de ejecutar el programa, los elementos con claves menores de cinco se eliminan del mapa original, lo que demuestra el borrado basado en un predicado usando “std::map”.
Conclusión
En conclusión, la función “std::map::erase” es una herramienta versátil en C++ para eliminar los elementos de “std::map”. Ya sea que se borre por clave, iterador, rango o en función de un predicado, la función “std::map::erase” proporciona flexibilidad y facilidad de uso. Al dominar esta función, los desarrolladores de C++ pueden administrar y manipular eficientemente los datos dentro de los contenedores 'std::map', haciendo que su código sea más sólido y más fácil de mantener.