Printre numeroasele operațiuni disponibile pentru „std::map”, funcția „erase” se remarcă ca un instrument crucial pentru eliminarea elementelor pe baza tastelor acestora. O „std::map” este un container asociativ organizat care cuprinde perechi cheie-valoare. Aranjarea elementelor într-o „std::map” este sortată în mod constant în funcție de cheile lor, facilitând operațiunile eficiente precum căutarea, inserarea și ștergerea pe baza valorilor cheie.
În domeniul C++, funcția „std::map::erase” servește ca o funcție membră a clasei „std::map”, permițând eliminarea anumitor elemente de pe hartă. Vine în diferite forme, oferind flexibilitate în specificarea elementelor de șters. În acest articol, vom aprofunda în detaliile „std::map::erase”, oferind mai multe exemple pentru a ilustra versatilitatea acestuia.
Exemplul 1: Ștergerea după cheie
Abilitatea de a șterge elementele prin tastă în „std::map” este o caracteristică fundamentală oferită de Biblioteca de șabloane standard C++. Această operație este folosită în mod obișnuit atunci când trebuie să gestionați și să manipulați perechile cheie-valoare dintr-un program și oferă o modalitate convenabilă de a elimina elementele specifice pe baza cheilor lor. Vom crea un exemplu pentru a demonstra cum să folosiți „std::map” pentru a crea o hartă, a șterge un element cu tastă și apoi a afișa harta modificată.
#include
#include
int principal ( ) {
std::hartă < int, std::string > myMap;
MyMap [ 1 ] = 'Roșu' ;
MyMap [ 2 ] = 'Albastru' ;
MyMap [ 3 ] = 'Verde' ;
myMap.erase ( 2 ) ;
pentru ( const auto & pereche: myMap ) {
std::cout << pereche.în primul rând << ':' << pereche.a doua << std::endl;
}
întoarcere 0 ;
}
În acest exemplu, începem prin a include bibliotecile standard C++ necesare, cum ar fi
Pentru a prezenta starea rezultată a hărții, folosim o buclă „for” care iterează prin fiecare pereche cheie-valoare din „myMap”. Utilizăm obiectul „std::cout” din interiorul buclei pentru a imprima fiecare pereche cheie-valoare pe consolă. În cele din urmă, instrucțiunea „return 0” încheie funcția „principală” care semnalează execuția cu succes a programului nostru.
Ieșirea afișează perechile cheie-valoare rămase în „std::map” după ce elementul cu cheia 2 („Albastru”) este șters, ceea ce are ca rezultat ieșirea „1: Roșu” și „3: Verde”.
Exemplul 2: Ștergerea prin iterator
În C++, iteratoarele sunt obiecte care facilitează navigarea elementelor într-un container, oferind un mijloc de a accesa, modifica sau elimina elementele. Funcția „std::map::erase” poate fi folosită și cu iteratoare pentru a elimina elementele.
Iată un exemplu:
#include#include
int principal ( ) {
std::hartă < int, std::string > fruitFolder;
fruitFolder [ 1 ] = 'Mango' ;
fruitFolder [ 2 ] = 'Portocale' ;
fruitFolder [ 3 ] = 'Ananas' ;
fruitFolder [ 4 ] = 'struguri' ;
auto it = fruitMap.find ( 2 ) ;
dacă ( aceasta ! = fruitMap.end ( ) ) {
fruitMap.erase ( aceasta ) ;
}
pentru ( const auto & pereche: fruitMap ) {
std::cout << pereche.în primul rând << ':' << pereche.a doua << std::endl;
}
întoarcere 0 ;
}
Codul C++ furnizat începe prin declararea unui „std::map” numit „fruitMap” pentru a stoca perechile cheie-valoare, asociind numerele întregi cu numele de fructe corespunzătoare. Populam harta cu intrări pentru patru fructe diferite: „Mango”, „Orange”, „PineApple” și „Struguri”. După aceea, folosim funcția „găsește” pentru a obține un iterator (it) care indică elementul cu valoarea cheie 2 din „fruitMap”. Apoi, verificăm dacă iteratorul nu este egal cu „end()” pentru a ne asigura că elementul cu cheia specificată există în hartă.
În blocul condiționat, ștergem elementul către care este indicat de iteratorul „it” folosind funcția „șterge”. În cele din urmă, repetăm elementele rămase în „fruitMap” modificat folosind o buclă „for”.
Ieșirea finală afișează conținutul modificat „fruitMap” după ștergere.
Exemplul 3: Ștergerea unui interval
Containerul „std::map” din C++ oferă o metodă convenabilă de a șterge elementele dintr-un interval specificat. Funcția „ștergere” vă permite să eliminați elementele de pe hartă pe baza iteratoarelor care reprezintă începutul și sfârșitul intervalului de șters.
Acum, să explorăm conceptul de ștergere a unui interval folosind „std::map” cu un exemplu:
#include#include
int principal ( ) {
std::hartă < int, std::string > hartă nouă;
hartă nouă [ 1 ] = 'Cal' ;
hartă nouă [ 2 ] = 'Leu' ;
hartă nouă [ 3 ] = 'Tigru' ;
hartă nouă [ 4 ] = 'Pisică' ;
newMap.erase ( newMap.lower_bound ( 2 ) , newMap.upper_bound ( 3 ) ) ;
pentru ( const auto & pereche: newMap ) {
std::cout << pereche.în primul rând << ':' << pereche.a doua << std::endl;
}
întoarcere 0 ;
}
Programul începe prin declararea unui „std::map” numit „newMap” care asociază cheile întregi cu valorile șirurilor corespunzătoare. După aceea, populăm harta cu perechi cheie-valoare folosind operatorul paranteze pătrate. De exemplu, atribuim perechile cheie-valoare de (1, „Cal”), (2, „Leu”), (3, „Tigru”) și (4, „Pisică”) la „Hartă nouă”.
Următoarea operațiune semnificativă implică utilizarea iteratoarelor pentru a șterge elementele de pe hartă. Funcția de ștergere este folosită cu argumentele „newMap.lower_bound(2)” și „newMap.upper_bound(3)”. Acest lucru șterge elementele cu taste care se încadrează în intervalul (2, 3). Cu alte cuvinte, elimină intrările „Leu” și „Tigru” de pe hartă. După această operație, harta conține doar elementele cu cheile 1 și 4, corespunzătoare „Calului” și „Pisicii”.
În cele din urmă, folosim o buclă „for” bazată pe interval pentru a itera elementele rămase din hartă și pentru a le imprima perechile cheie-valoare pe consolă.
Ca rezultat, rezultatul afișează următoarele:
Exemplul 4: Ștergerea pe baza unui predicat
Ștergerea pe baza unui predicat se referă la eliminarea elementelor dintr-o structură de date, cum ar fi un container, pe baza unei condiții sau criterii specificate. „std::map::erase” poate fi folosit și cu o funcție de predicat pentru a elimina elementele în mod condiționat. Să luăm în considerare următorul exemplu:
#include#include
#include
int principal ( ) {
std::hartă < int, std::string > myMap = {
{ 1 , 'Ianuarie' } ,
{ 2 , 'Februarie' } ,
{ 3 , 'Martie' } ,
{ 4 , 'Aprilie' } ,
{ 5 , 'Mai' }
} ;
auto predicat = [ ] ( const std::pereche < int, std::string >& element ) {
întoarcere element.a doua.lungime ( ) < 5 ;
} ;
myMap.erase ( std::remove_if ( myMap.begin ( ) , myMap.end ( ) , predicat ) , myMap.end ( ) ) ;
std::cout << ' \n Hartă după ștergerea elementelor bazate pe predicat:' << std::endl;
pentru ( const auto & pereche: myMap ) {
std::cout << pereche.în primul rând << ':' << pereche.a doua << std::endl;
}
întoarcere 0 ;
}
Programul începe prin includerea fișierelor de antet necesare. O „std::map” numită „myMap” este declarată și inițializată în funcția „main”. Conține perechile cheie-valoare care reprezintă numele lunilor și valorile lor numerice respective. Ulterior, este definită o funcție „lambda” (predicat). Această funcție „lambda” servește ca predicat pentru algoritmul „std::remove_if”. Acesta verifică dacă lungimea valorii șirului care este asociată cu un element de hartă este mai mică de cinci caractere.
Algoritmul „std::remove_if” este apoi utilizat împreună cu funcția „erase” a „std::map”. Această combinație elimină elementele de pe hartă pe baza validității predicatului.
După rularea programului, elementele cu chei mai mici de cinci sunt eliminate din harta originală, demonstrând ștergerea pe baza unui predicat folosind „std::map”.
Concluzie
În concluzie, funcția „std::map::erase” este un instrument versatil în C++ pentru a elimina elementele din „std::map”. Indiferent dacă ștergerea prin tastă, iterator, interval sau bazată pe un predicat, funcția „std::map::erase” oferă flexibilitate și ușurință în utilizare. Stăpânind această funcție, dezvoltatorii C++ pot gestiona și manipula eficient datele din containerele „std::map”, făcând codul lor mai puternic și mai ușor de întreținut.