Bland de många operationerna som är tillgängliga för 'std::map' framstår 'radera'-funktionen som ett avgörande verktyg för att ta bort elementen baserat på deras nycklar. En 'std::map' är en organiserad associativ behållare som består av nyckel-värdepar. Arrangemanget av element inom en 'std::map' sorteras konsekvent efter deras nycklar, vilket underlättar effektiva operationer som sökning, infogning och radering baserat på nyckelvärden.
Inom området för C++ fungerar 'std::map::erase'-funktionen som en medlemsfunktion i klassen 'std::map', vilket möjliggör eliminering av specifika element från kartan. Det finns i olika former, vilket ger flexibilitet när det gäller att specificera vilka element som ska raderas. I den här artikeln kommer vi att fördjupa oss i detaljerna om 'std::map::erase', som ger flera exempel för att illustrera dess mångsidighet.
Exempel 1: Radering med nyckel
Möjligheten att radera elementen med nyckel i 'std::map' är en grundläggande funktion som tillhandahålls av C++ Standard Template Library. Den här operationen används ofta när du behöver hantera och manipulera nyckel-värdeparen i ett program, och det ger ett bekvämt sätt att ta bort de specifika elementen baserat på deras nycklar. Vi kommer att skapa ett exempel för att visa hur man använder 'std::map' för att skapa en karta, radera ett element med nyckel och sedan visa den modifierade kartan.
#include
#inkludera
int main ( ) {
std::karta < int, std::string > min karta;
min karta [ 1 ] = 'Röd' ;
min karta [ 2 ] = 'Blå' ;
min karta [ 3 ] = 'Grön' ;
myMap.erase ( 2 ) ;
för ( const auto & par: myMap ) {
std::cout << par.först << ': ' << par.sekund << std::endl;
}
lämna tillbaka 0 ;
}
I det här exemplet börjar vi med att inkludera de nödvändiga C++-standardbiblioteken som
För att visa upp det resulterande tillståndet på kartan använder vi en 'för'-loop som itererar genom varje nyckel-värdepar inom 'myMap'. Vi använder 'std::cout'-objektet inuti slingan för att skriva ut varje nyckel-värdepar till konsolen. Slutligen avslutar 'retur 0'-satsen 'huvud'-funktionen som signalerar framgångsrikt genomförande av vårt program.
Utdata visar de återstående nyckel-värdeparen i 'std::map' efter att elementet med nyckel 2 ('Blå') har raderats, vilket resulterar i '1: Röd' och '3: Grön' utdata.
Exempel 2: Radering med Iterator
I C++ är iteratorer objekt som underlättar navigeringen av element i en behållare, och erbjuder ett sätt att komma åt, ändra eller ta bort elementen. Funktionen 'std::map::erase' kan också användas med iteratorer för att ta bort elementen.
Här är ett exempel:
#include#inkludera
int main ( ) {
std::karta < int, std::string > fruktmapp;
fruktmapp [ 1 ] = 'Mango' ;
fruktmapp [ 2 ] = 'Orange' ;
fruktmapp [ 3 ] = 'Ananas' ;
fruktmapp [ 4 ] = 'Druvor' ;
auto it = fruitMap.find ( 2 ) ;
om ( Det ! = fruitMap.end ( ) ) {
fruitMap.erase ( Det ) ;
}
för ( const auto & par: fruitMap ) {
std::cout << par.först << ': ' << par.sekund << std::endl;
}
lämna tillbaka 0 ;
}
Den tillhandahållna C++-koden börjar med att deklarera en 'std::map' med namnet 'fruitMap' för att lagra nyckel-värdeparen, associera heltalen med motsvarande fruktnamn. Vi fyller kartan med poster för fyra olika frukter: 'Mango', 'Apelsin', 'Ananas' och 'Druvor'. Efter det använder vi 'hitta'-funktionen för att få en iterator (it) som pekar på elementet med nyckelvärdet 2 i 'fruitMap'. Sedan kontrollerar vi om iteratorn inte är lika med 'end()' för att säkerställa att elementet med den angivna nyckeln finns i kartan.
I det villkorliga blocket raderar vi elementet som pekas på av 'it'-iteratorn med hjälp av 'radera'-funktionen. Slutligen itererar vi genom de återstående elementen i den modifierade 'fruitMap' med hjälp av en 'för'-loop.
Den slutliga utgången visar det modifierade 'fruitMap'-innehållet efter raderingen.
Exempel 3: Radera ett område
Behållaren 'std::map' i C++ tillhandahåller en bekväm metod för att radera elementen inom ett specificerat intervall. 'Radera'-funktionen låter dig ta bort elementen från kartan baserat på iteratorer som representerar början och slutet av intervallet som ska raderas.
Låt oss nu utforska konceptet med att radera ett intervall med hjälp av 'std::map' med ett exempel:
#include#inkludera
int main ( ) {
std::karta < int, std::string > newMap;
ny Karta [ 1 ] = 'Häst' ;
ny Karta [ 2 ] = 'Lejon' ;
ny Karta [ 3 ] = 'Tiger' ;
ny Karta [ 4 ] = 'Katt' ;
nyMap.radera ( newMap.lower_bound ( 2 ) , newMap.upper_bound ( 3 ) ) ;
för ( const auto & par: newMap ) {
std::cout << par.först << ': ' << par.sekund << std::endl;
}
lämna tillbaka 0 ;
}
Programmet börjar med att deklarera en 'std::map' med namnet 'newMap' som associerar heltalsnycklarna med motsvarande strängvärden. Efter det fyller vi kartan med nyckel-värdepar med hakparentesoperatorn. Till exempel tilldelar vi nyckel-värdeparen (1, 'Häst'), (2, 'Lion'), (3, 'Tiger') och (4, 'Katt') till 'newMap'.
Nästa betydande operation involverar att använda iteratorerna för att radera elementen från kartan. Raderingsfunktionen används med argumenten 'newMap.lower_bound(2)' och 'newMap.upper_bound(3)'. Detta raderar elementen med nycklar som faller inom området (2, 3). Med andra ord tar det bort posterna 'Lion' och 'Tiger' från kartan. Efter denna operation innehåller kartan endast elementen med knapparna 1 och 4, motsvarande 'Häst' och 'Katt'.
Slutligen använder vi en intervallbaserad 'för'-loop för att iterera genom de återstående elementen i kartan och skriva ut deras nyckel-värdepar till konsolen.
Som ett resultat visar utgången följande:
Exempel 4: Radering baserat på ett predikat
Radering baserat på ett predikat avser att ta bort elementen från en datastruktur, till exempel en behållare, baserat på ett specificerat villkor eller kriterier. 'std::map::erase' kan också användas med en predikatfunktion för att ta bort elementen villkorligt. Låt oss överväga följande exempel:
#include#inkludera
#inkludera
int main ( ) {
std::karta < int, std::string > min karta = {
{ 1 , 'Januari' } ,
{ 2 , 'Februari' } ,
{ 3 , 'Mars' } ,
{ 4 , 'april' } ,
{ 5 , 'Maj' }
} ;
autopredikat = [ ] ( const std::pair < int, std::string >& element ) {
lämna tillbaka element.andra.längd ( ) < 5 ;
} ;
myMap.erase ( std::remove_if ( myMap.begin ( ) , myMap.end ( ) , predikat ) , myMap.end ( ) ) ;
std::cout << ' \n Karta efter att ha raderat element baserat på predikatet:' << std::endl;
för ( const auto & par: myMap ) {
std::cout << par.först << ': ' << par.sekund << std::endl;
}
lämna tillbaka 0 ;
}
Programmet börjar med att inkludera nödvändiga rubrikfiler. En 'std::map' kallad 'myMap' deklareras och initieras i 'huvud'-funktionen. Den innehåller nyckel-värdeparen som representerar månadernas namn och deras respektive numeriska värden. Därefter definieras en 'lambda'-funktion (predikat). Denna 'lambda'-funktion fungerar som ett predikat för 'std::remove_if'-algoritmen. Den verifierar om längden på strängvärdet som är associerat med ett kartelement är mindre än fem tecken.
Algoritmen 'std::remove_if' används sedan tillsammans med 'radera'-funktionen för 'std::map'. Denna kombination tar bort elementen från kartan baserat på predikatets giltighet.
Efter att ha kört programmet tas elementen med knappar mindre än fem bort från den ursprungliga kartan, vilket demonstrerar raderingen baserat på ett predikat med 'std::map'.
Slutsats
Sammanfattningsvis är funktionen 'std::map::erase' ett mångsidigt verktyg i C++ för att ta bort elementen från 'std::map'. Oavsett om du raderar med tangent, iterator, intervall eller baserat på ett predikat, ger funktionen 'std::map::erase' flexibilitet och användarvänlighet. Genom att behärska den här funktionen kan C++-utvecklarna effektivt hantera och manipulera data i 'std::map'-behållare, vilket gör deras kod starkare och lättare att underhålla.