C++లో, వెక్టర్ అనేది ఒక బహుముఖ కంటైనర్, ఇది డైనమిక్‌గా దాని పరిమాణాన్ని మార్చగలదు, ఇది మూలకాల యొక్క సమర్థవంతమైన తారుమారుని అనుమతిస్తుంది. ఒక జత అనేది రెండు భిన్నమైన వస్తువులను కలిగి ఉండే సాధారణ కంటైనర్ అయితే, సంబంధిత డేటాను అనుబంధించడానికి మరియు నిర్వహించడానికి అనుకూలమైన మార్గాలను అందిస్తుంది. ఈ జంటలు వెక్టార్‌లో నిర్వహించబడినప్పుడు, డెవలపర్‌లు కీ-విలువ జతల యొక్క డైనమిక్ సేకరణలను లేదా రెండు విభిన్న మూలకాల యొక్క ఏదైనా ఇతర కలయికను సృష్టించగల సామర్థ్యాన్ని పొందుతారు.
కీ-విలువ జతలతో వ్యవహరించేటప్పుడు లేదా ఎంటిటీల మధ్య సంబంధాలను సూచించేటప్పుడు మూలకాలు జతగా నిల్వ చేయబడే సందర్భాలలో ఈ డేటా నిర్మాణం ప్రత్యేకంగా ఉపయోగపడుతుంది. ఈ కథనంలో, మేము జంటల C++ వెక్టర్ భావనను అన్వేషిస్తాము మరియు దాని ఆచరణాత్మక అనువర్తనాలను వివరించడానికి వివిధ ఉదాహరణలను అన్వేషిస్తాము.
ఉదాహరణ 1: ప్రాథమిక వినియోగం: జంటల వెక్టర్‌పై మళ్లించడం
మేము విద్యార్థుల పేర్లు మరియు వారి సంబంధిత వయస్సులను సూచించే జంటల వెక్టర్‌ను సృష్టించే ప్రాథమిక ఉదాహరణను పరిశీలిద్దాం. జంటల వెక్టర్‌పై మళ్లించడం సాధారణ వెక్టర్‌పై మళ్లించడం లాంటిది. వెక్టార్‌లోని ప్రతి జతని తిరిగి పొందడానికి ఒకరు ఇటరేటర్‌లను లేదా పరిధి-ఆధారిత 'ఫర్' లూప్‌లను ఉపయోగించవచ్చు.
ఈ ఉదాహరణ అర్ధవంతమైన సందర్భంలో 'జతల వెక్టర్' కోసం వాక్యనిర్మాణాన్ని ప్రదర్శిస్తుంది.
#
#
#include
పూర్ణాంక ప్రధాన ( ) {
std:: వెక్టర్ < std:: జత < std::string, int >> విద్యార్థి డేటా;
studentData.push_back ( std::make_pair ( 'ఆడమ్' , ఇరవై ) ) ;
studentData.push_back ( std::make_pair ( 'బిల్లు' , 22 ) ) ;
studentData.push_back ( std::make_pair ( 'చార్లీ' , ఇరవై ఒకటి ) ) ;
std::cout << 'విద్యార్థి డేటా: \n ' ;
కోసం ( స్థిర ఆటో & విద్యార్థి: విద్యార్థి డేటా ) {
std::cout << 'పేరు:' << విద్యార్థి.మొదటి << ', వయస్సు:' << విద్యార్థి.రెండవ << std::endl;
}
తిరిగి 0 ;
}
ఈ C++ కోడ్ స్నిప్పెట్‌లో, మేము మూడు ముఖ్యమైన హెడర్ ఫైల్‌లను చేర్చడం ద్వారా ప్రారంభిస్తాము: ఇన్‌పుట్ మరియు అవుట్‌పుట్ ఆపరేషన్‌ల కోసం “
మెయిన్() ఫంక్షన్‌లో ముందుకు వెళుతున్నప్పుడు, మేము “std::vector” కంటైనర్‌ని ఉపయోగించి “studentData” అనే వెక్టర్‌ని ప్రకటిస్తాము. ప్రతి జత విద్యార్థి పేరు ('std::string'గా సూచించబడుతుంది) మరియు వారి వయస్సు ('పూర్ణాంక' పూర్ణాంకం) జత చేసే జంటలను నిల్వ చేయడానికి ఈ వెక్టర్ రూపొందించబడింది. అప్పుడు, మేము 'స్టూడెంట్‌డేటా' వెక్టర్‌ను మూడు జతలతో నింపాము. “పుష్_బ్యాక్” ఫంక్షన్‌ని ఉపయోగించి, వెక్టార్ చివర జతలు జోడించబడతాయి, దాని పరిమాణాన్ని డైనమిక్‌గా సర్దుబాటు చేస్తాయి. ఒక లూప్ 'స్టూడెంట్ డేటా' ద్వారా పునరావృతమవుతుంది, ప్రతి విద్యార్థి పేరు మరియు వయస్సును సంగ్రహిస్తుంది మరియు ముద్రిస్తుంది. అవుట్‌పుట్ “విద్యార్థి డేటా:”ని ప్రదర్శిస్తుంది, ఇది నిర్మాణాత్మక ప్రాతినిధ్యాన్ని నొక్కి చెబుతుంది. విద్యార్థుల పేర్లు మరియు వయస్సులు విడిగా ముద్రించబడతాయి, నిల్వ చేయబడిన డేటాను స్పష్టంగా ప్రదర్శిస్తాయి.
ఉదాహరణ 2: జతల వెక్టర్‌ను క్రమబద్ధీకరించడం
జంటల వెక్టర్‌ను క్రమబద్ధీకరించడం అనేది ఒక సాధారణ చర్య, ప్రత్యేకించి కీ-విలువ సంఘాలతో వ్యవహరించేటప్పుడు. ఈ ప్రయోజనం కోసం “
#
#
పూర్ణాంక ప్రధాన ( ) {
std:: వెక్టర్ < std:: జత < std::string, int >> సమాచారం;
info.push_back ( std::make_pair ( 'పీటర్' , పదిహేను ) ) ;
info.push_back ( std::make_pair ( 'డోరా' , 29 ) ) ;
info.push_back ( std::make_pair ( 'హన్నా' , ఇరవై ) ) ;
std::cout << 'అసలు సమాచారం: \n ' ;
కోసం ( స్థిర ఆటో & ప్రవేశం: సమాచారం ) {
std::cout << 'పేరు:' << ప్రవేశం.మొదట << ', వయస్సు:' << ప్రవేశం.రెండవ << std::endl;
}
std:: విధమైన ( info.begin ( ) , info.end ( ) ) ;
std::cout << ' \n క్రమబద్ధీకరించబడిన సమాచారం: \n ' ;
కోసం ( స్థిర ఆటో & ప్రవేశం: సమాచారం ) {
std::cout << 'వయస్సు:' << ప్రవేశం.రెండవ << ', పేరు:' << ప్రవేశం.మొదట << std::endl;
}
తిరిగి 0 ;
}
ఈ C++ కోడ్ ఉదాహరణలో, మేము వ్యక్తులకు సంబంధించిన డేటాను, ప్రత్యేకంగా వారి పేర్లు మరియు వయస్సులను నిల్వ చేయడానికి మరియు మార్చడానికి జంటల వెక్టర్‌తో పని చేస్తున్నాము. మేము మెయిన్() ఫంక్షన్‌లో “పెయిర్ల సమాచారం” అనే వెక్టర్‌ని ప్రారంభిస్తాము. తదనంతరం, మేము ఈ వెక్టార్‌ను మూడు జతలతో నింపాము, ప్రతి ఒక్కటి ప్రత్యేకమైన వ్యక్తి పేరు మరియు వయస్సును కలిగి ఉంటుంది, సమర్థవంతమైన జత సృష్టి కోసం “పుష్_బ్యాక్” ఫంక్షన్ మరియు “std::make_pair”ని ఉపయోగిస్తాము.
మేము కన్సోల్‌కు “అసలు సమాచారం”ని అవుట్‌పుట్ చేస్తాము. ఇది 'సమాచారం' వెక్టర్ ద్వారా మళ్ళించడం మరియు ప్రతి జత భాగాలను ముద్రించడం. ఆపై, ప్రతి జత యొక్క మొదటి మూలకాన్ని (ఈ సందర్భంలో పేర్లు) పోల్చిన జతల కోసం డిఫాల్ట్ పోలిక ఆపరేటర్ ఆధారంగా 'సమాచారం' వెక్టర్‌ను క్రమాన్ని మార్చడానికి మేము 'std::sort' అల్గారిథమ్‌ని ఉపయోగిస్తాము. సార్టింగ్ ఆపరేషన్‌ను అనుసరించి, క్రమబద్ధీకరించబడిన సమాచారాన్ని ముద్రించడం ద్వారా మేము సవరించిన “సమాచారం” వెక్టర్ ద్వారా మళ్లీ పునరావృతం చేస్తాము. ఈసారి, అవుట్‌పుట్ సార్టింగ్ ప్రక్రియ యొక్క ఫలితాన్ని వివరిస్తూ, వయస్సు-మొదటి క్రమాన్ని నొక్కి చెబుతుంది.
ఉదాహరణ 3: వివిధ రకాల వెక్టర్‌లను కలపడం
మీరు రెండు వెక్టర్స్ నుండి సమాచారాన్ని మిళితం చేయాల్సిన కొన్ని పరిస్థితులను మీరు ఎదుర్కోవచ్చు. జతల వెక్టర్ రెండు వెక్టర్స్ నుండి మూలకాల మధ్య అనుబంధాన్ని నిర్వహించడానికి సహాయపడుతుంది.
##
పూర్ణాంక ప్రధాన ( ) {
std:: వెక్టర్ < std:: స్ట్రింగ్ > నగరాలు = { 'న్యూయార్క్' , 'పారిస్' , 'టోక్యో' } ;
std:: వెక్టర్ < int > జనాభా = { 8175133 , 2140526 , 37435191 } ;
std:: వెక్టర్ < std:: జత < std::string, int >> సిటీ పాపులేషన్ పెయిర్స్;
కోసం ( size_t i = 0 ; i < std::min ( నగరాలు.పరిమాణం ( ) , జనాభా.పరిమాణం ( ) ) ; ++i ) {
cityPopulationPairs.push_back ( { నగరాలు [ i ] , జనాభా [ i ] } ) ;
}
std::cout << 'నగరం-జనాభా జంటలు:' << std::endl;
కోసం ( స్థిర ఆటో & జంట: నగరం జనాభా జంటలు ) {
std::cout << 'నగరం: ' << జత.మొదటి << ', జనాభా:' << జత.రెండవ << std::endl;
}
తిరిగి 0 ;
}
కోడ్ యొక్క 'ప్రధాన' ఫంక్షన్‌లో, రెండు వెక్టర్‌లు ప్రకటించబడ్డాయి: నగర పేర్లను నిల్వ చేయడానికి 'నగరాలు' మరియు సంబంధిత జనాభా విలువలను నిల్వ చేయడానికి 'జనాభా'.
మూడవ వెక్టర్, “సిటీ పాపులేషన్‌పెయిర్స్”, నగరాల జతలను మరియు వాటి సంబంధిత జనాభాను నిల్వ చేయడానికి నిర్వచించబడింది. ప్రతి జత “std:: pair
సమాచారాన్ని కలిపిన తర్వాత, 'cityPopulationPairs'లో నిల్వ చేయబడిన జతల ద్వారా మళ్ళించడానికి మరొక 'ఫర్' లూప్ ఉపయోగించబడుతుంది. కంబైన్డ్ డేటా 'std::cout'ని ఉపయోగించి ప్రామాణిక అవుట్‌పుట్‌లో ప్రదర్శించబడుతుంది, ప్రతి నగరం మరియు దాని సంబంధిత జనాభాను స్పష్టంగా సూచిస్తుంది.
ఉదాహరణ 4: గరిష్ట మరియు కనిష్ట విలువలను కనుగొనడం
డేటాసెట్‌లోని కనిష్ట మరియు గరిష్ట విలువలను గుర్తించడం అల్గారిథమిక్ మరియు స్టాటిస్టికల్ ఆపరేషన్‌లలో ఒక సాధారణ అవసరం. ఒక క్రమంలో గరిష్ట మరియు కనిష్ట విలువలు రెండింటినీ ట్రాక్ చేయడానికి మేము జతల వెక్టర్‌ను ఉపయోగించవచ్చు:
##
#
పూర్ణాంక ప్రధాన ( ) {
std:: వెక్టర్ < int > సంఖ్యలు = { 5 , 12 , 18 , 3 , 7 , 4 , 33 } ;
std:: వెక్టర్ < std:: జత < మీరు, మీరు >> minMaxPairs;
std:: విధమైన ( సంఖ్యలు.ప్రారంభం ( ) , numbers.end ( ) ) ;
minMaxPairs.push_back ( { సంఖ్యలు.ముందు ( ) , numbers.back ( ) } ) ;
std::cout << 'కనిష్ట-మాక్స్ జతలు:' << std::endl;
కోసం ( స్థిర ఆటో & జత: minMaxPairs ) {
std::cout << 'కనిష్టం:' << జత.మొదటి << ', గరిష్టం:' << జత.రెండవ << std::endl;
}
తిరిగి 0 ;
}
అందించిన C++ కోడ్ పూర్ణాంకాల వెక్టర్‌లో కనిష్ట మరియు గరిష్ట విలువలను కనుగొనే ప్రక్రియను ప్రదర్శిస్తుంది మరియు ఆపై ఈ విలువలను జతల వెక్టర్‌లో నిల్వ చేస్తుంది. 'సంఖ్యలు' అనే పేరుగల వెక్టర్ ప్రారంభంలో ప్రకటించబడింది మరియు పూర్ణాంకాల సమితితో ప్రారంభించబడుతుంది. డేటాసెట్‌లోని కనిష్ట మరియు గరిష్ట విలువలను సమర్ధవంతంగా గుర్తించడానికి, ప్రోగ్రామ్ అల్గోరిథం లైబ్రరీ నుండి “std::sort” ఫంక్షన్‌ను ఉపయోగిస్తుంది.
ఈ ఫంక్షన్ డేటాసెట్‌లోని కనిష్ట మరియు గరిష్ట విలువలను గుర్తించే ప్రక్రియను సులభతరం చేయడం ద్వారా మూలకాలను ఆరోహణ క్రమంలో అమర్చడం లక్ష్యంగా పెట్టుకుంది. సార్టింగ్ ఆపరేషన్ numbers.begin() మరియు numbers.end()ని శ్రేణి పారామితులుగా ఉపయోగించి “సంఖ్యలు” వెక్టార్‌కు వర్తించబడుతుంది. క్రమబద్ధీకరణ దశను అనుసరించి, ప్రోగ్రామ్ లెక్కించిన కనిష్ట మరియు గరిష్ట విలువలను నిల్వ చేయడానికి జంటల వెక్టర్, “minMaxPairs”ని సృష్టిస్తుంది. క్రమబద్ధీకరించబడిన సంఖ్యల వెక్టర్ యొక్క మొదటి (కనీస) మరియు చివరి (గరిష్ట) మూలకాలను కలిగి ఉన్న ఒకే జతని జోడించడానికి “పుష్_బ్యాక్” ఫంక్షన్ ఉపయోగించబడుతుంది. చివరగా, ప్రోగ్రామ్ 'minMaxPairs' వెక్టర్ ద్వారా మళ్ళించడం ద్వారా మరియు కనిష్ట మరియు గరిష్ట విలువలను ప్రదర్శించడం ద్వారా ఫలితాన్ని అందిస్తుంది.
ముగింపు
ముగింపులో, జంటల యొక్క C++ వెక్టర్ శక్తివంతమైన మరియు సౌకర్యవంతమైన డేటా నిర్మాణంగా ఉద్భవించింది, ప్రోగ్రామింగ్ పనులకు బహుముఖ ప్రజ్ఞను జోడిస్తుంది. దాని సింటాక్స్ మరియు ప్రాక్టికల్ అప్లికేషన్‌ల యొక్క వివరణాత్మక అన్వేషణ ద్వారా, ఈ కంటైనర్ కీ-వాల్యూ అసోసియేషన్‌లను నిర్వహించడానికి, వివిధ వెక్టర్‌ల నుండి సమాచారాన్ని కలపడానికి మరియు కనిష్ట మరియు గరిష్ట విలువలను ట్రాక్ చేయడానికి ఎలా సహాయపడుతుందో మేము చూశాము.