C++లో, STL (ప్రామాణిక టెంప్లేట్ లైబ్రరీ), కంటైనర్లు ఇతర వస్తువుల సేకరణలను నిల్వ చేయడానికి ఉపయోగించే వస్తువులు. అవి క్లాస్ టెంప్లేట్‌ల మాదిరిగానే పని చేస్తాయి మరియు పెద్ద సంఖ్యలో ఎలిమెంట్ రకాలకు మద్దతు ఇస్తాయి మరియు వాటి ఎలిమెంట్‌లను నేరుగా లేదా ఇటరేటర్‌ల ద్వారా యాక్సెస్ చేయడానికి సభ్యుల ఫంక్షన్‌లను అందిస్తాయి.
C++ STL కంటైనర్‌ల రకాలు
C++లో, మూడు రకాల STLలు ఉన్నాయి కంటైనర్లు , ఇవి క్రింద ఇవ్వబడ్డాయి:
1: సీక్వెన్షియల్ కంటైనర్లు
C++లో, సీక్వెన్షియల్ కంటైనర్లు సీక్వెన్షియల్‌గా తిరిగి పొందగలిగే వస్తువులను నిల్వ చేయడానికి మాకు అనుమతిస్తాయి. ఇవి కంటైనర్లు డేటా స్ట్రక్చర్‌ల శ్రేణులు లేదా లింక్డ్ జాబితాలుగా ఎన్‌కోడ్ చేయబడ్డాయి. కొన్ని రకాల సీక్వెన్షియల్ కంటైనర్లు క్రింద ఇవ్వబడ్డాయి.
- వెక్టర్: ఇది డైనమిక్‌గా సైజులో ఉండే శ్రేణి, ఇది మెమరీలో పక్కపక్కనే నిల్వ చేయబడుతుంది.
- దేని గురించి: ఇది చొప్పించడం మరియు తొలగించడం రెండింటి కోసం ఆపరేషన్‌లకు మద్దతు ఇచ్చే డబుల్-ఎండ్ క్యూను సూచిస్తుంది.
- అమరిక: ఇది దాని పరిమాణాన్ని స్థిరంగా ఉంచుతూ సంకలనం సమయంలో కేటాయించబడిన స్టాటిక్ అర్రే.
- జాబితా: ఇది రెట్టింపు-లింక్ చేయబడిన జాబితా, ఇది జాబితాలోని ఏ ప్రదేశంలోనైనా మూలకాలను వేగంగా చొప్పించడం మరియు తొలగించడం జరుగుతుంది.
- ఫార్వార్డ్ జాబితా: ఇది జాబితా వంటి సింగిల్-లింక్డ్ జాబితా, కానీ మీరు దానిని ఒక దిశలో మాత్రమే ప్రయాణించగలరు.
ఉదాహరణ
ఈ ఉదాహరణలో, మేము ఉపయోగిస్తాము వెక్టర్ తరగతి ఎలా చూపించడానికి a సీక్వెన్షియల్ కంటైనర్ పనిచేస్తుంది.
#
#
నేమ్‌స్పేస్ stdని ఉపయోగించడం;
పూర్ణాంక ప్రధాన ( ) {
// Int యొక్క వెక్టర్‌ను ప్రారంభించండి రకం
వెక్టర్ < int > సంఖ్యలు = { 10 , 2 , 16 , 70 , 5 } ;
// వెక్టర్‌ను ప్రింట్ చేయండి
కోట్ << 'సంఖ్యలు:' ;
కోసం ( దానంతట అదే & నేను: సంఖ్యలు )
{
కోట్ << i << ',' ;
}
తిరిగి 0 ;
}
పైన ఉన్న కోడ్ ఉపయోగాన్ని ప్రదర్శిస్తుంది సీక్వెన్షియల్ కంటైనర్లు వెక్టర్ ఆకృతిలో, ఇది పూర్ణాంక శ్రేణుల నిల్వను అనుమతిస్తుంది. ప్రోగ్రామ్ టైప్ పూర్ణాంకం యొక్క వెక్టర్‌ను ప్రారంభిస్తుంది, దానికి విలువలను కేటాయించి, వాటిని లూప్ ఉపయోగించి ప్రింట్ చేస్తుంది. C++లో డేటాను నిల్వ చేయడం మరియు యాక్సెస్ చేయడం ఎలా సులభమో ఈ ఉదాహరణ చూపిస్తుంది సీక్వెన్షియల్ కంటైనర్ .
2: అనుబంధ కంటైనర్లు
అనుబంధ కంటైనర్లు పోలిక ఆపరేటర్ ద్వారా నిర్వచించబడిన నిర్దిష్ట క్రమంలో మూలకాలను నిల్వ చేయడానికి మమ్మల్ని అనుమతిస్తుంది. కాకుండా సీక్వెన్షియల్ కంటైనర్లు , మూలకాల క్రమం అనుబంధ కంటైనర్లు ఎలిమెంట్‌లను నిర్వహించడానికి మరియు యాక్సెస్ చేయడానికి వినియోగదారులను అనుమతించే కీలను ఉపయోగించి నిర్వహించబడుతుంది. ఒక మూలకం ఒక లోకి చొప్పించినప్పుడు అనుబంధ కంటైనర్ , ఇది దాని కీ ఆధారంగా స్వయంచాలకంగా సరైన స్థానంలో క్రమబద్ధీకరించబడుతుంది. ఈ రకమైన కంటైనర్లు బైనరీ ట్రీ డేటా స్ట్రక్చర్‌ల వలె అంతర్గతంగా అమలు చేయబడతాయి.
ది అనుబంధ కంటైనర్లు వర్గీకరించబడ్డాయి:
- మ్యాప్: ప్రత్యేక కీలను ఉపయోగించి క్రమబద్ధీకరించబడిన కీ-విలువ జతల సేకరణ
- మల్టీమ్యాప్: కీలను ఉపయోగించి క్రమబద్ధీకరించబడిన కీ-విలువ జతల సేకరణ
- సెట్: ప్రత్యేకమైన కీలు సేకరించి, కీల ద్వారా అమర్చబడ్డాయి.
- మల్టీసెట్: కీలను ఉపయోగించి క్రమబద్ధీకరించబడిన కీల సేకరణ
ఉదాహరణ
ఎలా ఉందో వివరించడానికి అనుబంధ కంటైనర్ పనిచేస్తుంది, మేము ఉపయోగిస్తాము తరగతి సెట్ ఈ ఉదాహరణలో.
##
నేమ్‌స్పేస్ stdని ఉపయోగించడం;
పూర్ణాంక ప్రధాన ( )
{
// ప్రారంభించు a సెట్ int రకం
సెట్ < int > సంఖ్యలు = { 10 , 2 , 16 , 70 , 5 } ;
// ముద్రించండి సెట్
కోట్ << 'సంఖ్యలు:' ;
కోసం ( దానంతట అదే & నేను: సంఖ్యలు )
{
కోట్ << i << ',' ;
}
తిరిగి 0 ;
}
పై కోడ్ C++లో పూర్ణాంకాల సమితిని ప్రారంభిస్తుంది, ఇది అనుబంధ కంటైనర్‌కు ఉదాహరణ. మూలకాలు డిఫాల్ట్‌గా ఆరోహణ క్రమంలో క్రమబద్ధీకరించబడతాయని సెట్ నిర్ధారిస్తుంది. కోడ్ లూప్‌ని ఉపయోగించి సెట్‌లోని సంఖ్యలను ప్రింట్ చేస్తుంది.
3: ఆర్డర్ చేయని అసోసియేటివ్ కంటైనర్లు
C++లో, క్రమం లేని అనుబంధం కంటైనర్లు ఒక యొక్క క్రమబద్ధీకరించని సంస్కరణలను అందించడానికి ఉపయోగించబడతాయి అనుబంధ కంటైనర్ . అవి హాష్ టేబుల్ డేటా స్ట్రక్చర్‌ల వలె అంతర్గతంగా అమలు చేయబడతాయి. ది అనుబంధ కంటైనర్లు వర్గీకరించబడ్డాయి:
- క్రమం లేని మ్యాప్: ప్రత్యేకమైన కీలను ఉపయోగించి హ్యాష్ చేయబడిన కీ-విలువ జతల సేకరణ.
- క్రమం చేయని మల్టీమ్యాప్: కీలను ఉపయోగించి హ్యాష్ చేయబడిన కీ-విలువ జతల సేకరణ.
- క్రమం లేని సెట్: కీలను ఉపయోగించి హ్యాష్ చేయబడిన ప్రత్యేక కీల సేకరణ.
- క్రమం చేయని మల్టీసెట్: కీలను ఉపయోగించి హ్యాష్ చేయబడిన కీల సేకరణ.
ఉదాహరణ
ఎలా ఉందో వివరించడానికి క్రమం లేని అనుబంధం కంటైనర్ పనిచేస్తుంది, మేము ఉపయోగిస్తాము క్రమం లేని సెట్ ఈ ఉదాహరణలో తరగతి.
##
నేమ్‌స్పేస్ stdని ఉపయోగించడం;
పూర్ణాంక ప్రధాన ( )
{
// int యొక్క unordered_setని ప్రారంభించండి రకం
క్రమం లేని_సెట్ < int > సంఖ్యలు = { 10 , 2 , 16 , 70 , 5 } ;
// ముద్రించండి సెట్
కోట్ << 'సంఖ్యలు:' ;
కోసం ( దానంతట అదే & నేను: సంఖ్యలు )
{
కోట్ << i << ',' ;
}
తిరిగి 0 ;
}
ముగింపు
ఒక STL C++ కంటైనర్ ఇతర వస్తువుల సేకరణను నిల్వ చేయడానికి హోల్డర్ వస్తువు. అవి క్లాస్ టెంప్లేట్‌ల మాదిరిగానే పని చేస్తాయి మరియు పెద్ద సంఖ్యలో ఎలిమెంట్ రకాలకు మద్దతు ఇస్తాయి. ఈ ట్యుటోరియల్‌లో, మేము సాధారణంగా ఉపయోగించే STL C++ కంటైనర్‌ల గురించి చర్చించాము, అవి సీక్వెన్షియల్ కంటైనర్లు, అనుబంధ కంటైనర్లు అలాగే క్రమం లేని అనుబంధ కంటైనర్లు .