C++ STL లైబ్రరీ మాకు మ్యాప్ క్లాస్‌ని అందిస్తుంది. మ్యాప్‌లను అనుబంధ కంటైనర్‌లుగా పరిగణిస్తారు, ఇవి ఆర్డర్ చేసిన కీలక విలువలు మరియు మ్యాప్ చేయబడిన విలువల జతలో వస్తువులను ఉంచుతాయి. ఒకే కీ విలువతో రెండు మ్యాప్ చేయబడిన విలువలు ఎప్పుడూ ఉండకూడదు. మ్యాప్ క్లాస్ అనేక విధులను అందిస్తుంది కానీ ఇక్కడ మనం చర్చిస్తాము map.at() ఫంక్షన్. కీ విలువకు మ్యాప్ చేయబడిన మూలకం ఫంక్షన్ యొక్క పారామీటర్‌గా పంపబడుతుంది, అది ఉపయోగించి సూచించబడుతుంది map.at() ఫంక్షన్. మేము కంటైనర్ పరిధిలో లేని మూలకాన్ని పొందడానికి ప్రయత్నించినప్పుడు, ది map.at() ఫంక్షన్ కంటైనర్ పరిధిని అంచనా వేస్తుంది మరియు మినహాయింపును అందిస్తుంది.
map.at() ఫంక్షన్ యొక్క సింటాక్స్
C++లో map.at() ఫంక్షన్‌ని అమలు చేయడానికి మేము దిగువ వాక్యనిర్మాణాన్ని అనుసరించాలి.
Map_variable.at ( కీ / విలువ జత )
మేము 'Map_variable' పేరుతో ఉన్న మ్యాప్ ఆబ్జెక్ట్‌ని ఉపయోగించాము వద్ద() ఫంక్షన్. ఇది నేరుగా సూచించబడిన మూలకాన్ని తిరిగి అందిస్తుంది మరియు పేర్కొన్న కీ విలువను సూచిస్తుంది. డేటా కీ మ్యాప్ ఎక్కువగా మ్యాప్ పరిధిపై ఆధారపడి ఉంటుంది. అది కాకపోతే, నిర్వచించిన పరిధికి మించి విలువ ఉందని సూచించే అమలు సమయంలో మినహాయింపు లేదా లోపం తిరిగి వచ్చే అవకాశం ఉంది. ఇప్పుడు, మేము ఈ సింటాక్స్‌ని C++ కోడ్‌లలో ఇది పని చేస్తుందని చూపడానికి ఉపయోగిస్తాము.
ఉదాహరణ 1: map.at() ఫంక్షన్‌ని ఉపయోగించడం
map.at ఫంక్షన్‌ని ప్రదర్శించడానికి ప్రోగ్రామ్ అమలు చేయబడుతుంది. మేము లింక్ చేసాము వద్ద() తో ఫంక్షన్ మ్యాప్() కొన్ని ఇన్‌పుట్ విలువలను తీసుకొని దాని కార్యాచరణను చూపే ఫంక్షన్. దీని కోసం, మేము c++ కోసం అవసరమైన మరొక మాడ్యూల్‌తో మ్యాప్ మాడ్యూల్‌ను దిగుమతి చేయడం ద్వారా ప్రోగ్రామ్ యొక్క హెడర్ విభాగాన్ని పూరించాము. అప్పుడు, మేము పిలిచాము ప్రధాన () మ్యాప్ క్లాస్ నుండి మ్యాప్ డిక్లరేషన్ కోసం ఫంక్షన్. మ్యాప్ యొక్క వస్తువు 'MyMap'గా లేబుల్ చేయబడింది. మేము మ్యాప్ కీ మరియు విలువను ఇవ్వడం ద్వారా మ్యాప్‌ల జాబితాను సృష్టిస్తాము.
దీని తరువాత, మేము ఆజ్ఞాపించాము map.at() పేర్కొన్న స్ట్రింగ్‌ను పూర్ణాంకానికి మ్యాప్ చేసే ఫంక్షన్. అప్పుడు, మేము ఫలితాలను ముద్రించాము map.at() for loop నుండి ఫంక్షన్. ఫర్ లూప్ “ఆటో” కీవర్డ్ సూచనను ఉపయోగిస్తుంది. ఇనిషియలైజర్ డిక్లేర్ చేయబడిన దాని నుండి వేరియబుల్ రకాన్ని స్వయంచాలకంగా తీసివేస్తుందని ఆటో కీవర్డ్ సూచిస్తుంది. కౌట్ స్టేట్‌మెంట్ నుండి తిరిగి వచ్చే క్రమంలో జతలను ప్రింట్ చేస్తుంది map.at() ఫంక్షన్.
##
#
పూర్ణాంక ప్రధాన ( )
std: : మ్యాప్ < std::string,int > MyMap = {
{ 'యాపిల్', 0 } ,
{ 'ద్రాక్ష' , 0 } ,
{ 'మామిడి పండ్లు' , 0 } }
MyMap.at ( 'యాపిల్' ) = 5 ;
MyMap.at ( 'ద్రాక్ష' ) = 10 ;
MyMap.at ( 'మామిడి పండ్లు' ) = 6 ;
కోసం ( దానంతట అదే & m: MyMap ) {
std::cout << m.మొదటి << ':' << మీ.సెకండ్ << '\n' ; }
< బలమైన > తిరిగి 0 ;
}
ఇప్పుడు, మేము అమలు చేసే పై ప్రోగ్రామ్ నుండి ఫలితాలను కలిగి ఉన్నాము map.at() ఫంక్షన్. పరిధిలో ఉన్న అన్ని పేర్కొన్న పూర్ణాంకాలు ప్రతి స్ట్రింగ్‌కు వ్యతిరేకంగా ప్రదర్శించబడతాయి.
ఉదాహరణ 2: out_of_range మినహాయింపు కోసం map.at() ఫంక్షన్‌ని ఉపయోగించడం
యొక్క ఉపయోగం గురించి మేము ఒక ఉదాహరణ ప్రోగ్రామ్ ద్వారా చర్చించాము map.at C++లో ఫంక్షన్. ఇప్పుడు, మేము మరొకటి అమలు చేసాము map.at కార్యక్రమంలో. కానీ ఈసారి అది మ్యాప్‌లో ప్రదర్శించబడిన విలువను మరియు కీ పేర్కొనబడనప్పుడు out_of_range మినహాయింపును కూడా అందిస్తుంది. మనం ఉపయోగించుకోవాలి కాబట్టి map.at ఫంక్షన్, కాబట్టి మేము మ్యాప్ మాడ్యూల్‌ను హెడర్‌లో జోడించాము. అప్పుడు, 'శూన్యం' పరామితిగా పాస్ చేయబడిన ప్రధాన విధిని మేము నిర్వచించాము.
ప్రధాన ఫంక్షన్ లోపల, మేము మ్యాప్ ఆబ్జెక్ట్‌ను “m1”గా సృష్టించడం ద్వారా జాబితా కన్స్ట్రక్టర్‌ను ప్రారంభించాము. మ్యాప్ జాబితాలో వివిధ రకాల కీలు మరియు వాటికి వ్యతిరేకంగా పూర్ణాంక విలువలు ఉన్నాయి. అప్పుడు, మేము 'i' కీని పాస్ చేయడం ద్వారా ముద్రించాము map.at ఫంక్షన్. మేము ట్రై-క్యాచ్ బ్లాక్‌ని ఉపయోగించాము. ప్రయత్నించండి బ్లాక్‌లో, మేము ఉనికిలో లేని కీని అందించాము map.at ఫంక్షన్. కీ పరిధి వెలుపల ఉన్నందున, ప్రయత్నించండి బ్లాక్ లోపాన్ని విసిరివేస్తుంది.
##
నేమ్‌స్పేస్ stdని ఉపయోగించడం;
పూర్ణాంక ప్రధాన ( శూన్యం ) {
పటం < చార్, Int > m1 = {
{ 'l' , 1 } ,
{ 'నేను' , రెండు } ,
{ 'n' , 3 } ,
{ 'లో' , 4 } ,
{ 'x' , 5 } ,
} ;
కోట్ << 'మ్యాప్ కీ విలువ m1['i'] = ' << m1.at ( 'నేను' ) << endl;
ప్రయత్నించండి {
m1.at ( 'వై' ) ;
} క్యాచ్ ( పరిధి_ఆఫ్_రేంజ్ & మరియు ) {
cerr << 'లో లోపం' << ఇ.ఏమి ( ) << endl;
}
తిరిగి 0 ;
}
మేము అవుట్‌పుట్ స్క్రీన్‌షాట్ నుండి దృశ్యమానం చేయవచ్చు map.at() ఫంక్షన్ మ్యాప్‌లో ఉన్న కీలను మాత్రమే అందిస్తుంది. మేము 'y' కీని పాస్ చేసినప్పుడు లోపం ప్రదర్శించబడినందున పరిధి వెలుపల కీలు లోపాన్ని విసురుతాయి map.at ఫంక్షన్.
ఉదాహరణ 3: ఎలిమెంట్‌లను యాక్సెస్ చేయడానికి map.at() ఫంక్షన్‌ని ఉపయోగించడం
map.at ఫంక్షన్ నుండి అంకెల యొక్క పేర్కొన్న మూలకాన్ని ఉపయోగించి ఒక మూలకాన్ని యాక్సెస్ చేయవచ్చు. పై ప్రకటనను నెరవేర్చడానికి ఈ కార్యక్రమాన్ని అమలు చేద్దాం. మేము మ్యాప్ మాడ్యూల్‌ని మొదట హెడర్ విభాగంలో నిర్వచించాము, ఎందుకంటే ఇది యాక్సెస్ చేయడానికి అవసరం map.at ఫంక్షన్. అప్పుడు, మ్యాప్ క్లాస్ మ్యాప్ ఆబ్జెక్ట్‌ను “మ్యాప్”గా ప్రారంభించిన ప్రధాన విధిని మేము కలిగి ఉన్నాము. ఈ “మ్యాప్” ఆబ్జెక్ట్‌తో, మేము స్ట్రింగ్‌ల కీలను రూపొందించాము మరియు వాటికి అంకెల విలువను కేటాయించాము. ఆ తరువాత, మేము కాల్ చేసాము map.at కౌట్ స్టేట్‌మెంట్‌తో ఒక ఫంక్షన్ మరియు 'ఉదాహరణ' కీని ఇన్‌పుట్‌గా ఆమోదించింది.
##
#
నేమ్‌స్పేస్ stdని ఉపయోగించడం;
పూర్ణాంక ప్రధాన ( )
{
పటం < స్ట్రింగ్, Int > మ్యాప్;
మ్యాప్ [ 'నా' ] = 1 ;
మ్యాప్ [ 'c++' ] = రెండు ;
మ్యాప్ [ 'మ్యాప్' ] = 3 ;
మ్యాప్ [ 'ఉదాహరణ' ] = 4 ;
కోట్ << Map.at ( 'ఉదాహరణ' ) ;
తిరిగి 0 ;
}
లో పేర్కొన్న కీకి వ్యతిరేకంగా అంకెల మూలకం అందించబడుతుంది map.at ఫంక్షన్. ఈ అంకె మ్యాప్ యొక్క ముఖ్య మూలకం 'ఉదాహరణ'కి కేటాయించబడినందున ఫలితం '4' విలువను ఇస్తుంది.
ఉదాహరణ 4: ఎలిమెంట్‌లను సవరించడం కోసం map.at() ఫంక్షన్‌ని ఉపయోగించడం
కీ విలువతో అనుబంధించబడిన విలువను సవరించడానికి ఒక సాధారణ ఉదాహరణను పరిశీలిద్దాం. మేము మ్యాప్ క్లాస్‌కి కాల్ చేసి, “M1” ఆబ్జెక్ట్‌ని సృష్టించడం ద్వారా మ్యాప్ జాబితాను సృష్టించాము. మేము మ్యాప్ యొక్క ప్రతి కీకి వ్యతిరేకంగా స్ట్రింగ్ విలువను కేటాయించాము. అప్పుడు, మనం ఉపయోగించుకోవాలి map.at ఫంక్షన్. లో map.at ఫంక్షన్, మేము పేర్కొన్న కీలను ఉపయోగించాము మరియు ఆ కీలకు వ్యతిరేకంగా కొత్త స్ట్రింగ్ విలువలను కేటాయించాము. ఇప్పుడు, ఈ విలువలు మునుపటి దానితో సవరించబడతాయి. ఫర్ లూప్ సహాయంతో, మేము మ్యాప్ నుండి ప్రతి మూలకాన్ని పునరావృతం చేసాము మరియు దానిని అవుట్‌పుట్‌గా ప్రదర్శించాము.
##
#
నేమ్‌స్పేస్ stdని ఉపయోగించడం;
పూర్ణాంక ప్రధాన ( )
{
పటం < int, స్ట్రింగ్ > M1 = {
{ 10 , 'c++' } ,
{ ఇరవై , 'జావా' } ,
{ 30 , 'కొండచిలువ' } ,
{ 40 , 'csharp' } ,
{ యాభై , 'ఓపెన్' } } ;
M1.at ( ఇరవై ) = 'టెన్సర్‌ఫ్లో' ;
M1.at ( 30 ) = 'Linux' ;
M1.at ( యాభై ) = 'స్కాలా' ;
కోట్ << ' \n మూలకాలు:' << endl;
కోసం ( దానంతట అదే & x: M1 ) {
కోట్ << x.మొదట << ':' << x.సెకండ్ << '\n' ;
}
తిరిగి 0 ;
}
అవుట్‌పుట్‌గా పొందిన విలువలు కొత్తగా కేటాయించిన స్ట్రింగ్ విలువలను సవరించాయని గమనించండి map.at ఫంక్షన్. నవీకరించబడిన విలువలు దిగువ స్నాప్‌షాట్‌లో చూపబడ్డాయి.
ముగింపు
వ్యాసం map.at ఫంక్షన్ గురించి. మేము map.at() ఫంక్షన్ యొక్క కార్యాచరణను దాని సింటాక్స్ ద్వారా అందించాము మరియు ఉదాహరణ C++ కంపైలర్‌తో అమలు చేయబడుతుంది. map.at() ఫంక్షన్ ఎలిమెంట్ యాక్సెసిబిలిటీని అనుమతిస్తుంది మరియు పద్ధతిని పిలుస్తున్నప్పుడు తలెత్తిన పరిస్థితిని వివరించే స్పష్టమైన మినహాయింపు లేదా లోపాన్ని అందిస్తుంది కాబట్టి ఇది చాలా ఉపయోగకరంగా ఉంటుంది. ఇంకా, మేము map.at ఫంక్షన్ ద్వారా ఉనికి కీకి వ్యతిరేకంగా కొత్త విలువలను కేటాయించవచ్చు.