'std::map' కోసం అందుబాటులో ఉన్న అనేక ఆపరేషన్లలో, 'ఎరేస్' ఫంక్షన్ వాటి కీల ఆధారంగా మూలకాలను తీసివేయడానికి కీలకమైన సాధనంగా నిలుస్తుంది. 'std::map' అనేది కీలక-విలువ జతలను కలిగి ఉండే వ్యవస్థీకృత అనుబంధ కంటైనర్. “std::map”లోని మూలకాల అమరిక వాటి కీల ప్రకారం స్థిరంగా క్రమబద్ధీకరించబడుతుంది, కీలక విలువల ఆధారంగా శోధన, చొప్పించడం మరియు తొలగింపు వంటి ప్రభావవంతమైన కార్యకలాపాలను సులభతరం చేస్తుంది.
C++ పరిధిలో, “std::map::erase” ఫంక్షన్ “std::map” క్లాస్ యొక్క మెంబర్ ఫంక్షన్‌గా పనిచేస్తుంది, ఇది మ్యాప్ నుండి నిర్దిష్ట మూలకాలను తొలగించడాన్ని అనుమతిస్తుంది. ఇది వివిధ రూపాల్లో వస్తుంది, ఏ మూలకాలను తొలగించాలో పేర్కొనడంలో సౌలభ్యాన్ని అందిస్తుంది. ఈ కథనంలో, మేము 'std::map::erase' యొక్క వివరాలను పరిశీలిస్తాము, దాని బహుముఖ ప్రజ్ఞను వివరించడానికి అనేక ఉదాహరణలను అందజేస్తాము.
ఉదాహరణ 1: కీ ద్వారా ఎరేసింగ్
'std::map'లో కీ ద్వారా మూలకాలను తొలగించగల సామర్థ్యం C++ ప్రామాణిక టెంప్లేట్ లైబ్రరీ ద్వారా అందించబడిన ప్రాథమిక లక్షణం. మీరు ప్రోగ్రామ్‌లో కీ-విలువ జతలను నిర్వహించాల్సిన మరియు మార్చాల్సిన అవసరం వచ్చినప్పుడు ఈ ఆపరేషన్ సాధారణంగా ఉపయోగించబడుతుంది మరియు ఇది వాటి కీల ఆధారంగా నిర్దిష్ట అంశాలను తీసివేయడానికి అనుకూలమైన మార్గాన్ని అందిస్తుంది. మ్యాప్‌ను రూపొందించడానికి, కీ ద్వారా మూలకాన్ని చెరిపివేయడానికి, ఆపై సవరించిన మ్యాప్‌ను ప్రదర్శించడానికి “std::map”ని ఎలా ఉపయోగించాలో ప్రదర్శించడానికి మేము ఒక ఉదాహరణను సృష్టిస్తాము.
#
#
పూర్ణాంక ప్రధాన ( ) {
std:: మ్యాప్ < int, std:: స్ట్రింగ్ > myMap;
నా మ్యాప్ [ 1 ] = 'ఎరుపు' ;
నా మ్యాప్ [ 2 ] = 'నీలం' ;
నా మ్యాప్ [ 3 ] = 'ఆకుపచ్చ' ;
myMap.erase ( 2 ) ;
కోసం ( స్థిర ఆటో & జత: myMap ) {
std::cout << జత.మొదటి << ':' << జత.రెండవ << std::endl;
}
తిరిగి 0 ;
}
ఈ ఉదాహరణలో, ఇన్‌పుట్/అవుట్‌పుట్ కార్యకలాపాలను మరియు “std::map” కంటైనర్‌ను వరుసగా ఉపయోగించడాన్ని ప్రారంభించడానికి
మ్యాప్ యొక్క ఫలిత స్థితిని ప్రదర్శించడానికి, 'myMap'లోని ప్రతి కీ-విలువ జత ద్వారా పునరావృతమయ్యే 'కోసం' లూప్‌ను మేము ఉపయోగిస్తాము. మేము ప్రతి కీ-విలువ జతను కన్సోల్‌కు ప్రింట్ చేయడానికి లూప్ లోపల “std::cout” ఆబ్జెక్ట్‌ని ఉపయోగిస్తాము. చివరగా, 'రిటర్న్ 0' స్టేట్‌మెంట్ మా ప్రోగ్రామ్ యొక్క విజయవంతమైన అమలును సూచించే 'ప్రధాన' ఫంక్షన్‌ను ముగించింది.
కీ 2 ('నీలం')తో ఉన్న మూలకం తొలగించబడిన తర్వాత అవుట్‌పుట్ మిగిలిన కీ-విలువ జతలను 'std::map'లో ప్రదర్శిస్తుంది, దీని ఫలితంగా '1: Red' మరియు '3: Green' అవుట్‌పుట్ వస్తుంది.
ఉదాహరణ 2: ఇటరేటర్ ద్వారా ఎరేసింగ్
C++లో, ఇటరేటర్‌లు అనేది కంటైనర్‌లోని మూలకాల నావిగేషన్‌ను సులభతరం చేసే వస్తువులు, మూలకాలను యాక్సెస్ చేయడానికి, సవరించడానికి లేదా తీసివేయడానికి మార్గాలను అందిస్తాయి. మూలకాలను తీసివేయడానికి 'std::map::erase' ఫంక్షన్‌ని ఇటరేటర్‌లతో కూడా ఉపయోగించవచ్చు.
ఇక్కడ ఒక ఉదాహరణ:
##
పూర్ణాంక ప్రధాన ( ) {
std:: మ్యాప్ < int, std:: స్ట్రింగ్ > ఫ్రూట్ ఫోల్డర్;
ఫ్రూట్ ఫోల్డర్ [ 1 ] = 'మామిడి' ;
ఫ్రూట్ ఫోల్డర్ [ 2 ] = 'నారింజ' ;
ఫ్రూట్ ఫోల్డర్ [ 3 ] = 'అనాస పండు' ;
ఫ్రూట్ ఫోల్డర్ [ 4 ] = 'ద్రాక్ష' ;
auto it = fruitMap.find ( 2 ) ;
ఉంటే ( అది ! = fruitMap.end ( ) ) {
fruitMap.erase ( అది ) ;
}
కోసం ( స్థిర ఆటో & జత: పండ్ల పటం ) {
std::cout << జత.మొదటి << ':' << జత.రెండవ << std::endl;
}
తిరిగి 0 ;
}
అందించిన C++ కోడ్ కీ-విలువ జతలను నిల్వ చేయడానికి 'fruitMap' పేరుతో 'std::map'ని ప్రకటించడం ద్వారా ప్రారంభమవుతుంది, పూర్ణాంకాలను సంబంధిత పండ్ల పేర్లతో అనుబంధిస్తుంది. 'మామిడి', 'ఆరెంజ్', 'పైనాపిల్' మరియు 'గ్రేప్స్' అనే నాలుగు విభిన్న పండ్ల కోసం మేము మ్యాప్‌ను నమోదు చేస్తాము. ఆ తర్వాత, 'ఫ్రూట్‌మ్యాప్'లో 2 కీ విలువతో మూలకాన్ని సూచించే ఇటరేటర్ (ఇది) పొందేందుకు మేము 'కనుగొను' ఫంక్షన్‌ని ఉపయోగిస్తాము. ఆపై, పేర్కొన్న కీతో కూడిన మూలకం మ్యాప్‌లో ఉందని నిర్ధారించుకోవడానికి ఇటరేటర్ “ముగింపు()”కి సమానం కాదా అని మేము తనిఖీ చేస్తాము.
షరతులతో కూడిన బ్లాక్‌లో, 'ఎరేస్' ఫంక్షన్‌ని ఉపయోగించి 'ఇది' ఇటరేటర్ ద్వారా సూచించబడిన మూలకాన్ని మేము చెరిపివేస్తాము. చివరగా, మేము 'ఫర్' లూప్‌ని ఉపయోగించి సవరించిన 'ఫ్రూట్‌మ్యాప్'లోని మిగిలిన మూలకాల ద్వారా పునరావృతం చేస్తాము.
చివరి అవుట్‌పుట్ ఎరేజర్ తర్వాత సవరించిన “ఫ్రూట్‌మ్యాప్” కంటెంట్‌లను ప్రదర్శిస్తుంది.
ఉదాహరణ 3: పరిధిని చెరిపివేయడం
C++లోని “std::map” కంటైనర్ నిర్దిష్ట పరిధిలోని మూలకాలను తొలగించడానికి అనుకూలమైన పద్ధతిని అందిస్తుంది. తొలగించాల్సిన పరిధి యొక్క ప్రారంభం మరియు ముగింపును సూచించే ఇటరేటర్‌ల ఆధారంగా మ్యాప్ నుండి ఎలిమెంట్‌లను తీసివేయడానికి “ఎరేస్” ఫంక్షన్ మిమ్మల్ని అనుమతిస్తుంది.
ఇప్పుడు, ఒక ఉదాహరణతో 'std::map'ని ఉపయోగించి పరిధిని చెరిపివేసే భావనను అన్వేషిద్దాం:
##
పూర్ణాంక ప్రధాన ( ) {
std:: మ్యాప్ < int, std:: స్ట్రింగ్ > కొత్త మ్యాప్;
కొత్త మ్యాప్ [ 1 ] = 'గుర్రం' ;
కొత్త మ్యాప్ [ 2 ] = 'సింహం' ;
కొత్త మ్యాప్ [ 3 ] = 'పులి' ;
కొత్త మ్యాప్ [ 4 ] = 'పిల్లి' ;
newMap.erase ( newMap.lower_bound ( 2 ) , newMap.upper_bound ( 3 ) ) ;
కోసం ( స్థిర ఆటో & జత: కొత్త మ్యాప్ ) {
std::cout << జత.మొదటి << ':' << జత.రెండవ << std::endl;
}
తిరిగి 0 ;
}
పూర్ణాంక కీలను సంబంధిత స్ట్రింగ్ విలువలతో అనుబంధించే “న్యూమ్యాప్” పేరుతో “std::map”ని ప్రకటించడం ద్వారా ప్రోగ్రామ్ ప్రారంభమవుతుంది. ఆ తర్వాత, మేము స్క్వేర్ బ్రాకెట్ ఆపరేటర్‌ని ఉపయోగించి కీ-విలువ జతలతో మ్యాప్‌ను నింపుతాము. ఉదాహరణకు, మేము (1, “గుర్రం”), (2, “సింహం”), (3, “పులి”), మరియు (4, “పిల్లి”) యొక్క కీ-విలువ జతలను “న్యూ మ్యాప్”కి కేటాయిస్తాము.
తదుపరి ముఖ్యమైన ఆపరేషన్ మ్యాప్ నుండి ఎలిమెంట్‌లను చెరిపివేయడానికి ఇటరేటర్‌లను ఉపయోగించడం. ఎరేస్ ఫంక్షన్ “newMap.lower_bound(2)” మరియు “newMap.upper_bound(3)” ఆర్గ్యుమెంట్‌లతో ఉపయోగించబడుతుంది. ఇది (2, 3) పరిధిలోకి వచ్చే కీలతో మూలకాలను తొలగిస్తుంది. మరో మాటలో చెప్పాలంటే, ఇది మ్యాప్ నుండి 'లయన్' మరియు 'టైగర్' ఎంట్రీలను తొలగిస్తుంది. ఈ ఆపరేషన్ తర్వాత, మ్యాప్‌లో “గుర్రం” మరియు “పిల్లి” లకు సంబంధించిన 1 మరియు 4 కీలతో కూడిన అంశాలు మాత్రమే ఉంటాయి.
చివరగా, మ్యాప్‌లోని మిగిలిన మూలకాల ద్వారా పునరావృతం చేయడానికి మరియు వాటి కీ-విలువ జతలను కన్సోల్‌కు ప్రింట్ చేయడానికి మేము పరిధి-ఆధారిత “ఫర్” లూప్‌ను ఉపయోగిస్తాము.
ఫలితంగా, అవుట్‌పుట్ క్రింది వాటిని ప్రదర్శిస్తుంది:
ఉదాహరణ 4: ప్రిడికేట్ ఆధారంగా ఎరేసింగ్
ప్రిడికేట్ ఆధారంగా ఎరేసింగ్ అనేది నిర్దిష్ట షరతు లేదా ప్రమాణాల ఆధారంగా కంటైనర్ వంటి డేటా నిర్మాణం నుండి మూలకాలను తీసివేయడాన్ని సూచిస్తుంది. మూలకాలను షరతులతో తొలగించడానికి 'std::map::erase'ని ప్రిడికేట్ ఫంక్షన్‌తో కూడా ఉపయోగించవచ్చు. కింది ఉదాహరణను పరిశీలిద్దాం:
##
#
పూర్ణాంక ప్రధాన ( ) {
std:: మ్యాప్ < int, std:: స్ట్రింగ్ > myMap = {
{ 1 , 'జనవరి' } ,
{ 2 , 'ఫిబ్రవరి' } ,
{ 3 , 'మార్చి' } ,
{ 4 , 'ఏప్రిల్' } ,
{ 5 , 'మే' }
} ;
ఆటో ప్రిడికేట్ = [ ] ( const std:: జత < int, std:: స్ట్రింగ్ >& మూలకం ) {
తిరిగి మూలకం.రెండవ.పొడవు ( ) < 5 ;
} ;
myMap.erase ( std::remove_if ( myMap.begin ( ) , myMap.end ( ) , ఊహించండి ) , myMap.end ( ) ) ;
std::cout << ' \n ప్రిడికేట్ ఆధారంగా మూలకాలను తొలగించిన తర్వాత మ్యాప్:' << std::endl;
కోసం ( స్థిర ఆటో & జత: myMap ) {
std::cout << జత.మొదటి << ':' << జత.రెండవ << std::endl;
}
తిరిగి 0 ;
}
అవసరమైన హెడర్ ఫైల్‌లను చేర్చడం ద్వారా ప్రోగ్రామ్ ప్రారంభమవుతుంది. “myMap” అని పిలువబడే “std::map” ప్రకటించబడింది మరియు “ప్రధాన” ఫంక్షన్‌లో ప్రారంభించబడింది. ఇది నెలల పేర్లు మరియు వాటి సంబంధిత సంఖ్యా విలువలను సూచించే కీ-విలువ జతలను కలిగి ఉంటుంది. తదనంతరం, 'లాంబ్డా' ఫంక్షన్ (ప్రిడికేట్) నిర్వచించబడింది. ఈ “లాంబ్డా” ఫంక్షన్ “std::remove_if” అల్గారిథమ్‌కు సూచనగా పనిచేస్తుంది. మ్యాప్ మూలకంతో అనుబంధించబడిన స్ట్రింగ్ విలువ యొక్క పొడవు ఐదు అక్షరాల కంటే తక్కువగా ఉందో లేదో ఇది ధృవీకరిస్తుంది.
'std::remove_if' అల్గోరిథం అప్పుడు 'std::map' యొక్క 'ఎరేస్' ఫంక్షన్‌తో కలిపి ఉపయోగించబడుతుంది. ఈ కలయిక ప్రిడికేట్ యొక్క ప్రామాణికత ఆధారంగా మ్యాప్ నుండి మూలకాలను తొలగిస్తుంది.
ప్రోగ్రామ్‌ని అమలు చేసిన తర్వాత, 'std::map'ని ఉపయోగించి ప్రిడికేట్ ఆధారంగా చెరిపివేయడాన్ని ప్రదర్శిస్తూ, అసలు మ్యాప్ నుండి ఐదు కంటే తక్కువ కీలు ఉన్న మూలకాలు తీసివేయబడతాయి.
ముగింపు
ముగింపులో, “std::map::erase” ఫంక్షన్ అనేది “std::map” నుండి మూలకాలను తీసివేయడానికి C++లో బహుముఖ సాధనం. కీ, ఇటరేటర్, రేంజ్ లేదా ప్రిడికేట్ ఆధారంగా చెరిపివేసినా, “std::map::erase” ఫంక్షన్ సౌలభ్యం మరియు వాడుకలో సౌలభ్యాన్ని అందిస్తుంది. ఈ ఫంక్షన్‌ను మాస్టరింగ్ చేయడం ద్వారా, C++ డెవలపర్‌లు 'std::map'కంటెయినర్‌లలో డేటాను సమర్థవంతంగా నిర్వహించగలరు మరియు మార్చగలరు, తద్వారా వారి కోడ్‌ను మరింత బలంగా మరియు సులభంగా నిర్వహించగలుగుతారు.