C ++ లో మ్యాప్‌పై మళ్ళించడానికి అనేక మార్గాలు ఉన్నాయి. C ++ యొక్క కొత్త వెర్షన్‌లతో, C ++ లో మ్యాప్‌పై పునరుద్ఘాటించడానికి మరింత అధునాతన మార్గాలు ఉన్నాయి.
ఒక్కొక్కటిగా వెళ్దాం.
Stp :: మ్యాప్‌తో లూప్ కోసం ఉపయోగించడం
మేము | _+_ | అనే మ్యాప్‌ను సృష్టించాము మరియు దానికి కీ-విలువ జతలను చేర్చారు.
<కోసం>
#చేర్చండి
#చేర్చండి
#చేర్చండి
#చేర్చండి
#చేర్చండి
ఉపయోగించి నేమ్‌స్పేస్గంటలు;
intప్రధాన() {
// మ్యాప్‌ని ప్రారంభించండి
మ్యాప్>'భారతదేశం','ఢిల్లీ'));
కంట్రీ క్యాపిటల్ మ్యాప్.చొప్పించు(జత<స్ట్రింగ్, స్ట్రింగ్>('నేపాల్','ఖాట్మండు'));
కంట్రీ క్యాపిటల్ మ్యాప్.చొప్పించు(జత<స్ట్రింగ్, స్ట్రింగ్>('చైనా','బీజింగ్'));
కంట్రీ క్యాపిటల్ మ్యాప్.చొప్పించు(జత<స్ట్రింగ్, స్ట్రింగ్>('ఫ్రాన్స్','పారిస్'));
// లూప్ కోసం ఇట్రేటర్‌ని ఉపయోగించడం
కోసం (దానంతట అదేitr=కంట్రీ క్యాపిటల్ మ్యాప్.ప్రారంభించండి();itr!=కంట్రీ క్యాపిటల్ మ్యాప్.ముగింపు();itr++)
{
గంటలు::ఖరీదు <<itr->ప్రధమ// యాక్సెస్ కీ
<< ':'
<<itr->రెండవ// యాక్సెస్ విలువ
<<గంటలు::endl;
}
తిరిగి 0;
}
</కోసం>
అవుట్‌పుట్:
<కోసం>
చైనా:బీజింగ్
ఫ్రాన్స్:పారిస్
భారతదేశం:ఢిల్లీ
నేపాల్:ఖాట్మండు
</కోసం>
మీరు గమనిస్తే, మేము లూప్ కోసం ఉపయోగించే దేశం: రాజధాని (కీ: విలువ) ముద్రించాము.
మీరు గమనిస్తే, మేము ఉపయోగించాము | _+_ | చదవగలిగే కారణంగా మ్యాప్ ఇరేటర్ కోసం టైప్ స్పెసిఫైయర్. మీరు | _+_ | ఉపయోగించవచ్చు స్పష్టంగా అలాగే.
గమనిక: మీరు అవుట్‌పుట్‌ను చూసినట్లయితే, అది కీలను ఆరోహణ క్రమంలో క్రమబద్ధీకరిస్తుంది. దీనికి కారణం std :: మ్యాప్ అనేది సప్లైడ్ కంపారిటర్ (వెర్షన్ C ++ 11 తరువాత) తో క్రమబద్ధీకరించబడిన అసోసియేటివ్ కంటైనర్. మేము ఏ పోలికను అందించనందున, C ++ స్ట్రింగ్ కోసం డిఫాల్ట్ కంపారిటర్‌ని ఉపయోగించింది.
Stp :: మ్యాప్‌తో ఉండగా లూప్‌ను ఉపయోగించడం
మనం లూప్‌కు బదులుగా కాసేపు లూప్‌ను కూడా ఉపయోగించవచ్చు.
<కోసం>
#చేర్చండి
#చేర్చండి
#చేర్చండి
#చేర్చండి>
ఉపయోగించి నేమ్‌స్పేస్గంటలు;
intప్రధాన() {
// మ్యాప్‌ని ప్రారంభించండి
మ్యాప్<స్ట్రింగ్, స్ట్రింగ్>కంట్రీ క్యాపిటల్ మ్యాప్;
// మ్యాప్‌లో విభిన్న అంశాలను చొప్పించండి
కంట్రీ క్యాపిటల్ మ్యాప్.చొప్పించు(జత<స్ట్రింగ్, స్ట్రింగ్>('భారతదేశం','ఢిల్లీ'));
కంట్రీ క్యాపిటల్ మ్యాప్.చొప్పించు(జత<స్ట్రింగ్, స్ట్రింగ్>('నేపాల్','ఖాట్మండు'));
కంట్రీ క్యాపిటల్ మ్యాప్.చొప్పించు(జత<స్ట్రింగ్, స్ట్రింగ్>('చైనా','బీజింగ్'));
కంట్రీ క్యాపిటల్ మ్యాప్.చొప్పించు(జత<స్ట్రింగ్, స్ట్రింగ్>('ఫ్రాన్స్','పారిస్'));
// మ్యాప్ కోసం ఇటరేటర్‌ను సృష్టించండి మరియు ప్రారంభంతో ప్రారంభించండి
దానంతట అదేitr=కంట్రీ క్యాపిటల్ మ్యాప్.ప్రారంభించండి();
// అయితే లూప్‌లో ఇటరేటర్‌ని ఉపయోగించడం
అయితే (itr!=కంట్రీ క్యాపిటల్ మ్యాప్.ముగింపు())
{
గంటలు::ఖరీదు <<itr->ప్రధమ// యాక్సెస్ కీ
<< ':'
<<itr->రెండవ// యాక్సెస్ విలువ
<<గంటలు::endl;
itr++;
}
తిరిగి 0;
}
</కోసం>
అవుట్‌పుట్:
<కోసం>
చైనా:బీజింగ్
ఫ్రాన్స్:పారిస్
భారతదేశం:ఢిల్లీ
నేపాల్:ఖాట్మండు
</కోసం>
లూప్ (C ++ 11 వెర్షన్ తరువాత) కోసం రేంజ్ ఆధారంగా
మీరు C ++ 11 వెర్షన్‌ని ఉపయోగిస్తుంటే, C ++ లో మ్యాప్ ద్వారా మళ్లీ చెప్పడానికి ఇది చాలా సొగసైన మార్గం. మీరు సాంప్రదాయ క్యూబర్‌సోమ్ లూప్‌లను నివారించవచ్చు మరియు బదులుగా దీనిని ఉపయోగించవచ్చు.
<కోసం>#చేర్చండి
#చేర్చండి
#చేర్చండి
ఉపయోగించి నేమ్‌స్పేస్గంటలు;
intప్రధాన() {
// మ్యాప్‌ని ప్రారంభించండి
మ్యాప్<స్ట్రింగ్, స్ట్రింగ్>కంట్రీ క్యాపిటల్ మ్యాప్;
// మ్యాప్‌లో విభిన్న అంశాలను చొప్పించండి
కంట్రీ క్యాపిటల్ మ్యాప్.చొప్పించు(జత<స్ట్రింగ్, స్ట్రింగ్>('భారతదేశం','ఢిల్లీ'));
కంట్రీ క్యాపిటల్ మ్యాప్.చొప్పించు(జత<స్ట్రింగ్, స్ట్రింగ్>('నేపాల్','ఖాట్మండు'));
కంట్రీ క్యాపిటల్ మ్యాప్.చొప్పించు(జత<స్ట్రింగ్, స్ట్రింగ్>('చైనా','బీజింగ్'));
కంట్రీ క్యాపిటల్ మ్యాప్.చొప్పించు(జత<స్ట్రింగ్, స్ట్రింగ్>('ఫ్రాన్స్','పారిస్'));
// లూప్ కోసం ఇట్రేటర్‌ని ఉపయోగించడం
కోసం (కానిస్టేట్ దానంతట అదే &అతను:కంట్రీ క్యాపిటల్ మ్యాప్) {
ఖరీదు <<అతను.ప్రధమ << ':' <<అతను.రెండవ<<' n';
}
తిరిగి 0;
}
</కోసం>
అవుట్‌పుట్:
చైనా:బీజింగ్
ఫ్రాన్స్:పారిస్
భారతదేశం:ఢిల్లీ
నేపాల్:ఖాట్మండు
కీ-వాల్యూస్ పెయిర్‌లతో లూప్ కోసం రేంజ్-బేస్డ్ ఉపయోగించడం (C ++ 17 వెర్షన్ తరువాత)
ఈ వెర్షన్‌కు c ++ 17 నుండి మద్దతు ఉంది మరియు మ్యాప్‌లో పునరుద్ఘాటించడానికి మరింత సరళమైన మార్గాన్ని అందిస్తుంది. మ్యాప్‌లో మీరు కీ-వాల్యూస్ జతని స్పష్టంగా యాక్సెస్ చేయవచ్చు, ఇది మరింత చదవగలిగే పరిష్కారాన్ని అందిస్తుంది.
<కోసం>#చేర్చండి
#చేర్చండి
#చేర్చండి
ఉపయోగించి నేమ్‌స్పేస్గంటలు;
intప్రధాన() {
// మ్యాప్‌ని ప్రారంభించండి
మ్యాప్<స్ట్రింగ్, స్ట్రింగ్>కంట్రీ క్యాపిటల్ మ్యాప్;
// మ్యాప్‌లో విభిన్న అంశాలను చొప్పించండి
కంట్రీ క్యాపిటల్ మ్యాప్.చొప్పించు(జత<స్ట్రింగ్, స్ట్రింగ్>('భారతదేశం','ఢిల్లీ'));
కంట్రీ క్యాపిటల్ మ్యాప్.చొప్పించు(జత<స్ట్రింగ్, స్ట్రింగ్>('నేపాల్','ఖాట్మండు'));
కంట్రీ క్యాపిటల్ మ్యాప్.చొప్పించు(జత<స్ట్రింగ్, స్ట్రింగ్>('చైనా','బీజింగ్'));
కంట్రీ క్యాపిటల్ మ్యాప్.చొప్పించు(జత<స్ట్రింగ్, స్ట్రింగ్>('ఫ్రాన్స్','పారిస్'));
// లూప్ కోసం ఇట్రేటర్‌ని ఉపయోగించడం
కోసం (కానిస్టేట్ దానంతట అదే& [కీ, విలువ] :కంట్రీ క్యాపిటల్ మ్యాప్) {
ఖరీదు <<కీ<< ':' <<విలువ<< ' n';
}
తిరిగి 0;
}
</కోసం>
అవుట్‌పుట్:
చైనా:బీజింగ్
ఫ్రాన్స్:పారిస్
భారతదేశం:ఢిల్లీ
నేపాల్:ఖాట్మండు
C ++ లో మ్యాప్‌పై ఎలా మళ్లించాలో అంతే. హ్యాపీ కోడింగ్!