Onder de vele bewerkingen die beschikbaar zijn voor “std::map”, valt de functie “erase” op als een cruciaal hulpmiddel voor het verwijderen van de elementen op basis van hun sleutels. Een “std::map” is een georganiseerde associatieve container die bestaat uit sleutel-waardeparen. De rangschikking van elementen binnen een “std::map” wordt consistent gesorteerd op basis van hun sleutels, waardoor effectieve bewerkingen zoals zoeken, invoegen en verwijderen op basis van sleutelwaarden worden vergemakkelijkt.
Binnen het domein van C++ fungeert de functie “std::map::erase” als een lidfunctie van de klasse “std::map”, waardoor specifieke elementen van de kaart kunnen worden verwijderd. Het is verkrijgbaar in verschillende vormen en biedt flexibiliteit bij het specificeren van welke elementen moeten worden gewist. In dit artikel zullen we ingaan op de details van “std::map::erase”, waarbij we meerdere voorbeelden geven om de veelzijdigheid ervan te illustreren.
Voorbeeld 1: Wissen met een sleutel
De mogelijkheid om de elementen per sleutel in de “std::map” te wissen is een fundamentele functie van de C++ Standard Template Library. Deze bewerking wordt vaak gebruikt wanneer u de sleutel-waardeparen in een programma moet beheren en manipuleren, en biedt een handige manier om de specifieke elementen te verwijderen op basis van hun sleutels. We zullen een voorbeeld maken om te demonstreren hoe u de “std::map” kunt gebruiken om een kaart te maken, een element met een sleutel te wissen en vervolgens de gewijzigde kaart weer te geven.
#include
#include
int. hoofd ( ) {
std::kaart < int,std::string > mijnkaart;
mijnkaart [ 1 ] = 'Rood' ;
mijnkaart [ 2 ] = 'Blauw' ;
mijnkaart [ 3 ] = 'Groente' ;
mijnMap.wissen ( 2 ) ;
voor ( const auto & paar: mijnMap ) {
std::uit << paar.eerst << ': ' << paar.seconde << std::endl;
}
opbrengst 0 ;
}
In dit voorbeeld beginnen we met het opnemen van de noodzakelijke C++-standaardbibliotheken zoals
Om de resulterende status van de kaart te laten zien, gebruiken we een ‘for’-lus die door elk sleutel-waardepaar binnen ‘myMap’ loopt. We gebruiken het object “std::cout” in de lus om elk sleutel-waardepaar naar de console af te drukken. Tenslotte rondt de “return 0”-instructie de “main”-functie af die de succesvolle uitvoering van ons programma aangeeft.
De uitvoer toont de resterende sleutel-waardeparen in de “std::map” nadat het element met sleutel 2 (“Blauw”) is gewist, wat resulteert in de uitvoer “1: Rood” en “3: Groen”.
Voorbeeld 2: Wissen door Iterator
In C++ zijn iterators objecten die de navigatie van elementen binnen een container vergemakkelijken en een manier bieden om de elementen te openen, te wijzigen of te verwijderen. De functie “std::map::erase” kan ook worden gebruikt met iterators om de elementen te verwijderen.
Hier is een voorbeeld:
#include#include
int. hoofd ( ) {
std::kaart < int,std::string > fruitMap;
fruitMap [ 1 ] = 'Mango' ;
fruitMap [ 2 ] = 'Oranje' ;
fruitMap [ 3 ] = 'Ananas' ;
fruitMap [ 4 ] = 'Druiven' ;
auto it = fruitMap.find ( 2 ) ;
als ( Het ! = fruitMap.end ( ) ) {
fruitMap.erase ( Het ) ;
}
voor ( const auto & pair : fruitMap ) {
std::uit << paar.eerst << ': ' << paar.seconde << std::endl;
}
opbrengst 0 ;
}
De meegeleverde C++-code begint met het declareren van een “std::map” met de naam “fruitMap” om de sleutel-waardeparen op te slaan, waarbij de gehele getallen worden geassocieerd met overeenkomstige fruitnamen. We vullen de kaart met vermeldingen voor vier verschillende soorten fruit: 'Mango', 'Sinaasappel', 'Ananas' en 'Druiven'. Daarna gebruiken we de functie “find” om een iterator (it) te verkrijgen die verwijst naar het element met de sleutelwaarde 2 binnen de “fruitMap”. Vervolgens controleren we of de iterator niet gelijk is aan “end()” om er zeker van te zijn dat het element met de opgegeven sleutel op de kaart voorkomt.
In het voorwaardelijke blok wissen we het element waarnaar wordt verwezen door de ‘it’-iterator met behulp van de ‘erase’-functie. Ten slotte doorlopen we de overige elementen in de gewijzigde “fruitMap” met behulp van een “for”-lus.
De uiteindelijke uitvoer toont de gewijzigde “fruitMap”-inhoud na het wissen.
Voorbeeld 3: Een bereik wissen
De container “std::map” in C++ biedt een handige methode om de elementen binnen een opgegeven bereik te wissen. Met de functie “wissen” kunt u de elementen van de kaart verwijderen op basis van iteratoren die het begin en het einde van het te verwijderen bereik vertegenwoordigen.
Laten we nu het concept van het wissen van een bereik verkennen met behulp van “std::map” met een voorbeeld:
#include#include
int. hoofd ( ) {
std::kaart < int,std::string > nieuwe kaart;
nieuwe kaart [ 1 ] = 'Paard' ;
nieuwe kaart [ 2 ] = 'Leeuw' ;
nieuwe kaart [ 3 ] = 'Tijger' ;
nieuwe kaart [ 4 ] = 'Kat' ;
nieuwe kaart. wissen ( newMap.lower_bound ( 2 ) , nieuweMap.upper_bound ( 3 ) ) ;
voor ( const auto & paar: nieuwe kaart ) {
std::uit << paar.eerst << ': ' << paar.seconde << std::endl;
}
opbrengst 0 ;
}
Het programma begint met het declareren van een “std::map” genaamd “newMap” die de gehele sleutels associeert met corresponderende stringwaarden. Daarna vullen we de kaart in met sleutel-waardeparen met behulp van de vierkante haakjesoperator. We wijzen bijvoorbeeld de sleutelwaardeparen (1, “Paard”), (2, “Leeuw”), (3, “Tijger”) en (4, “Kat”) toe aan “nieuwe kaart”.
De volgende belangrijke operatie omvat het gebruik van de iterators om de elementen van de kaart te wissen. De wisfunctie wordt gebruikt met de argumenten “newMap.lower_bound(2)” en “newMap.upper_bound(3)”. Hiermee worden de elementen gewist met toetsen die binnen het bereik (2, 3) vallen. Met andere woorden, het verwijdert de vermeldingen “Leeuw” en “Tijger” van de kaart. Na deze handeling bevat de kaart alleen de elementen met de toetsen 1 en 4, overeenkomend met “Paard” en “Kat”.
Ten slotte gebruiken we een op bereik gebaseerde “for”-lus om de resterende elementen op de kaart te doorlopen en hun sleutel-waardeparen naar de console af te drukken.
Als gevolg hiervan wordt in de uitvoer het volgende weergegeven:
Voorbeeld 4: Wissen op basis van een predikaat
Wissen op basis van een predikaat verwijst naar het verwijderen van de elementen uit een gegevensstructuur, zoals een container, op basis van een gespecificeerde voorwaarde of criteria. De “std::map::erase” kan ook worden gebruikt met een predikaatfunctie om de elementen voorwaardelijk te verwijderen. Laten we het volgende voorbeeld bekijken:
#include#include
#include
int. hoofd ( ) {
std::kaart < int,std::string > mijnkaart = {
{ 1 , 'Januari' } ,
{ 2 , 'Februari' } ,
{ 3 , 'Maart' } ,
{ 4 , 'April' } ,
{ 5 , 'Kunnen' }
} ;
automatisch predikaat = [ ] ( const std::paar < int,std::string >& element ) {
opbrengst element.seconde.lengte ( ) < 5 ;
} ;
mijnMap.wissen ( std::verwijder_if ( mijnkaart.begin ( ) , mijnkaart.end ( ) , predikaat ) , mijnkaart.end ( ) ) ;
std::uit << ' \N Kaart na het wissen van elementen op basis van het predikaat:' << std::endl;
voor ( const auto & paar: mijnMap ) {
std::uit << paar.eerst << ': ' << paar.seconde << std::endl;
}
opbrengst 0 ;
}
Het programma begint met het opnemen van de benodigde headerbestanden. Een “std::map” genaamd “myMap” wordt gedeclareerd en geïnitialiseerd in de “main” functie. Het bevat de sleutel-waardeparen die de namen van de maanden en hun respectieve numerieke waarden vertegenwoordigen. Vervolgens wordt een “lambda”-functie (predikaat) gedefinieerd. Deze “lambda” -functie dient als predikaat voor het “std::remove_if” -algoritme. Er wordt gecontroleerd of de lengte van de tekenreekswaarde die aan een kaartelement is gekoppeld minder dan vijf tekens bedraagt.
Het ‘std::remove_if’ algoritme wordt dan gebruikt in combinatie met de ‘erase’-functie van de ‘std::map’. Deze combinatie verwijdert de elementen van de kaart op basis van de geldigheid van het predikaat.
Na het uitvoeren van het programma worden de elementen met sleutels kleiner dan vijf verwijderd van de originele kaart, wat het wissen aantoont op basis van een predikaat met behulp van “std::map”.
Conclusie
Concluderend is de functie “std::map::erase” een veelzijdig hulpmiddel in C++ om de elementen uit “std::map” te verwijderen. Of het nu gaat om wissen per sleutel, iterator, bereik of op basis van een predikaat, de functie “std::map::erase” biedt flexibiliteit en gebruiksgemak. Door deze functie onder de knie te krijgen, kunnen de C++-ontwikkelaars de gegevens binnen “std::map”-containers efficiënt beheren en manipuleren, waardoor hun code sterker en gemakkelijker te onderhouden wordt.