Tra le tante operazioni disponibili per “std::map”, spicca la funzione “erase” che risulta essere uno strumento fondamentale per rimuovere gli elementi in base alla loro chiave. Una 'std::map' è un contenitore associativo organizzato che comprende coppie chiave-valore. La disposizione degli elementi all'interno di una 'std::map' è ordinata in modo coerente in base alle rispettive chiavi, facilitando operazioni efficaci come la ricerca, l'inserimento e l'eliminazione in base ai valori chiave.
Nell'ambito del C++, la funzione “std::map::erase” funge da funzione membro della classe “std::map”, consentendo l'eliminazione di elementi specifici dalla mappa. È disponibile in varie forme, offrendo flessibilità nello specificare quali elementi cancellare. In questo articolo approfondiremo i dettagli di “std::map::erase”, fornendo numerosi esempi per illustrarne la versatilità.
Esempio 1: cancellazione tramite tasto
La possibilità di cancellare gli elementi per chiave nella “std::map” è una funzionalità fondamentale fornita dalla C++ Standard Template Library. Questa operazione viene comunemente utilizzata quando è necessario gestire e manipolare le coppie chiave-valore in un programma e fornisce un modo conveniente per rimuovere elementi specifici in base alle relative chiavi. Creeremo un esempio per dimostrare come utilizzare 'std::map' per creare una mappa, cancellare un elemento per chiave e quindi visualizzare la mappa modificata.
#include
#include
int principale ( ) {
std::mappa < int, std::string > miaMappa;
miaMappa [ 1 ] = 'Rosso' ;
miaMappa [ 2 ] = 'Blu' ;
miaMappa [ 3 ] = 'Verde' ;
myMap.erase ( 2 ) ;
per ( const automatico & coppia: miaMappa ) {
std::cout << accoppiare.prima << ': ' << coppia.secondo << std::endl;
}
ritorno 0 ;
}
In questo esempio, iniziamo includendo le librerie standard C++ necessarie come
Per mostrare lo stato risultante della mappa, utilizziamo un ciclo 'for' che scorre ciascuna coppia chiave-valore all'interno di 'myMap'. Utilizziamo l'oggetto 'std::cout' all'interno del ciclo per stampare ciascuna coppia chiave-valore sulla console. Infine, l'istruzione “return 0” conclude la funzione “main” che segnala l'avvenuta esecuzione del nostro programma.
L'output visualizza le rimanenti coppie chiave-valore in 'std::map' dopo che l'elemento con chiave 2 ('Blu') viene cancellato, il che risulta nell'output '1: Rosso' e '3: Verde'.
Esempio 2: cancellazione tramite iteratore
In C++, gli iteratori sono oggetti che facilitano la navigazione degli elementi all'interno di un contenitore, offrendo un mezzo per accedere, modificare o rimuovere gli elementi. La funzione “std::map::erase” può essere utilizzata anche con gli iteratori per rimuovere gli elementi.
Ecco un esempio:
#include#include
int principale ( ) {
std::mappa < int, std::string > fruttaCartella;
fruttaCartella [ 1 ] = 'Mango' ;
fruttaCartella [ 2 ] = 'Arancia' ;
fruttaCartella [ 3 ] = 'Ananas' ;
fruttaCartella [ 4 ] = 'Uva' ;
auto it = fruitMap.find ( 2 ) ;
Se ( Esso ! = fruitMap.end ( ) ) {
fruitMap.erase ( Esso ) ;
}
per ( const automatico & coppia: fruitMap ) {
std::cout << accoppiare.prima << ': ' << coppia.secondo << std::endl;
}
ritorno 0 ;
}
Il codice C++ fornito inizia dichiarando un 'std::map' denominato 'fruitMap' per memorizzare le coppie chiave-valore, associando gli interi ai nomi dei frutti corrispondenti. Popoliamo la mappa con voci per quattro diversi frutti: 'Mango', 'Arancia', 'Ananas' e 'Uva'. Successivamente, utilizziamo la funzione “find” per ottenere un iteratore (it) che punta all'elemento con il valore chiave 2 all'interno di “fruitMap”. Quindi, controlliamo se l'iteratore non è uguale a “end()” per garantire che l'elemento con la chiave specificata esista nella mappa.
Nel blocco condizionale, cancelliamo l'elemento a cui punta l'iteratore 'it' utilizzando la funzione 'cancella'. Infine, iteriamo attraverso gli elementi rimanenti nella 'fruitMap' modificata utilizzando un ciclo 'for'.
L'output finale mostra il contenuto modificato di 'fruitMap' dopo la cancellazione.
Esempio 3: cancellazione di un intervallo
Il contenitore 'std::map' in C++ fornisce un metodo conveniente per cancellare gli elementi all'interno di un intervallo specificato. La funzione “cancella” permette di rimuovere gli elementi dalla mappa in base ad iteratori che rappresentano l'inizio e la fine dell'intervallo da eliminare.
Ora esploriamo il concetto di cancellazione di un intervallo utilizzando 'std::map' con un esempio:
#include#include
int principale ( ) {
std::mappa < int, std::string > nuovaMappa;
nuovaMappa [ 1 ] = 'Cavallo' ;
nuovaMappa [ 2 ] = 'Leone' ;
nuovaMappa [ 3 ] = 'Tigre' ;
nuovaMappa [ 4 ] = 'Gatto' ;
newMap.erase ( newMap.lower_bound ( 2 ) , newMap.upper_bound ( 3 ) ) ;
per ( const automatico & coppia: nuova mappa ) {
std::cout << accoppiare.prima << ': ' << coppia.secondo << std::endl;
}
ritorno 0 ;
}
Il programma inizia dichiarando una 'std::map' denominata 'newMap' che associa le chiavi intere ai corrispondenti valori stringa. Successivamente, popoliamo la mappa con coppie chiave-valore utilizzando l'operatore parentesi quadra. Ad esempio, assegniamo le coppie chiave-valore di (1, 'Cavallo'), (2, 'Leone'), (3, 'Tigre') e (4, 'Gatto') a 'nuovaMappa'.
La prossima operazione significativa prevede l'utilizzo degli iteratori per cancellare gli elementi dalla mappa. La funzione di cancellazione viene utilizzata con gli argomenti “newMap.lower_bound(2)” e “newMap.upper_bound(3)”. Questo cancella gli elementi con chiavi che rientrano nell'intervallo (2, 3). In altre parole, rimuove le voci “Leone” e “Tigre” dalla mappa. Dopo questa operazione la mappa conterrà solo gli elementi con i tasti 1 e 4, corrispondenti a “Cavallo” e “Gatto”.
Infine, utilizziamo un ciclo 'for' basato su intervallo per scorrere gli elementi rimanenti nella mappa e stampare le relative coppie chiave-valore sulla console.
Di conseguenza, l'output visualizza quanto segue:
Esempio 4: cancellazione in base a un predicato
La cancellazione in base a un predicato si riferisce alla rimozione degli elementi da una struttura dati, come un contenitore, in base a una condizione o criteri specificati. 'std::map::erase' può essere utilizzato anche con una funzione di predicato per rimuovere gli elementi in modo condizionale. Consideriamo il seguente esempio:
#include#include
#include
int principale ( ) {
std::mappa < int, std::string > miaMappa = {
{ 1 , 'Gennaio' } ,
{ 2 , 'Febbraio' } ,
{ 3 , 'Marzo' } ,
{ 4 , 'Aprile' } ,
{ 5 , 'Maggio' }
} ;
predicato automatico = [ ] ( const std::coppia < int, std::string >& elemento ) {
ritorno elemento.seconda.lunghezza ( ) < 5 ;
} ;
myMap.erase ( std::rimuovi_if ( miaMappa.begin ( ) , miaMappa.end ( ) , predicato ) , miaMappa.end ( ) ) ;
std::cout << ' \N Mappa dopo aver cancellato gli elementi in base al predicato:' << std::endl;
per ( const automatico & coppia: miaMappa ) {
std::cout << accoppiare.prima << ': ' << coppia.secondo << std::endl;
}
ritorno 0 ;
}
Il programma inizia includendo i file di intestazione necessari. Una 'std::map' chiamata 'myMap' viene dichiarata e inizializzata nella funzione 'main'. Contiene le coppie chiave-valore che rappresentano i nomi dei mesi e i rispettivi valori numerici. Successivamente viene definita una funzione “lambda” (predicato). Questa funzione 'lambda' funge da predicato per l'algoritmo 'std::remove_if'. Verifica se la lunghezza del valore stringa associato a un elemento della mappa è inferiore a cinque caratteri.
L'algoritmo 'std::remove_if' viene quindi utilizzato insieme alla funzione 'cancella' di 'std::map'. Questa combinazione rimuove gli elementi dalla mappa in base alla validità del predicato.
Dopo aver eseguito il programma, gli elementi con chiavi inferiori a cinque vengono rimossi dalla mappa originale, dimostrando la cancellazione basata su un predicato utilizzando “std::map”.
Conclusione
In conclusione, la funzione “std::map::erase” è uno strumento versatile in C++ per rimuovere gli elementi da “std::map”. Sia che si cancelli per chiave, iteratore, intervallo o in base a un predicato, la funzione 'std::map::erase' offre flessibilità e facilità d'uso. Padroneggiando questa funzione, gli sviluppatori C++ possono gestire e manipolare in modo efficiente i dati all'interno dei contenitori 'std::map', rendendo il loro codice più forte e più facile da mantenere.