Sa maraming mga operasyon na magagamit para sa 'std::map', ang function na 'erase' ay namumukod-tangi bilang isang mahalagang tool para sa pag-alis ng mga elemento batay sa kanilang mga susi. Ang 'std::map' ay isang organisadong nag-uugnay na lalagyan na binubuo ng mga pares ng key-value. Ang pag-aayos ng mga elemento sa loob ng 'std::map' ay pare-parehong pinagbubukod-bukod ayon sa kanilang mga susi, na nagpapadali sa mga epektibong operasyon gaya ng paghahanap, pagpasok, at pagtanggal batay sa mga pangunahing halaga.
Sa loob ng larangan ng C++, ang function na 'std::map::erase' ay nagsisilbing function ng miyembro ng class na 'std::map', na nagbibigay-daan sa pag-aalis ng mga partikular na elemento mula sa mapa. Dumating ito sa iba't ibang anyo, na nagbibigay ng kakayahang umangkop sa pagtukoy kung aling mga elemento ang buburahin. Sa artikulong ito, susuriin natin ang mga detalye ng 'std::map::erase', na nagbibigay ng maraming halimbawa upang ilarawan ang versatility nito.
Halimbawa 1: Pagbubura sa pamamagitan ng Susi
Ang kakayahang burahin ang mga elemento sa pamamagitan ng key sa 'std::map' ay isang pangunahing tampok na ibinigay ng C++ Standard Template Library. Karaniwang ginagamit ang operasyong ito kapag kailangan mong pamahalaan at manipulahin ang mga pares ng key-value sa isang program, at nagbibigay ito ng maginhawang paraan upang alisin ang mga partikular na elemento batay sa kanilang mga susi. Gagawa kami ng isang halimbawa upang ipakita kung paano gamitin ang 'std::map' upang lumikha ng isang mapa, burahin ang isang elemento sa pamamagitan ng key, at pagkatapos ay ipakita ang binagong mapa.
#include
#include
int pangunahing ( ) {
std::mapa < int, std::string > myMap;
myMap [ 1 ] = 'Pula' ;
myMap [ 2 ] = 'Asul' ;
myMap [ 3 ] = 'berde' ;
myMap.erase ( 2 ) ;
para sa ( const auto at pares: myMap ) {
std::cout << pares.una << ': ' << pares.pangalawa << std::endl;
}
bumalik 0 ;
}
Sa halimbawang ito, magsisimula tayo sa pamamagitan ng pagsasama ng mga kinakailangang C++ na karaniwang mga aklatan tulad ng
Upang ipakita ang resultang estado ng mapa, gumamit kami ng 'para' na loop na umuulit sa bawat pares ng key-value sa loob ng 'myMap.' Ginagamit namin ang object na 'std::cout' sa loob ng loop para i-print ang bawat key-value pair sa console. Sa wakas, ang 'return 0' na pahayag ay nagtatapos sa 'pangunahing' function na nagpapahiwatig ng matagumpay na pagpapatupad ng aming programa.
Ipinapakita ng output ang natitirang key-value pairs sa “std::map” pagkatapos mabura ang elementong may key 2 (“Blue”) na nagreresulta sa “1: Red” at “3: Green” na output.
Halimbawa 2: Pagbubura sa pamamagitan ng Iterator
Sa C++, ang mga iterator ay mga bagay na nagpapadali sa pag-navigate ng mga elemento sa loob ng isang lalagyan, na nag-aalok ng paraan upang ma-access, baguhin, o alisin ang mga elemento. Ang function na 'std::map::erase' ay maaari ding gamitin kasama ng mga iterator upang alisin ang mga elemento.
Narito ang isang halimbawa:
#include#include
int pangunahing ( ) {
std::mapa < int, std::string > fruitFolder;
fruitFolder [ 1 ] = 'mangga' ;
fruitFolder [ 2 ] = 'Kahel' ;
fruitFolder [ 3 ] = 'Pinas' ;
fruitFolder [ 4 ] = 'Ubas' ;
auto ito = fruitMap.find ( 2 ) ;
kung ( ito ! = fruitMap.end ( ) ) {
fruitMap.burahin ( ito ) ;
}
para sa ( const auto at pares: fruitMap ) {
std::cout << pares.una << ': ' << pares.pangalawa << std::endl;
}
bumalik 0 ;
}
Ang ibinigay na C++ code ay nagsisimula sa pamamagitan ng pagdedeklara ng 'std::map' na pinangalanang 'fruitMap' upang iimbak ang mga pares ng key-value, na iniuugnay ang mga integer sa mga katumbas na pangalan ng prutas. Pinupunan namin ang mapa ng mga entry para sa apat na magkakaibang prutas: 'Mango', 'Orange', 'PineApple', at 'Grapes'. Pagkatapos nito, ginagamit namin ang function na 'hanapin' upang makakuha ng isang iterator (ito) na tumuturo sa elemento na may pangunahing halaga na 2 sa loob ng 'fruitMap'. Pagkatapos, tinitingnan namin kung ang iterator ay hindi katumbas ng 'end()' upang matiyak na ang elementong may tinukoy na key ay umiiral sa mapa.
Sa conditional block, binubura namin ang elementong itinuturo ng 'it' iterator gamit ang function na 'erase'. Sa wakas, umuulit kami sa mga natitirang elemento sa binagong 'fruitMap' gamit ang loop na 'para sa'.
Ang huling output ay nagpapakita ng binagong 'fruitMap' na mga nilalaman pagkatapos ng pagbura.
Halimbawa 3: Pagbubura ng Saklaw
Ang lalagyan ng 'std::map' sa C++ ay nagbibigay ng isang maginhawang paraan upang burahin ang mga elemento sa loob ng isang tinukoy na hanay. Binibigyang-daan ka ng function na 'burahin' na alisin ang mga elemento mula sa mapa batay sa mga iterator na kumakatawan sa simula at dulo ng hanay na tatanggalin.
Ngayon, tuklasin natin ang konsepto ng pagbubura ng isang hanay gamit ang 'std::map' na may isang halimbawa:
#include#include
int pangunahing ( ) {
std::mapa < int, std::string > newMap;
bagong Mapa [ 1 ] = 'Kabayo' ;
bagong Mapa [ 2 ] = 'Leon' ;
bagong Mapa [ 3 ] = 'Tigre' ;
bagong Mapa [ 4 ] = 'Pusa' ;
newMap.erase ( newMap.lower_bound ( 2 ) , newMap.upper_bound ( 3 ) ) ;
para sa ( const auto at pares: newMap ) {
std::cout << pares.una << ': ' << pares.pangalawa << std::endl;
}
bumalik 0 ;
}
Nagsisimula ang programa sa pamamagitan ng pagdedeklara ng 'std::map' na pinangalanang 'newMap' na nag-uugnay sa mga integer key sa mga katumbas na halaga ng string. Pagkatapos nito, pinupuno namin ang mapa ng mga pares ng key-value gamit ang operator ng square bracket. Halimbawa, itinatalaga namin ang mga pares ng key-value ng (1, “Kabayo”), (2, “Leon”), (3, “Tiger”), at (4, “Cat”) sa “newMap”.
Ang susunod na makabuluhang operasyon ay nagsasangkot ng paggamit ng mga iterator upang burahin ang mga elemento mula sa mapa. Ang function na burahin ay ginagamit sa mga argumentong 'newMap.lower_bound(2)' at 'newMap.upper_bound(3)'. Binubura nito ang mga elemento na may mga key na nasa hanay (2, 3). Sa madaling salita, inaalis nito ang mga entry na 'Lion' at 'Tiger' mula sa mapa. Pagkatapos ng operasyong ito, ang mapa ay naglalaman lamang ng mga elemento na may mga susi 1 at 4, na tumutugma sa 'Kabayo' at 'Pusa'.
Panghuli, gumagamit kami ng nakabatay sa saklaw na loop na 'para sa' upang umulit sa mga natitirang elemento sa mapa at i-print ang kanilang mga pares ng key-value sa console.
Bilang resulta, ipinapakita ng output ang sumusunod:
Halimbawa 4: Pagbubura Batay sa Panaguri
Ang pagbura batay sa isang panaguri ay tumutukoy sa pag-alis ng mga elemento mula sa isang istraktura ng data, tulad ng isang lalagyan, batay sa isang tinukoy na kundisyon o pamantayan. Ang 'std::map::erase' ay maaari ding gamitin sa isang predicate function upang alisin ang mga elemento nang may kondisyon. Isaalang-alang natin ang sumusunod na halimbawa:
#include#include
#include
int pangunahing ( ) {
std::mapa < int, std::string > myMap = {
{ 1 , 'Enero' } ,
{ 2 , 'Pebrero' } ,
{ 3 , 'Marso' } ,
{ 4 , 'Abril' } ,
{ 5 , 'Mayo' }
} ;
auto predicate = [ ] ( const std::pair < int, std::string >& elemento ) {
bumalik elemento.pangalawa.haba ( ) < 5 ;
} ;
myMap.erase ( std::remove_if ( myMap.magsimula ( ) , myMap.end ( ) , panaguri ) , myMap.end ( ) ) ;
std::cout << ' \n Mapa pagkatapos burahin ang mga elemento batay sa panaguri:' << std::endl;
para sa ( const auto at pares: myMap ) {
std::cout << pares.una << ': ' << pares.pangalawa << std::endl;
}
bumalik 0 ;
}
Nagsisimula ang programa sa pamamagitan ng pagsasama ng mga kinakailangang file ng header. Ang isang 'std::map' na tinatawag na 'myMap' ay idineklara at pinasimulan sa 'pangunahing' function. Naglalaman ito ng mga pares ng key-value na kumakatawan sa mga pangalan ng buwan at ng kani-kanilang mga numerical value. Kasunod nito, tinukoy ang isang function na 'lambda' (predicate). Ang function na 'lambda' na ito ay nagsisilbing predicate para sa algorithm na 'std::remove_if'. Bine-verify nito kung ang haba ng value ng string na nauugnay sa isang elemento ng mapa ay mas mababa sa limang character.
Ang 'std::remove_if' algorithm ay gagamitin kasabay ng 'erase' function ng 'std::map'. Tinatanggal ng kumbinasyong ito ang mga elemento mula sa mapa batay sa bisa ng panaguri.
Pagkatapos patakbuhin ang programa, ang mga elemento na may mga key na mas mababa sa lima ay aalisin mula sa orihinal na mapa, na nagpapakita ng pagbura batay sa isang predicate gamit ang 'std::map'.
Konklusyon
Sa konklusyon, ang function na 'std::map::erase' ay isang versatile tool sa C++ upang alisin ang mga elemento mula sa 'std::map'. Magbubura man sa pamamagitan ng key, iterator, range, o batay sa isang predicate, ang function na 'std::map::erase' ay nagbibigay ng flexibility at kadalian ng paggamit. Sa pamamagitan ng pag-master ng function na ito, ang mga developer ng C++ ay maaaring mahusay na pamahalaan at manipulahin ang data sa loob ng 'std::map' container, na ginagawang mas malakas at mas madaling mapanatili ang kanilang code.