Blandt de mange operationer, der er tilgængelige for 'std::map', skiller 'slette'-funktionen sig ud som et afgørende værktøj til at fjerne elementerne baseret på deres nøgler. Et 'std::map' er en organiseret associativ beholder, der består af nøgleværdi-par. Arrangementet af elementer inden for et 'std::map' er konsekvent sorteret efter deres nøgler, hvilket letter de effektive operationer såsom søgning, indsættelse og sletning baseret på nøgleværdier.
Inden for C++-området fungerer 'std::map::erase'-funktionen som en medlemsfunktion af 'std::map'-klassen, hvilket muliggør eliminering af specifikke elementer fra kortet. Det kommer i forskellige former, hvilket giver fleksibilitet til at specificere, hvilke elementer der skal slettes. I denne artikel vil vi dykke ned i detaljerne i 'std::map::erase', der giver flere eksempler for at illustrere dets alsidighed.
Eksempel 1: Sletning med nøgle
Evnen til at slette elementerne med nøgle i 'std::map' er en grundlæggende funktion, som leveres af C++ Standard Template Library. Denne operation bruges ofte, når du skal administrere og manipulere nøgleværdi-parrene i et program, og den giver en bekvem måde at fjerne de specifikke elementer baseret på deres nøgler. Vi vil oprette et eksempel for at demonstrere, hvordan man bruger 'std::map' til at oprette et kort, slette et element med tasten og derefter vise det ændrede kort.
#include
#include
int main ( ) {
std::kort < int, std::streng > mit kort;
mit kort [ 1 ] = 'Rød' ;
mit kort [ 2 ] = 'Blå' ;
mit kort [ 3 ] = 'Grøn' ;
mit Kort.slet ( 2 ) ;
til ( const auto & par: myMap ) {
std::cout << par.først << ': ' << par.sekund << std::endl;
}
Vend tilbage 0 ;
}
I dette eksempel begynder vi med at inkludere de nødvendige C++ standardbiblioteker såsom
For at vise kortets resulterende tilstand bruger vi en 'for'-løkke, der itererer gennem hvert nøgleværdi-par i 'myMap'. Vi bruger 'std::cout'-objektet inde i løkken til at udskrive hvert nøgleværdi-par til konsollen. Til sidst afslutter 'retur 0'-sætningen 'hoved'-funktionen, som signalerer en vellykket eksekvering af vores program.
Outputtet viser de resterende nøgleværdi-par i 'std::map' efter at elementet med tast 2 ('Blå') er slettet, hvilket resulterer i '1: Rød' og '3: Grøn' output.
Eksempel 2: Sletning med Iterator
I C++ er iteratorer objekter, der letter navigationen af elementer i en container, og tilbyder et middel til at få adgang til, ændre eller fjerne elementerne. Funktionen 'std::map::slet' kan også bruges med iteratorer til at fjerne elementerne.
Her er et eksempel:
#include#inkluder
int main ( ) {
std::kort < int, std::streng > frugtmappe;
frugtmappe [ 1 ] = 'Mango' ;
frugtmappe [ 2 ] = 'Orange' ;
frugtmappe [ 3 ] = 'Ananas' ;
frugtmappe [ 4 ] = 'Druer' ;
auto it = fruitMap.find ( 2 ) ;
hvis ( det ! = fruitMap.end ( ) ) {
fruitMap.erase ( det ) ;
}
til ( const auto & par: fruitMap ) {
std::cout << par.først << ': ' << par.sekund << std::endl;
}
Vend tilbage 0 ;
}
Den medfølgende C++-kode begynder med at erklære et 'std::map' med navnet 'fruitMap' for at gemme nøgleværdi-parrene, der forbinder heltal med tilsvarende frugtnavne. Vi udfylder kortet med poster for fire forskellige frugter: 'Mango', 'Orange', 'Ananas' og 'Druer'. Derefter bruger vi 'find'-funktionen til at opnå en iterator (it), der peger på elementet med nøgleværdien 2 i 'fruitMap'. Derefter kontrollerer vi, om iteratoren ikke er lig med 'end()' for at sikre, at elementet med den angivne nøgle findes i kortet.
I den betingede blok sletter vi det element, der peges på af 'it' iteratoren ved hjælp af 'slet'-funktionen. Til sidst itererer vi gennem de resterende elementer i det modificerede 'fruitMap' ved hjælp af en 'for'-løkke.
Det endelige output viser det ændrede 'fruitMap'-indhold efter sletningen.
Eksempel 3: Sletning af et område
'std::map'-beholderen i C++ giver en praktisk metode til at slette elementerne inden for et specificeret område. 'Slet'-funktionen giver dig mulighed for at fjerne elementerne fra kortet baseret på iteratorer, der repræsenterer begyndelsen og slutningen af det område, der skal slettes.
Lad os nu udforske konceptet med at slette et område ved hjælp af 'std::map' med et eksempel:
#include#inkluder
int main ( ) {
std::kort < int, std::streng > nyt kort;
nyt kort [ 1 ] = 'Hest' ;
nyt kort [ 2 ] = 'Løve' ;
nyt kort [ 3 ] = 'Tiger' ;
nyt kort [ 4 ] = 'Kat' ;
newMap.slet ( newMap.lower_bound ( 2 ) , newMap.upper_bound ( 3 ) ) ;
til ( const auto & par: newMap ) {
std::cout << par.først << ': ' << par.sekund << std::endl;
}
Vend tilbage 0 ;
}
Programmet begynder med at erklære et 'std::map' ved navn 'newMap', som forbinder heltalsnøglerne med tilsvarende strengværdier. Derefter udfylder vi kortet med nøgle-værdi-par ved hjælp af den firkantede parentes. For eksempel tildeler vi nøgleværdi-parrene (1, 'Hest'), (2, 'Løve'), (3, 'Tiger') og (4, 'Kat') til 'newMap'.
Den næste væsentlige operation involverer at bruge iteratorerne til at slette elementerne fra kortet. Slettefunktionen bruges med argumenterne 'newMap.lower_bound(2)' og 'newMap.upper_bound(3)'. Dette sletter elementerne med taster, der falder inden for området (2, 3). Med andre ord fjerner det 'Lion' og 'Tiger' indtastningerne fra kortet. Efter denne operation indeholder kortet kun elementerne med tasterne 1 og 4, svarende til 'Hest' og 'Kat'.
Til sidst bruger vi en rækkebaseret 'for'-løkke til at iterere gennem de resterende elementer på kortet og udskrive deres nøgleværdi-par til konsollen.
Som et resultat viser outputtet følgende:
Eksempel 4: Sletning baseret på et prædikat
Sletning baseret på et prædikat refererer til at fjerne elementerne fra en datastruktur, såsom en container, baseret på en specificeret betingelse eller kriterier. 'std::map::erase' kan også bruges med en prædikatfunktion til at fjerne elementerne betinget. Lad os overveje følgende eksempel:
#include#inkluder
#include
int main ( ) {
std::kort < int, std::streng > mit kort = {
{ 1 , 'Januar' } ,
{ 2 , 'Februar' } ,
{ 3 , 'Marts' } ,
{ 4 , 'April' } ,
{ 5 , 'Kan' }
} ;
auto prædikat = [ ] ( const std::par < int, std::streng >& element ) {
Vend tilbage element.anden.længde ( ) < 5 ;
} ;
mit Kort.slet ( std::fjern_hvis ( mit Kort.begynd ( ) , myMap.end ( ) , prædikat ) , myMap.end ( ) ) ;
std::cout << ' \n Kort efter sletning af elementer baseret på prædikatet:' << std::endl;
til ( const auto & par: myMap ) {
std::cout << par.først << ': ' << par.sekund << std::endl;
}
Vend tilbage 0 ;
}
Programmet starter med at inkludere de nødvendige header-filer. Et 'std::map' kaldet 'myMap' erklæres og initialiseres i 'main'-funktionen. Den indeholder nøgle-værdi-par, der repræsenterer månedernes navne og deres respektive numeriske værdier. Efterfølgende defineres en 'lambda' funktion (prædikat). Denne 'lambda'-funktion fungerer som et prædikat for 'std::remove_if'-algoritmen. Det verificerer, om længden af strengværdien, der er knyttet til et kortelement, er mindre end fem tegn.
'std::remove_if'-algoritmen bruges derefter sammen med 'slette'-funktionen i 'std::map'. Denne kombination fjerner elementerne fra kortet baseret på prædikatets gyldighed.
Efter at have kørt programmet, fjernes elementerne med nøgler mindre end fem fra det originale kort, hvilket demonstrerer sletningen baseret på et prædikat ved hjælp af 'std::map'.
Konklusion
Afslutningsvis er 'std::map::erase'-funktionen et alsidigt værktøj i C++ til at fjerne elementerne fra 'std::map'. Uanset om du sletter med tast, iterator, rækkevidde eller baseret på et prædikat, giver funktionen 'std::map::erase' fleksibilitet og brugervenlighed. Ved at mestre denne funktion kan C++-udviklerne effektivt administrere og manipulere dataene i 'std::map'-containere, hvilket gør deres kode stærkere og nemmere at vedligeholde.