Unter den vielen für „std::map“ verfügbaren Operationen sticht die Funktion „erase“ als entscheidendes Werkzeug zum Entfernen der Elemente basierend auf ihren Schlüsseln hervor. Eine „std::map“ ist ein organisierter assoziativer Container, der aus Schlüssel-Wert-Paaren besteht. Die Anordnung der Elemente innerhalb einer „std::map“ ist konsistent nach ihren Schlüsseln sortiert, was effektive Vorgänge wie Suchen, Einfügen und Löschen basierend auf Schlüsselwerten erleichtert.
Im Bereich von C++ dient die Funktion „std::map::erase“ als Mitgliedsfunktion der Klasse „std::map“ und ermöglicht die Entfernung bestimmter Elemente aus der Karte. Es ist in verschiedenen Formen erhältlich und bietet Flexibilität bei der Angabe, welche Elemente gelöscht werden sollen. In diesem Artikel werden wir uns mit den Details von „std::map::erase“ befassen und mehrere Beispiele liefern, um seine Vielseitigkeit zu veranschaulichen.
Beispiel 1: Löschen per Schlüssel
Die Möglichkeit, die Elemente per Schlüssel in der „std::map“ zu löschen, ist eine grundlegende Funktion der C++-Standardvorlagenbibliothek. Dieser Vorgang wird häufig verwendet, wenn Sie die Schlüssel-Wert-Paare in einem Programm verwalten und manipulieren müssen, und bietet eine bequeme Möglichkeit, bestimmte Elemente basierend auf ihren Schlüsseln zu entfernen. Wir werden ein Beispiel erstellen, um zu demonstrieren, wie man mit „std::map“ eine Karte erstellt, ein Element per Schlüssel löscht und dann die geänderte Karte anzeigt.
#include
#include
int main ( ) {
std::map < int, std::string > meineKarte;
meineKarte [ 1 ] = 'Rot' ;
meineKarte [ 2 ] = 'Blau' ;
meineKarte [ 3 ] = 'Grün' ;
myMap.erase ( 2 ) ;
für ( const auto & Paar: myMap ) {
std::cout << Paar.zuerst << ': ' << Paar.Sekunde << std::endl;
}
zurückkehren 0 ;
}
In diesem Beispiel beginnen wir mit der Einbindung der erforderlichen C++-Standardbibliotheken wie
Um den resultierenden Zustand der Karte darzustellen, verwenden wir eine „for“-Schleife, die jedes Schlüssel-Wert-Paar in „myMap“ durchläuft. Wir verwenden das „std::cout“-Objekt innerhalb der Schleife, um jedes Schlüssel-Wert-Paar auf der Konsole auszugeben. Schließlich schließt die „return 0“-Anweisung die „main“-Funktion ab, die die erfolgreiche Ausführung unseres Programms signalisiert.
Die Ausgabe zeigt die verbleibenden Schlüssel-Wert-Paare in „std::map“ an, nachdem das Element mit Schlüssel 2 („Blau“) gelöscht wurde, was zur Ausgabe „1: Rot“ und „3: Grün“ führt.
Beispiel 2: Löschen durch Iterator
In C++ sind Iteratoren Objekte, die die Navigation von Elementen innerhalb eines Containers erleichtern und eine Möglichkeit bieten, auf die Elemente zuzugreifen, sie zu ändern oder zu entfernen. Die Funktion „std::map::erase“ kann auch mit Iteratoren verwendet werden, um die Elemente zu entfernen.
Hier ist ein Beispiel:
#include#include
int main ( ) {
std::map < int, std::string > FruitFolder;
Obstordner [ 1 ] = 'Mango' ;
Obstordner [ 2 ] = 'Orange' ;
Obstordner [ 3 ] = 'Ananas' ;
Obstordner [ 4 ] = 'Trauben' ;
auto it = FruitMap.find ( 2 ) ;
Wenn ( Es ! = FruitMap.end ( ) ) {
FruitMap.erase ( Es ) ;
}
für ( const auto & Paar: FruitMap ) {
std::cout << Paar.zuerst << ': ' << Paar.Sekunde << std::endl;
}
zurückkehren 0 ;
}
Der bereitgestellte C++-Code beginnt mit der Deklaration einer „std::map“ namens „fruitMap“, um die Schlüssel-Wert-Paare zu speichern und die Ganzzahlen den entsprechenden Fruchtnamen zuzuordnen. Wir füllen die Karte mit Einträgen für vier verschiedene Früchte: „Mango“, „Orange“, „Ananas“ und „Trauben“. Danach verwenden wir die Funktion „find“, um einen Iterator (it) zu erhalten, der auf das Element mit dem Schlüsselwert 2 innerhalb der „fruitMap“ zeigt. Anschließend prüfen wir, ob der Iterator ungleich „end()“ ist, um sicherzustellen, dass das Element mit dem angegebenen Schlüssel in der Karte vorhanden ist.
Im bedingten Block löschen wir das Element, auf das der Iterator „it“ zeigt, mithilfe der Funktion „erase“. Schließlich durchlaufen wir die verbleibenden Elemente in der modifizierten „fruitMap“ mithilfe einer „for“-Schleife.
Die endgültige Ausgabe zeigt den geänderten „fruitMap“-Inhalt nach dem Löschen an.
Beispiel 3: Löschen eines Bereichs
Der „std::map“-Container in C++ bietet eine praktische Methode zum Löschen der Elemente innerhalb eines angegebenen Bereichs. Mit der Funktion „Löschen“ können Sie die Elemente aus der Karte entfernen, basierend auf Iteratoren, die den Anfang und das Ende des zu löschenden Bereichs darstellen.
Lassen Sie uns nun das Konzept des Löschens eines Bereichs mithilfe von „std::map“ anhand eines Beispiels untersuchen:
#include#include
int main ( ) {
std::map < int, std::string > newMap;
neueKarte [ 1 ] = 'Pferd' ;
neueKarte [ 2 ] = 'Löwe' ;
neueKarte [ 3 ] = 'Tiger' ;
neueKarte [ 4 ] = 'Katze' ;
newMap.erase ( newMap.lower_bound ( 2 ) , newMap.upper_bound ( 3 ) ) ;
für ( const auto & Paar: newMap ) {
std::cout << Paar.zuerst << ': ' << Paar.Sekunde << std::endl;
}
zurückkehren 0 ;
}
Das Programm beginnt mit der Deklaration einer „std::map“ mit dem Namen „newMap“, die die Ganzzahlschlüssel den entsprechenden Zeichenfolgewerten zuordnet. Anschließend füllen wir die Karte mithilfe des eckigen Klammeroperators mit Schlüssel-Wert-Paaren. Beispielsweise weisen wir „newMap“ die Schlüssel-Wert-Paare (1, „Pferd“), (2, „Löwe“), (3, „Tiger“) und (4, „Katze“) zu.
Der nächste wichtige Vorgang besteht darin, mithilfe der Iteratoren die Elemente aus der Karte zu löschen. Die Löschfunktion wird mit den Argumenten „newMap.lower_bound(2)“ und „newMap.upper_bound(3)“ verwendet. Dadurch werden die Elemente mit Schlüsseln gelöscht, die in den Bereich (2, 3) fallen. Mit anderen Worten: Die Einträge „Löwe“ und „Tiger“ werden von der Karte entfernt. Nach diesem Vorgang enthält die Karte nur noch die Elemente mit den Schlüsseln 1 und 4, entsprechend „Pferd“ und „Katze“.
Schließlich verwenden wir eine bereichsbasierte „for“-Schleife, um die verbleibenden Elemente in der Karte zu durchlaufen und ihre Schlüssel-Wert-Paare auf der Konsole auszugeben.
Als Ergebnis zeigt die Ausgabe Folgendes an:
Beispiel 4: Löschen basierend auf einem Prädikat
Das Löschen basierend auf einem Prädikat bezieht sich auf das Entfernen der Elemente aus einer Datenstruktur, beispielsweise einem Container, basierend auf einer angegebenen Bedingung oder einem bestimmten Kriterium. „std::map::erase“ kann auch mit einer Prädikatfunktion verwendet werden, um die Elemente bedingt zu entfernen. Betrachten wir das folgende Beispiel:
#include#include
#include
int main ( ) {
std::map < int, std::string > myMap = {
{ 1 , 'Januar' } ,
{ 2 , 'Februar' } ,
{ 3 , 'Marsch' } ,
{ 4 , 'April' } ,
{ 5 , 'Mai' }
} ;
Auto-Prädikat = [ ] ( const std::pair < int, std::string >& Element ) {
zurückkehren element.second.length ( ) < 5 ;
} ;
myMap.erase ( std::remove_if ( myMap.begin ( ) , myMap.end ( ) , Prädikat ) , myMap.end ( ) ) ;
std::cout << ' \N Karte nach dem Löschen von Elementen basierend auf dem Prädikat:' << std::endl;
für ( const auto & Paar: myMap ) {
std::cout << Paar.zuerst << ': ' << Paar.Sekunde << std::endl;
}
zurückkehren 0 ;
}
Das Programm beginnt mit dem Einbinden der notwendigen Header-Dateien. Eine „std::map“ namens „myMap“ wird in der Funktion „main“ deklariert und initialisiert. Es enthält die Schlüssel-Wert-Paare, die die Namen der Monate und ihre jeweiligen numerischen Werte darstellen. Anschließend wird eine „Lambda“-Funktion (Prädikat) definiert. Diese „Lambda“-Funktion dient als Prädikat für den „std::remove_if“-Algorithmus. Es überprüft, ob die Länge des Zeichenfolgewerts, der einem Kartenelement zugeordnet ist, weniger als fünf Zeichen beträgt.
Der „std::remove_if“-Algorithmus wird dann in Verbindung mit der „erase“-Funktion der „std::map“ verwendet. Diese Kombination entfernt die Elemente basierend auf der Gültigkeit des Prädikats aus der Karte.
Nach dem Ausführen des Programms werden die Elemente mit Schlüsseln unter fünf aus der ursprünglichen Karte entfernt, wodurch das Löschen anhand eines Prädikats mit „std::map“ demonstriert wird.
Abschluss
Zusammenfassend lässt sich sagen, dass die Funktion „std::map::erase“ ein vielseitiges Werkzeug in C++ ist, um die Elemente aus „std::map“ zu entfernen. Unabhängig davon, ob das Löschen nach Schlüssel, Iterator, Bereich oder basierend auf einem Prädikat erfolgt, bietet die Funktion „std::map::erase“ Flexibilität und Benutzerfreundlichkeit. Durch die Beherrschung dieser Funktion können die C++-Entwickler die Daten in „std::map“-Containern effizient verwalten und manipulieren, wodurch ihr Code stärker und einfacher zu warten ist.