Az „std::map” számára elérhető számos művelet közül az „erase” funkció kiemelkedik az elemek kulcsai alapján történő eltávolításának kulcsfontosságú eszközeként. Az „std::map” egy szervezett asszociatív tároló, amely kulcs-érték párokból áll. Az „std::map”-en belüli elemek elrendezése következetesen a kulcsok szerint van rendezve, megkönnyítve a kulcsértékeken alapuló hatékony műveleteket, például a keresést, beszúrást és törlést.
A C++ területén belül az „std::map::erase” függvény az „std::map” osztály tagfüggvényeként szolgál, lehetővé téve bizonyos elemek eltávolítását a térképről. Különféle formákban kapható, rugalmasságot biztosítva a törölni kívánt elemek meghatározásában. Ebben a cikkben az „std::map::erase” részleteibe fogunk beleásni, számos példával illusztrálva annak sokoldalúságát.
1. példa: Törlés kulccsal
Az „std::map” elemeinek billentyűvel való törlése a C++ Standard Template Library alapvető szolgáltatása. Ezt a műveletet általában akkor használják, ha egy programban kell kezelni és manipulálni a kulcs-érték párokat, és kényelmes módot biztosít az egyes elemek kulcsaik alapján történő eltávolítására. Létrehozunk egy példát annak bemutatására, hogyan lehet az „std::map” segítségével létrehozni egy térképet, törölni egy elemet billentyűvel, majd megjeleníteni a módosított térképet.
#include
#include
int fő ( ) {
std::map < int, std::string > myMap;
myMap [ 1 ] = 'Piros' ;
myMap [ 2 ] = 'Kék' ;
myMap [ 3 ] = 'Zöld' ;
myMap.erase ( 2 ) ;
számára ( const auto & pár: myMap ) {
std::cout << pár.első << ':' << pár.második << std::endl;
}
Visszatérés 0 ;
}
Ebben a példában a szükséges C++ szabványkönyvtárak beépítésével kezdjük, mint például az
A térkép eredményül kapott állapotának bemutatásához egy „for” ciklust alkalmazunk, amely a „myMap” minden kulcs-érték páron keresztül iterál. A cikluson belüli „std::cout” objektumot használjuk az egyes kulcs-érték párok kinyomtatására a konzolra. Végül a „return 0” utasítás zárja le a „fő” függvényt, amely a programunk sikeres végrehajtását jelzi.
A kimenet megjeleníti a fennmaradó kulcs-érték párokat az „std::map”-ben, miután a 2-es kulcsú elem („Kék”) törlődik, ami „1: Piros” és „3: Green” kimenetet eredményez.
2. példa: Törlés Iterátorral
A C++ nyelvben az iterátorok olyan objektumok, amelyek megkönnyítik a tárolón belüli elemek navigálását, és lehetőséget kínálnak az elemek eléréséhez, módosításához vagy eltávolításához. Az „std::map::erase” függvény iterátorokkal együtt is használható az elemek eltávolítására.
Íme egy példa:
#include#include
int fő ( ) {
std::map < int, std::string > gyümölcsmappa;
gyümölcsmappa [ 1 ] = 'Mangó' ;
gyümölcsmappa [ 2 ] = 'Narancs' ;
gyümölcsmappa [ 3 ] = 'Ananász' ;
gyümölcsmappa [ 4 ] = 'Szőlő' ;
auto it = gyümölcsMap.find ( 2 ) ;
ha ( azt ! = gyümölcsMap.end ( ) ) {
gyümölcsTérkép.törlés ( azt ) ;
}
számára ( const auto & pár : gyümölcstérkép ) {
std::cout << pár.első << ':' << pár.második << std::endl;
}
Visszatérés 0 ;
}
A megadott C++ kód a „fruitMap” nevű „std::map” deklarálásával kezdődik, amely a kulcs-érték párokat tárolja, és az egész számokat a megfelelő gyümölcsnevekhez rendeli. A térképet négy különböző gyümölcsre vonatkozó bejegyzésekkel töltjük fel: „Mango”, „Orange”, „PineApple” és „Szőlő”. Ezt követően a „find” függvény segítségével egy iterátort (it) kapunk, amely a 2-es kulcsértékű elemre mutat a „fruitMap”-en belül. Ezután ellenőrizzük, hogy az iterátor nem egyenlő-e az „end()”-vel, hogy megbizonyosodjunk arról, hogy a megadott kulccsal rendelkező elem létezik a térképen.
A feltételes blokkban töröljük azt az elemet, amelyre az „it” iterátor mutat az „erase” funkció segítségével. Végül a módosított „fruitMap” fennmaradó elemeit iteráljuk egy „for” ciklus segítségével.
A végső kimenet a módosított „fruitMap” tartalmat jeleníti meg a törlés után.
3. példa: Tartomány törlése
A C++ „std::map” tárolója kényelmes módszert biztosít a megadott tartományon belüli elemek törlésére. A „törlés” funkció lehetővé teszi az elemek eltávolítását a térképről olyan iterátorok alapján, amelyek a törölni kívánt tartomány elejét és végét jelentik.
Most vizsgáljuk meg a tartomány törlésének koncepcióját az „std::map” használatával egy példával:
#include#include
int fő ( ) {
std::map < int, std::string > újtérkép;
újtérkép [ 1 ] = 'Ló' ;
újtérkép [ 2 ] = 'Oroszlán' ;
újtérkép [ 3 ] = 'Tigris' ;
újtérkép [ 4 ] = 'Macska' ;
newMap.erase ( newMap.lower_bound ( 2 ) , newMap.upper_bound ( 3 ) ) ;
számára ( const auto & pár : újtérkép ) {
std::cout << pár.első << ':' << pár.második << std::endl;
}
Visszatérés 0 ;
}
A program a „newMap” nevű „std::map” deklarálásával kezdődik, amely az egész kulcsokat a megfelelő karakterlánc-értékekhez rendeli. Ezt követően a szögletes zárójeles operátor segítségével kulcs-érték párokkal töltjük fel a térképet. Például az (1, „ló”), (2, „Oroszlán”), (3, „Tigris”) és (4, „Macska”) kulcs-érték párokat hozzárendeljük az „újtérképhez”.
A következő jelentős művelet az iterátorok használata az elemek törlésére a térképről. Az erase függvény a „newMap.lower_bound(2)” és a „newMap.upper_bound(3)” argumentumokkal együtt használatos. Ez törli a (2, 3) tartományba eső billentyűkkel rendelkező elemeket. Más szavakkal, eltávolítja az „Oroszlán” és „Tigris” bejegyzéseket a térképről. Ezt a műveletet követően a térkép csak az 1-es és 4-es gombokkal ellátott elemeket tartalmazza, amelyek megfelelnek a „Ló” és a „Cat” kifejezéseknek.
Végül egy tartomány-alapú „for” ciklust használunk a térkép többi elemének iterálására, és kinyomtatjuk a kulcs-érték párjaikat a konzolra.
Ennek eredményeként a kimenet a következőket jeleníti meg:
4. példa: Törlés predikátum alapján
A predikátumon alapuló törlés az elemek adatszerkezetből, például tárolóból való eltávolítását jelenti, meghatározott feltétel vagy feltételek alapján. Az „std::map::erase” predikátumfüggvénnyel együtt is használható az elemek feltételes eltávolítására. Tekintsük a következő példát:
#include#include
#include
int fő ( ) {
std::map < int, std::string > myMap = {
{ 1 , 'Január' } ,
{ 2 , 'Február' } ,
{ 3 , 'Március' } ,
{ 4 , 'Április' } ,
{ 5 , 'Lehet' }
} ;
auto predikátum = [ ] ( const std::pair < int, std::string >& elem ) {
Visszatérés elem.második.hosszúság ( ) < 5 ;
} ;
myMap.erase ( std::remove_if ( myMap.begin ( ) , myMap.end ( ) , állítmány ) , myMap.end ( ) ) ;
std::cout << ' \n Térkép az elemek törlése után a predikátum alapján:' << std::endl;
számára ( const auto & pár: myMap ) {
std::cout << pár.első << ':' << pár.második << std::endl;
}
Visszatérés 0 ;
}
A program a szükséges fejlécfájlok hozzáadásával kezdődik. Egy „std::map” nevű „myMap” deklarálódik és inicializálódik a „main” függvényben. Tartalmazza a kulcs-érték párokat, amelyek a hónapok nevét és a hozzájuk tartozó számértékeket jelentik. Ezt követően egy „lambda” függvény (predikátum) kerül meghatározásra. Ez a „lambda” függvény az „std::remove_if” algoritmus predikátumaként szolgál. Ellenőrzi, hogy a térképelemhez társított karakterlánc-érték hossza kevesebb-e öt karakternél.
Az „std::remove_if” algoritmust ezután az „std::map” „erase” funkciójával együtt használjuk. Ez a kombináció a predikátum érvényessége alapján eltávolítja az elemeket a térképről.
A program futtatása után az ötnél kisebb kulcsú elemek eltávolításra kerülnek az eredeti térképről, demonstrálva az „std::map” predikátum alapján történő törlést.
Következtetés
Összefoglalva, az „std::map::erase” függvény egy sokoldalú eszköz a C++ nyelven az „std::map” elemek eltávolítására. Akár kulccsal, iterátorral, tartománysal vagy predikátumon alapuló törlésről van szó, az „std::map::erase” funkció rugalmasságot és egyszerű használatot biztosít. A funkció elsajátításával a C++ fejlesztők hatékonyan kezelhetik és manipulálhatják az „std::map” tárolókban lévő adatokat, így a kódjuk erősebb és könnyebben karbantartható.