తరగతి మరియు వస్తువులు
క్లాస్ అనేది వేరియబుల్స్ మరియు ఫంక్షన్ల సమిష్టిగా పనిచేస్తుంది, ఇక్కడ వేరియబుల్స్ కేటాయించిన విలువలు లేవు. వేరియబుల్స్‌కు విలువలు కేటాయించినప్పుడు, తరగతి ఒక వస్తువు అవుతుంది. ఒకే తరగతికి ఇచ్చిన విభిన్న విలువలు వేర్వేరు వస్తువులను కలిగిస్తాయి; అంటే, విభిన్న వస్తువులు ఒకే విలువ కలిగిన ఒకే తరగతి. తరగతి నుండి ఒక వస్తువును సృష్టించడం ఆ వస్తువును తక్షణం చెప్పడం.
పేరు, క్రమరహిత_మ్యాప్, ఒక తరగతి. ఆర్డర్ చేయని_మ్యాప్ క్లాస్ నుండి సృష్టించబడిన ఒక ఆబ్జెక్ట్ ప్రోగ్రామర్ ఎంచుకున్న పేరును కలిగి ఉంది.
తరగతికి చెందిన ఒక వస్తువును తరగతి నుండి తక్షణం అమలు చేయడానికి అవసరం. C ++ లో, ఆ ఫంక్షన్ క్లాస్ పేరు వలె అదే పేరును కలిగి ఉంటుంది. తరగతి నుండి సృష్టించబడిన (తక్షణం) ఆబ్జెక్ట్‌లు ప్రోగ్రామర్ ద్వారా వారికి వేర్వేరు పేర్లు ఇవ్వబడ్డాయి.
తరగతి నుండి ఒక వస్తువును సృష్టించడం అంటే వస్తువును నిర్మించడం; ఇది తక్షణం అని కూడా అర్థం.
క్రమరహిత_మ్యాప్ క్లాస్‌ని ఉపయోగించే C ++ ప్రోగ్రామ్, ఫైల్ ఎగువన కింది పంక్తులతో మొదలవుతుంది:
#చేర్చండి#చేర్చండి
నేమ్‌స్పేస్ std ని ఉపయోగిస్తోంది;
మొదటి లైన్ ఇన్‌పుట్/అవుట్‌పుట్ కోసం. రెండవ లైన్ ప్రోగ్రామ్‌ను క్రమం లేని_మ్యాప్ క్లాస్ యొక్క అన్ని ఫీచర్‌లను ఉపయోగించడానికి అనుమతించడం. మూడవ పంక్తి ప్రామాణిక నేమ్‌స్పేస్‌లోని పేర్లను ఉపయోగించడానికి ప్రోగ్రామ్‌ను అనుమతిస్తుంది.
ఫంక్షన్‌ని ఓవర్‌లోడ్ చేస్తోంది
రెండు లేదా అంతకంటే ఎక్కువ విభిన్న ఫంక్షన్ సంతకాలు ఒకే పేరును కలిగి ఉన్నప్పుడు, ఆ పేరు ఓవర్‌లోడ్ చేయబడిందని చెప్పబడింది. ఒక ఫంక్షన్ అని పిలవబడినప్పుడు, ఆర్గ్యుమెంట్‌ల సంఖ్య మరియు రకం, వాస్తవానికి ఏ ఫంక్షన్ అమలు చేయబడుతుందో నిర్ణయించండి.
నిర్మాణం/కాపీ నిర్మాణం
సాధారణ నిర్మాణం
క్రమబద్ధీకరించని మ్యాప్‌ను ఈ క్రింది విధంగా నిర్మించవచ్చు మరియు విలువలను కేటాయించవచ్చు:
క్రమం లేని_మ్యాప్<కానిస్టేట్ చార్*, కానిస్టేట్ చార్*>umap;umap['అరటి'] = 'పసుపు';
umap['ద్రాక్ష'] = 'ఆకుపచ్చ';
umap['అత్తి'] = 'ఊదా';
కీ మరియు విలువ జతలకు సంబంధించిన రకాలతో టెంప్లేట్ స్పెషలైజేషన్‌తో డిక్లరేషన్ ప్రారంభమవుతుంది. మ్యాప్ కోసం ప్రోగ్రామర్ ఎంచుకున్న పేరు దీని తరువాత ఉంటుంది; అప్పుడు సెమికోలన్. రెండవ కోడ్ విభాగం వారి కీలకు విలువలను ఎలా కేటాయించాలో చూపుతుంది.
ఇనిషియలైజర్_లిస్ట్ ద్వారా నిర్మాణం
దీనిని ఈ క్రింది విధంగా చేయవచ్చు:
{'ద్రాక్ష', 'ఆకుపచ్చ'}, {'అత్తి', 'ఊదా'}});
ఇనిషియలైజర్_లిస్ట్ కేటాయించడం ద్వారా నిర్మాణం
ఉదాహరణ:
{'ద్రాక్ష', 'ఆకుపచ్చ'}, {'అత్తి', 'ఊదా'}};
మరొక క్రమరహిత_మ్యాప్‌ను కాపీ చేయడం ద్వారా నిర్మాణం
ఉదాహరణ:
{'ద్రాక్ష', 'ఆకుపచ్చ'}, {'అత్తి', 'ఊదా'}});
క్రమం లేని_మ్యాప్<కానిస్టేట్ చార్*, కానిస్టేట్ చార్*>umap2(umap1);
జత మూలకం
కింది కోడ్ జత మూలకాన్ని ఎలా సృష్టించాలో మరియు యాక్సెస్ చేయాలో చూపుతుంది:
జత<చార్, కానిస్టేట్ చార్*>pr= {'d', 'ఉండండి'};ఖరీదు<<prప్రధమ << ' n';
ఖరీదు<<prరెండవ << ' n';
అవుట్‌పుట్:
డిఉంటుంది
మొదటి మరియు రెండవ జతలోని రెండు అంశాలకు పదాలు రిజర్వ్ చేయబడ్డాయి. జతలోని విలువలను మొదటి మరియు రెండవ ఉపయోగించి ఇప్పటికీ మార్చవచ్చు.
క్రమం చేయని మ్యాప్ యొక్క అంశంలో జత అంటారు, value_type.
క్రమరహిత_మ్యాప్ ఎలిమెంట్ యాక్సెస్
మ్యాప్డ్_టైప్ & ఆపరేటర్ [] (కీ_టైప్ && కె)
సంబంధిత కీ కోసం విలువను అందిస్తుంది. ఉదాహరణ:
umap['అరటి'] = 'పసుపు';
umap['ద్రాక్ష'] = 'ఆకుపచ్చ';
umap['అత్తి'] = 'ఊదా';
కానిస్టేట్ చార్ *కుడి=umap['ద్రాక్ష'];
ఖరీదు<<కుడి<<' n';
అవుట్‌పుట్: ఆకుపచ్చ. విలువలను అదే విధంగా కేటాయించవచ్చు - పైన చూడండి.
క్రమరహిత_మ్యాప్ సామర్థ్యం
size_type పరిమాణం () const noexcept
మ్యాప్‌లోని జంటల సంఖ్యను అందిస్తుంది.
umap['అరటి'] = 'పసుపు';
umap['ద్రాక్ష'] = 'ఆకుపచ్చ';
umap['అత్తి'] = 'ఊదా';
ఖరీదు<<umap.పరిమాణం() <<' n';
అవుట్‌పుట్ 3.
బూల్ ఖాళీ () కానిస్టెప్ట్
మ్యాప్‌కు జత లేనట్లయితే 1 నిజం కోసం, మరియు దానికి జతలు ఉంటే 0 తప్పుకి అందిస్తుంది. ఉదాహరణ:
క్రమం లేని_మ్యాప్<కానిస్టేట్ చార్*, కానిస్టేట్ చార్*>umap;ఖరీదు<<umap.ఖాళీ() <<' n';
అవుట్‌పుట్ 1.
రిటర్నింగ్ ఐటరేటర్లు మరియు క్రమం లేని-మ్యాప్ క్లాస్
ఇటరేటర్ పాయింటర్ లాంటిది కానీ పాయింటర్ కంటే ఎక్కువ కార్యాచరణను కలిగి ఉంటుంది.
ప్రారంభం () తప్ప
కింది కోడ్ విభాగంలో ఉన్నట్లుగా, మ్యాప్ ఆబ్జెక్ట్ యొక్క మొదటి జతను సూచించే ఇటరేటర్‌ను అందిస్తుంది:
క్రమం లేని_మ్యాప్<కానిస్టేట్ చార్*, కానిస్టేట్ చార్*>umap;umap['అరటి'] = 'పసుపు';umap['ద్రాక్ష'] = 'ఆకుపచ్చ';umap['అత్తి'] = 'ఊదా';
క్రమం లేని_మ్యాప్<కానిస్టేట్ చార్*, కానిస్టేట్ చార్*> ::iteratoriter=umap.ప్రారంభించండి();
జత<కానిస్టేట్ చార్*, కానిస్టేట్ చార్*>pr= *iter;
ఖరీదు<<prప్రధమ << ',' <<prరెండవ << ' n';
అవుట్‌పుట్: అత్తి, ఊదా. మ్యాప్ ఆర్డర్ చేయబడలేదు.
start () const noexcept;
మ్యాప్ ఆబ్జెక్ట్ సేకరణ యొక్క మొదటి మూలకాన్ని సూచించే ఇటరేటర్‌ను అందిస్తుంది. ఆబ్జెక్ట్ నిర్మాణానికి ముందు కాన్స్టాట్ ఉన్నప్పుడు, ఎక్స్‌ప్రెషన్ ప్రారంభం () కాంట్ స్టార్ట్ () కి బదులుగా అమలు చేయబడుతుంది. ఈ పరిస్థితిలో, వస్తువులోని మూలకాలను సవరించలేము. ఇది క్రింది కోడ్‌లో ఉపయోగించబడుతుంది, ఉదాహరణకు.
కానిస్టేట్క్రమం లేని_మ్యాప్<కానిస్టేట్ చార్*, కానిస్టేట్ చార్*>umap({{'అరటి', 'పసుపు'},{'ద్రాక్ష', 'ఆకుపచ్చ'}, {'అత్తి', 'ఊదా'}});
క్రమం లేని_మ్యాప్<కానిస్టేట్ చార్*, కానిస్టేట్ చార్*> ::const_iteratoriter=umap.ప్రారంభించండి();
జత<కానిస్టేట్ చార్*, కానిస్టేట్ చార్*>pr= *iter;
ఖరీదు<<prప్రధమ << ',' <<prరెండవ << ' n';
అవుట్‌పుట్: అత్తి, ఊదా. మ్యాప్ ఆర్డర్ చేయబడలేదు. తిరిగి ఇచ్చిన ఇట్రేటర్‌ను స్వీకరించడానికి కేవలం ఇటరేటర్‌కు బదులుగా ఈసారి const_iterator ఉపయోగించబడిందని గమనించండి.
ముగింపు () తప్ప
మ్యాప్ ఆబ్జెక్ట్ యొక్క చివరి ఎలిమెంట్‌ని మించి వెంటనే సూచించే ఇటరేటర్‌ను అందిస్తుంది.
ముగింపు () కానిది
మ్యాప్ ఆబ్జెక్ట్ యొక్క చివరి ఎలిమెంట్‌ని మించి వెంటనే సూచించే ఇటరేటర్‌ను అందిస్తుంది. మ్యాప్ ఆబ్జెక్ట్ నిర్మాణానికి ముందు కాన్స్ట్ ఉన్నప్పుడు, ఎక్స్‌ప్రెషన్ ఎండ్ () కాన్స్ట్ అనేది ఎండ్ () కి బదులుగా అమలు చేయబడుతుంది.
క్రమరహిత_మ్యాప్ కార్యకలాపాలు
iterator find (const key_type & k)
మ్యాప్‌లో ఇచ్చిన కీ జత కోసం శోధిస్తుంది. అది కనుగొనబడితే, అది ఇట్రేటర్‌ను తిరిగి ఇస్తుంది. కనుగొనబడకపోతే, ఇది మ్యాప్ చివరను సూచించే ఇటరేటర్‌ను అందిస్తుంది, ఇది జత కాదు. ఈ మెంబర్ ఫంక్షన్‌ను ఎలా ఉపయోగించాలో కింది కోడ్ చూపుతుంది:
క్రమం లేని_మ్యాప్<చార్,చార్>umap;umap['కు'] = 'b';umap['సి'] = 'd';umap['మరియు'] = 'f';
క్రమం లేని_మ్యాప్<చార్,చార్> ::iteratoriter=umap.కనుగొనండి('సి');
ఉంటే (umap.కనుగొనండి('సి') ! =umap.ముగింపు())
{
జత<చార్,చార్>pr= *iter;
ఖరీదు<<prప్రధమ << ',' <<prరెండవ << ' n';
}
అవుట్‌పుట్: c, d
const_iterator find (const key_type & k) const;
క్రమబద్ధీకరించని మ్యాప్ యొక్క సృష్టి కాన్స్టాట్‌తో ప్రారంభమైతే, మ్యాప్‌లోని అన్ని అంశాలు చదవడానికి-మాత్రమే ఉండేలా ఈ ఫంక్షన్ వెర్షన్ అంటారు.
క్రమరహిత_మ్యాప్ మాడిఫైయర్లు
జత చొప్పించు (విలువ_ రకం && వస్తువు)
క్రమం లేని మ్యాప్ అంటే జతలు ఏ క్రమంలో లేవు. కాబట్టి, ప్రోగ్రామ్ తమకు అనుకూలమైన ఏ ప్రదేశంలోనైనా జతని చొప్పించింది. ఫంక్షన్ తిరిగి, జత. చొప్పించడం విజయవంతమైతే, బూల్ నిజం కోసం 1 అవుతుంది, లేకుంటే అది తప్పుకి 0 అవుతుంది. చొప్పించడం విజయవంతమైతే, ఇట్రేటర్ కొత్తగా చేర్చబడిన మూలకాన్ని చూపుతుంది. కింది కోడ్ వినియోగాన్ని వివరిస్తుంది:
umap['అరటి'] = 'పసుపు';
umap['ద్రాక్ష'] = 'ఆకుపచ్చ';
umap['అత్తి'] = 'ఊదా';
umap.చొప్పించు({{'చెర్రీ', 'నికర'}, {'స్ట్రాబెర్రీ', 'నికర'}});
ఖరీదు<<umap.పరిమాణం() << ' n';
అవుట్‌పుట్: 5. ఒకటి కంటే ఎక్కువ జతలను చేర్చవచ్చు.
size_type erase (const key_type & k)
ఈ ఫంక్షన్ ఒక జతను క్రమం లేని_మ్యాప్ నుండి తొలగిస్తుంది. కింది కోడ్ సెగ్మెంట్ వివరిస్తుంది:
క్రమం లేని_మ్యాప్<కానిస్టేట్ చార్*, కానిస్టేట్ చార్*>umap;umap['అరటి'] = 'పసుపు';
umap['ద్రాక్ష'] = 'ఆకుపచ్చ';
umap['అత్తి'] = 'ఊదా';
intఒకదానిపై=umap.చెరిపివేయి('ద్రాక్ష');
ఖరీదు<<umap.పరిమాణం() << ' n';
అవుట్‌పుట్ 2.
శూన్య మార్పిడి (క్రమం లేని_మ్యాప్ &)
ఈ కోడ్ విభాగంలో వివరించిన విధంగా రెండు క్రమం లేని మ్యాప్‌లను మార్చుకోవచ్చు:
{'ద్రాక్ష', 'ఆకుపచ్చ'}, {'అత్తి', 'ఊదా'}, {'స్ట్రాబెర్రీ', 'నికర'}};
క్రమం లేని_మ్యాప్<కానిస్టేట్ చార్*, కానిస్టేట్ చార్*>umap2= {{'చెర్రీ', 'నికర'}, {'సున్నం', 'ఆకుపచ్చ'}};
umap1.మార్పిడి(umap2);
క్రమం లేని_మ్యాప్<కానిస్టేట్ చార్*, కానిస్టేట్ చార్*> ::iteratoriter1=umap1.ప్రారంభించండి();
జత<కానిస్టేట్ చార్*, కానిస్టేట్ చార్*>pr1= *iter1;
క్రమం లేని_మ్యాప్<కానిస్టేట్ చార్*, కానిస్టేట్ చార్*> ::iteratoriter2=umap2.ప్రారంభించండి();
జత<కానిస్టేట్ చార్*, కానిస్టేట్ చార్*>pr2= *iter2;
ఖరీదు<< 'Umap1 మొదటి కీ మరియు పరిమాణం:'<<pr1.ప్రధమ <<','<<umap1.పరిమాణం() << ' n';
ఖరీదు<< 'Umap2 యొక్క మొదటి కీ మరియు పరిమాణం'<<pr2.ప్రధమ <<','<<umap2.పరిమాణం() << ' n';
క్రమం లేని_మ్యాప్<కానిస్టేట్ చార్*, కానిస్టేట్ చార్*>umap1= {{'అరటి', 'పసుపు'},
{'ద్రాక్ష', 'ఆకుపచ్చ'}, {'అత్తి', 'ఊదా'}, {'స్ట్రాబెర్రీ', 'నికర'}};
క్రమం లేని_మ్యాప్<కానిస్టేట్ చార్*, కానిస్టేట్ చార్*>umap2= {{'చెర్రీ', 'నికర'}, {'సున్నం', 'ఆకుపచ్చ'}};
umap1.మార్పిడి(umap2);
క్రమం లేని_మ్యాప్<కానిస్టేట్ చార్*, కానిస్టేట్ చార్*> ::iteratoriter1=umap1.ప్రారంభించండి();
జత<కానిస్టేట్ చార్*, కానిస్టేట్ చార్*>pr1= *iter1;
క్రమం లేని_మ్యాప్<కానిస్టేట్ చార్*, కానిస్టేట్ చార్*> ::iteratoriter2=umap2.ప్రారంభించండి();
జత<కానిస్టేట్ చార్*, కానిస్టేట్ చార్*>pr2= *iter2;
ఖరీదు<< 'Umap1 మొదటి కీ మరియు పరిమాణం:'<<pr1.ప్రధమ <<','<<umap1.పరిమాణం() << ' n';
ఖరీదు<< 'Umap2 యొక్క మొదటి కీ మరియు పరిమాణం'<<pr2.ప్రధమ <<','<<umap2.పరిమాణం() << ' n';
అవుట్‌పుట్:
Umap1 మొదటి కీ మరియు పరిమాణం: సున్నం, 2
Umap2 స్ట్రాబెర్రీ యొక్క మొదటి కీ మరియు పరిమాణం, 4
మ్యాప్ ఆర్డర్ చేయబడలేదు. అవసరమైతే మ్యాప్ నిడివి పెరుగుతుందని గమనించండి. డేటా రకాలు తప్పనిసరిగా ఒకే విధంగా ఉండాలి.
తరగతి మరియు దాని తక్షణ వస్తువులు
ఒక విలువ అనేది ఒక డేటా రకానికి, ఒక తక్షణ వస్తువు ఒక తరగతికి సంబంధించినది. క్రమం చేయని మ్యాప్ నిర్మాణం కూడా క్లాస్‌ని డేటా రకంగా ఆమోదించగలదు. కింది కార్యక్రమం దీనిని వివరిస్తుంది:
#చేర్చండి#చేర్చండి
నేమ్‌స్పేస్ std ని ఉపయోగిస్తోంది;
తరగతి TheCla
{
ప్రజా:
intఒకదానిపై;
స్టాటిక్ చార్చ;
శూన్యంఫంక్షన్(చార్లేదు, కానిస్టేట్ చార్ *p)
{
ఖరీదు<< 'ఉన్నాయి ' <<ఒకదానిపై<< 'విలువైన పుస్తకాలు' <<లేదు<<p<< 'స్టోర్‌లో.' << ' n';
}
స్టాటిక్ శూన్యంసరదాగా(చార్చ)
{
ఉంటే (చ== 'కు')
ఖరీదు<< 'అధికారిక స్టాటిక్ మెంబర్ ఫంక్షన్' << ' n';
}
};
intప్రధాన()
{
ది క్లా ఆబ్జెక్ట్ 1;ది క్లా ఆబ్జెక్ట్ 2;ది క్లా ఆబ్జెక్ట్ 3;ది క్లా ఆబ్జెక్ట్ 4;ది క్లా ఆబ్జెక్ట్ 5;
క్రమం లేని_మ్యాప్<కానిస్టేట్ చార్*,ది క్లా>umap;
umap= {{'అరటి',ఆబ్జెక్ట్ 1}, {'ద్రాక్ష',ఆబ్జెక్ట్ 2}, {'అత్తి',ఆబ్జెక్ట్ 3}, {'స్ట్రాబెర్రీ',ఆబ్జెక్ట్ 4}, {'సున్నం',ఆబ్జెక్ట్ 5}};
ఖరీదు<<umap.పరిమాణం() << ' n';
తిరిగి 0;
}
అవుట్‌పుట్: 5.
క్లాస్ డెఫినిషన్‌లో రెండు డేటా పబ్లిక్ సభ్యులు మరియు ఇద్దరు పబ్లిక్ మెంబర్ ఫంక్షన్‌లు ఉన్నాయి. ప్రధాన () ఫంక్షన్‌లో, తరగతికి సంబంధించిన విభిన్న వస్తువులు తక్షణం అందించబడతాయి. క్రమం చేయని మ్యాప్ అప్పుడు తక్షణం చేయబడుతుంది, ఇక్కడ ప్రతి జత పండు యొక్క పేరు మరియు తరగతి నుండి ఒక వస్తువును కలిగి ఉంటుంది. మ్యాప్ పరిమాణం ప్రదర్శించబడుతుంది. ప్రోగ్రామ్ హెచ్చరిక లేదా దోష సందేశం లేకుండా కంపైల్ చేస్తుంది.
మ్యాప్ యొక్క అప్లికేషన్
శ్రేణి విలువకు సూచికను అనుబంధిస్తుంది. కీ/విలువ జతలు జీవితంలో అనేక సందర్భాలలో ఉన్నాయి, వీటిని ప్రోగ్రామ్ చేయవచ్చు. పండు/రంగు యొక్క కీ/విలువ జత కేవలం ఒక ఉదాహరణ. మరొక ఉదాహరణ వ్యక్తుల పేరు మరియు వారి వయస్సు. ఈ సందర్భంలో, జత ఒక రకం, జతగా ఉంటుంది. ఇది జత కూడా కావచ్చు. తరువాతి సందర్భంలో, ప్రీ-ప్రాసెసింగ్ ఆదేశం ఉపయోగించబడుతుంది. కీ/విలువ జత ఇప్పటికీ వివాహిత జంటల పేర్లు కావచ్చు. బహుభార్యాత్వం ఉన్న దేశాలలో, ఒక వ్యక్తికి వేర్వేరు భార్యలు ఉంటారు.
మ్యాప్ నిర్మాణం
మ్యాప్ అనేది రెండు కాలమ్‌లతో కూడిన రెండు డైమెన్షనల్ శ్రేణి కాదు. మ్యాప్ హ్యాష్ ఫంక్షన్‌తో పనిచేస్తుంది. కీ ఒక శ్రేణి యొక్క పూర్ణాంకంలోకి, హాష్ ఫంక్షన్ ద్వారా ఎన్కోడ్ చేయబడింది. ఇది విలువలను కలిగి ఉన్న ఈ శ్రేణి. కాబట్టి, వాస్తవానికి విలువలతో ఒక శ్రేణి ఉంది, మరియు కీలు శ్రేణి యొక్క సూచికలకు మ్యాప్ చేయబడతాయి, కాబట్టి కీలు మరియు విలువల మధ్య అనురూపాలు తయారు చేయబడతాయి. హ్యాషింగ్ అనేది విస్తృతమైన అంశం మరియు ఈ వ్యాసంలో కవర్ చేయబడలేదు.
ముగింపు
మ్యాప్, అసోసియేటివ్ అర్రే అని కూడా పిలువబడే మూలకాల జాబితా, ఇక్కడ ప్రతి మూలకం కీ/విలువ జతగా ఉంటుంది. కాబట్టి, ప్రతి కీ ఒక విలువకు అనుగుణంగా ఉంటుంది. C ++ లో, సభ్యుల విధులు మరియు ఆపరేటర్లతో మ్యాప్ డేటా స్ట్రక్చర్‌గా అమలు చేయబడుతుంది. ఆర్డర్ చేసిన మ్యాప్ అనేది ఎలిమెంట్ జతలను కీల ద్వారా ఆర్డర్ చేసినది. ఆర్డర్ చేయని మ్యాప్ అంటే ఆర్డర్ చేయనిది.
సాంకేతికంగా, ఒక హాష్ జత మూలకాలను కలిగి ఉంటుంది. వాస్తవానికి, జత దాని సభ్యుల విధులు మరియు ఆపరేటర్లతో మొత్తం డేటా నిర్మాణం. జత కోసం రెండు టెంప్లేట్ పారామితులు unorders_map కోసం ఒకే రెండు టెంప్లేట్ పారామితులు.
మ్యాప్ కోసం ఇనిషియలైజర్_లిస్ట్ లిటరల్స్ అక్షరాలా ఉంటుంది. ప్రతి అంతర్గత అక్షరం రెండు వస్తువులను కలిగి ఉంటుంది, కీ/విలువ జత.
క్రమం లేని_మ్యాప్ కోసం సభ్యుల విధులు మరియు ఆపరేటర్‌లను కింది శీర్షికల కింద వర్గీకరించవచ్చు: క్రమం లేని_మ్యాప్ నిర్మాణం/కాపీ నిర్మాణం, క్రమరహిత_మ్యాప్ సామర్థ్యం, క్రమం లేని_మ్యాప్ ఇరేటర్, క్రమరహిత_మ్యాప్ ఆపరేషన్‌లు మరియు క్రమరహిత_మ్యాప్ మాడిఫైయర్లు.
కీని విలువకు మ్యాప్ చేయాల్సి వచ్చినప్పుడు క్రమం లేని మ్యాప్ ఉపయోగించబడుతుంది.
క్రిస్