కొన్ని కార్యకలాపాలను నిర్వహించడానికి మెమరీలో ఈ డేటా స్ట్రక్చర్‌లను మార్చేందుకు మనకు పూర్ణాంకం, అక్షరాలు, డబుల్ వంటి కొన్ని డేటా రకాల వేరియబుల్స్ అవసరం.
ఈ కథనం వెక్టార్ విశ్లేషణతో మీకు సహాయం చేస్తుంది మరియు C++లో వెక్టర్స్ (డేటా స్ట్రక్చర్)పై ప్రారంభ ప్రక్రియల గురించి తెలియజేస్తుంది.
C++ భాషలో వెక్టర్ అంటే ఏమిటి
C++లో వెక్టర్ క్లాస్ యొక్క అంతర్నిర్మిత కంటైనర్‌లను కలిగి ఉన్న ప్రత్యేక ప్రామాణిక టెంప్లేట్ లైబ్రరీని కలిగి ఉన్నాము. వెక్టర్ అనేది మెమరీలో సామూహిక నిల్వ, ఇది ఒకే రకమైన డేటా పరిమితితో డైనమిక్‌గా మూలకాలను నిల్వ చేస్తుంది.
C++లో వెక్టర్ యొక్క సాధారణ ప్రకటన
వెక్టర్_కీవర్డ్ < సమాచారం - రకం > వెక్టర్_పేరు ( )వెక్టర్స్ మరియు శ్రేణులు ఒకేలా ఉన్నప్పటికీ, వెక్టర్ పరిమాణం కాలక్రమేణా మారవచ్చు. భాగాలు సంబంధిత మెమరీ ప్రాంతాలలో ఉంచబడతాయి. ఫలితంగా, వెక్టర్ పరిమాణం నడుస్తున్న అప్లికేషన్ యొక్క అవసరాలపై ఆధారపడి ఉంటుంది. ప్రీ-ప్రాసెసర్ డైరెక్టివ్‌తో హెడర్ ఫైల్‌ను జోడించడం అవసరం #clude<వెక్టర్> C++ ప్రోగ్రామ్‌లలో వెక్టర్‌లను ఉపయోగించే ముందు. C++లో వెక్టర్ అమలు శ్రేణుల కంటే సరళమైనది మరియు సులభం.
C++లో వెక్టర్‌ను ప్రారంభించేందుకు మనకు వేర్వేరు పద్ధతులు ఉన్నాయి, వాటిని ఒక్కొక్కటిగా చర్చిద్దాం:
విధానం 1: వెక్టర్ క్లాస్‌లో ఫిల్ మెథడ్‌ని ఉపయోగించడం ద్వారా
##
నేమ్‌స్పేస్ stdని ఉపయోగిస్తోంది ;
int ప్రధాన ( )
{
వెక్టర్ < int > ఒక వస్తువు ( 10 ) ;
నింపండి ( ఒక వస్తువు. ప్రారంభం ( ) , ఒక వస్తువు. ముగింపు ( ) , 0 ) ;
కోసం ( int x : ఒక వస్తువు )
కోట్ << x << '' ;
తిరిగి 0 ;
}
ఈ కోడ్‌లో, మేము పూరక పద్ధతిని ఉపయోగిస్తాము మరియు వెక్టర్‌ను సృష్టిస్తాము. పూరక పద్ధతిలో రెండు వస్తువులు ఉన్నాయి, ఒకటి ప్రారంభమవుతుంది, మరియు రెండవది ముగింపు, అప్పుడు మేము ముద్రించాల్సిన విలువను పాస్ చేస్తాము.
అవుట్‌పుట్
విధానం 2: విలువలను ఒకదాని తర్వాత మరొకటి పుష్ చేయడానికి push_back()ని ఉపయోగించడం ద్వారా
##
నేమ్‌స్పేస్ stdని ఉపయోగిస్తోంది ;
int ప్రధాన ( )
{
వెక్టర్ < int > ఒక వస్తువు ;
ఒక వస్తువు. వెనుకకు నెట్టడం ( పదకొండు ) ;
ఒక వస్తువు. వెనుకకు నెట్టడం ( 22 ) ;
ఒక వస్తువు. వెనుకకు నెట్టడం ( 30 ) ;
ఒక వస్తువు. వెనుకకు నెట్టడం ( 4 ) ;
కోట్ << 'వెక్టర్స్‌లోని అన్ని మూలకాలు... \n ' ;
కోసం ( int i = 0 ; i < ఒక వస్తువు. పరిమాణం ( ) ; i ++ )
{
కోట్ << ఒక వస్తువు [ i ] << '' ;
}
తిరిగి 0 ;
}
ఈ ప్రోగ్రామ్‌లో మనం ఖాళీ వెక్టార్‌ని ప్రారంభించాము, ఆపై మనం పుష్_బ్యాక్ పద్ధతికి 11,22,30గా విలువలను మళ్లీ మళ్లీ ఉపయోగిస్తాము మరియు 4ని ఉపయోగిస్తాము మరియు వాటిని లూప్ ఉపయోగించి చూపుతాము.
అవుట్‌పుట్
విధానం 3: వెక్టర్‌ను ఒక దశలో ప్రారంభించండి మరియు ప్రారంభించండి
##
నేమ్‌స్పేస్ stdని ఉపయోగిస్తోంది ;
int ప్రధాన ( ) {
వెక్టర్ < int > ఒక వస్తువు { 6 , 22 , 70 , 4 , 9 , పదకొండు } ;
కోసం ( int తో : ఒక వస్తువు )
కోట్ << తో << '' ;
}
పై ప్రోగ్రామ్ ఉదాహరణలో, ప్రోగ్రామ్ ప్రధాన ఫంక్షన్‌తో ప్రారంభమవుతుంది, ఇక్కడ మేము పూర్ణాంక రకం వెక్టర్‌లను ప్రారంభించాము మరియు అదే దశలో వాటికి విలువలను ఇస్తాము. అప్పుడు మేము లూప్ కోసం a ఉపయోగించి విలువలను చూపుతాము.
అవుట్‌పుట్
విధానం 4: శ్రేణిని ఉపయోగించడంతో
##
నేమ్‌స్పేస్ stdని ఉపయోగిస్తోంది ;
int ప్రధాన ( )
{
వెక్టర్ < int > ఒక వస్తువు { 4 , 9 , 10 , 66 , 8 , 7 } ;
కోసం ( int i : ఒక వస్తువు )
కోట్ << i << '' ;
తిరిగి 0 ;
}
ఈ కోడ్‌లో, మేము 6 మూలకాల శ్రేణిని ప్రకటించడం ద్వారా వెక్టర్‌ను ప్రారంభించి, ఆపై వాటిని కౌట్‌తో ముద్రిస్తాము.
అవుట్‌పుట్
విధానం 5: ఇప్పటికే ఉన్న శ్రేణిని ఉపయోగించడం మరియు దానిని కాపీ చేయడం ద్వారా
##
నేమ్‌స్పేస్ stdని ఉపయోగిస్తోంది ;
int ప్రధాన ( )
{
int బి [ ] = { 1 , 88 , 7 , 6 , నాలుగు ఐదు } ;
int ది = పరిమాణం ( బి ) / పరిమాణం ( బి [ 0 ] ) ;
వెక్టర్ < int > ఒక వస్తువు ( బి , బి + ది ) ;
కోసం ( int అంకెలు : ఒక వస్తువు )
కోట్ << అంకెలు << '' ;
తిరిగి 0 ;
}
ఈ ప్రోగ్రామ్‌లో, మేము 5 విలువలతో ఒక శ్రేణిని bగా ప్రకటించి, ఆపై దానిని వెక్టర్‌లో రెండు పారామితుల ద్వారా జోడిస్తాము; శ్రేణి మొదటిది మరియు దాని పొడవుతో కూడిన శ్రేణి రెండవది.
అవుట్‌పుట్
విధానం 6: వెక్టర్‌లో కన్స్ట్రక్టర్ ఓవర్‌లోడ్ ఉపయోగించడం ద్వారా
##
నేమ్‌స్పేస్ stdని ఉపయోగిస్తోంది ;
int ప్రధాన ( )
{
వెక్టర్ < int > ఒక వస్తువు ( 10 , 9 ) ;
కోసం ( int x : ఒక వస్తువు )
కోట్ << x << '' ;
తిరిగి 0 ;
}
పై ఉదాహరణలో, మేము రెండు పారామితులను అంగీకరించే కన్స్ట్రక్టర్ ఓవర్‌లోడ్‌తో వెక్టార్‌ని ఉపయోగించాము: ఒకటి విలువ యొక్క పునరావృతం మరియు రెండవది మనం చూపించాలనుకుంటున్న అంకె, అందువల్ల అవుట్‌పుట్ క్రింది విధంగా ఉంటుంది.
అవుట్‌పుట్
ముగింపు
వెక్టర్స్ ప్రామాణిక టెంప్లేట్ లైబ్రరీ (STL)లో నిర్వచించబడ్డాయి. వెక్టార్‌ని ఉపయోగించడానికి, ముందుగా, మేము ప్రోగ్రామ్‌లో వెక్టర్ హెడర్‌ను చేర్చాలి. ఈ రచనలో, మేము C++ భాషలో వెక్టర్‌లను ప్రారంభించే వివిధ మార్గాలను చూశాము. డెవలపర్ అవసరాన్ని బట్టి ఏదైనా పద్ధతిని ఎంచుకోవచ్చు.