C++లో వెక్టార్‌ని ఉపయోగించడం ద్వారా డైనమిక్ శ్రేణిని అమలు చేయవచ్చు. మూలకాలను వివిధ మార్గాల్లో వెక్టర్‌కు జోడించవచ్చు. వెక్టార్ చివరిలో కొత్త మూలకాన్ని చొప్పించే మార్గాలలో push_back() ఫంక్షన్ ఒకటి, ఇది వెక్టార్ యొక్క పరిమాణాన్ని 1 ద్వారా పెంచుతుంది. వెక్టర్‌కు ఒక మూలకం జోడించాల్సిన అవసరం వచ్చినప్పుడు ఈ ఫంక్షన్ ఉపయోగపడుతుంది. వెక్టార్ యొక్క డేటా రకం ఈ ఫంక్షన్ యొక్క ఆర్గ్యుమెంట్ ద్వారా ఆమోదించబడిన విలువకు మద్దతు ఇవ్వకపోతే, మినహాయింపు ఉత్పత్తి చేయబడుతుంది మరియు డేటా చొప్పించబడదు. పుష్_బ్యాక్() ఫంక్షన్‌ని ఉపయోగించి వెక్టార్‌లో డేటాను ఇన్సర్ట్ చేసే మార్గం ఈ ట్యుటోరియల్‌లో చూపబడింది.
సింటాక్స్:
వెక్టర్ :: వెనుకకు నెట్టడం ( విలువ_రకం n ) ;వెక్టార్ యొక్క డేటా రకం n యొక్క డేటా రకానికి మద్దతిస్తే n విలువ వెక్టార్ చివరిలో చొప్పించబడుతుంది. ఇది ఏమీ తిరిగి ఇవ్వదు.
ముందస్తు అవసరం:
ఈ ట్యుటోరియల్ యొక్క ఉదాహరణలను తనిఖీ చేసే ముందు, మీరు సిస్టమ్‌లో g++ కంపైలర్ ఇన్‌స్టాల్ చేయబడిందో లేదో తనిఖీ చేయాలి. మీరు విజువల్ స్టూడియో కోడ్‌ని ఉపయోగిస్తుంటే, ఎక్జిక్యూటబుల్ కోడ్‌ని సృష్టించడానికి C++ సోర్స్ కోడ్‌ను కంపైల్ చేయడానికి అవసరమైన పొడిగింపులను ఇన్‌స్టాల్ చేయండి. ఇక్కడ, విజువల్ స్టూడియో కోడ్ అప్లికేషన్ C++ కోడ్‌ను కంపైల్ చేయడానికి మరియు అమలు చేయడానికి ఉపయోగించబడింది. వెక్టర్‌లోకి ఎలిమెంట్(ల)ని చొప్పించడానికి push_back() ఫంక్షన్ యొక్క వివిధ ఉపయోగాలు ఈ ట్యుటోరియల్ యొక్క తదుపరి భాగంలో చూపబడ్డాయి.
ఉదాహరణ-1: వెక్టర్ చివరిలో బహుళ మూలకాలను జోడించడం
పుష్_బ్యాక్() ఫంక్షన్‌ని ఉపయోగించి వెక్టర్ చివరిలో బహుళ మూలకాలను చొప్పించడానికి క్రింది కోడ్‌తో C++ ఫైల్‌ను సృష్టించండి. మూడు స్ట్రింగ్ విలువల వెక్టర్ కోడ్‌లో నిర్వచించబడింది. వెక్టార్ చివరిలో మూడు మూలకాలను చొప్పించడానికి పుష్_బ్యాక్() ఫంక్షన్ మూడుసార్లు పిలువబడింది. మూలకాలను చొప్పించడానికి ముందు మరియు తర్వాత వెక్టర్ యొక్క కంటెంట్ ముద్రించబడుతుంది.
//అవసరమైన లైబ్రరీలను చేర్చండి
#
#
ఉపయోగించి నేమ్‌స్పేస్ std ;
int ప్రధాన ( )
{
//స్ట్రింగ్ విలువల వెక్టర్‌ను ప్రకటించండి
వెక్టర్ < స్ట్రింగ్ > పక్షులు = { 'గ్రే పారెట్' , 'డైమండ్ డోవ్' , 'కాక్టెయిల్' } ;
కోట్ << 'చొప్పించడానికి ముందు వెక్టర్ యొక్క విలువలు: \n ' ;
//విలువలను ముద్రించడానికి లూప్‌ని ఉపయోగించి వెక్టార్‌ని మళ్ళించండి
కోసం ( int i = 0 ; i < పక్షులు. పరిమాణం ( ) ; ++ i )
కోట్ << పక్షులు [ i ] << '' ;
కోట్ << ' \n ' ;
/*
వెక్టార్ చివరిలో మూడు విలువలను జోడించండి
push_back() ఫంక్షన్‌ని ఉపయోగిస్తోంది
*/
పక్షులు. వెనుకకు నెట్టడం ( మేనా ) ;
పక్షులు. వెనుకకు నెట్టడం ( 'బడ్జీలు' ) ;
పక్షులు. వెనుకకు నెట్టడం ( 'కాకితువ్వ' ) ;
కోట్ << 'చొప్పించిన తర్వాత వెక్టర్ యొక్క విలువలు: \n ' ;
//విలువలను ముద్రించడానికి లూప్‌ని ఉపయోగించి వెక్టార్‌ని మళ్ళించండి
కోసం ( int i = 0 ; i < పక్షులు. పరిమాణం ( ) ; ++ i )
కోట్ << పక్షులు [ i ] << '' ;
కోట్ << ' \n ' ;
తిరిగి 0 ;
}
అవుట్‌పుట్:
పై కోడ్‌ని అమలు చేసిన తర్వాత క్రింది అవుట్‌పుట్ కనిపిస్తుంది. వెక్టార్ చివరిలో మూడు కొత్త మూలకాలు చొప్పించబడినట్లు అవుట్‌పుట్ చూపిస్తుంది.
ఉదాహరణ-2: ఇన్‌పుట్ ద్వారా వెక్టార్‌లోకి విలువలను చొప్పించండి
వినియోగదారు నుండి విలువలను తీసుకోవడం ద్వారా మరియు push_back() ఫంక్షన్‌ని ఉపయోగించడం ద్వారా మూలకాన్ని ఖాళీ వెక్టర్‌లోకి చొప్పించడానికి క్రింది కోడ్‌తో C++ ఫైల్‌ను సృష్టించండి. కోడ్‌లో పూర్ణాంక డేటా రకం యొక్క ఖాళీ వెక్టర్ ప్రకటించబడింది. తరువాత, 'ఫర్' లూప్ వినియోగదారు నుండి 5 సంఖ్యలను తీసుకుంటుంది మరియు push_back() ఫంక్షన్‌ని ఉపయోగించి వెక్టార్‌లోకి సంఖ్యలను చొప్పిస్తుంది. చొప్పించిన తర్వాత వెక్టర్ యొక్క కంటెంట్ ముద్రించబడుతుంది.
//అవసరమైన లైబ్రరీలను చేర్చండి#
#
ఉపయోగించి నేమ్‌స్పేస్ std ;
int ప్రధాన ( )
{
//పూర్ణాంక వెక్టార్‌ని ప్రకటించండి
వెక్టర్ < int > intVector ;
//పూర్ణాంక సంఖ్యను ప్రకటించండి
int సంఖ్య ;
కోట్ << '5 సంఖ్యలను నమోదు చేయండి: \n ' ;
/*
5 పూర్ణాంకాల విలువలను చొప్పించడానికి లూప్‌ను 5 సార్లు మళ్ళించండి
push_back() ఫంక్షన్‌ని ఉపయోగించి వెక్టర్‌లోకి
*/
కోసం ( int i = 0 ; i < 5 ; i ++ ) {
ఆహారపు >> సంఖ్య ;
intVector. వెనుకకు నెట్టడం ( సంఖ్య ) ;
}
కోట్ << 'చొప్పించిన తర్వాత వెక్టర్ యొక్క విలువలు: \n ' ;
//విలువలను ముద్రించడానికి లూప్‌ని ఉపయోగించి వెక్టార్‌ని మళ్ళించండి
కోసం ( int i = 0 ; i < intVector. పరిమాణం ( ) ; ++ i )
కోట్ << intVector [ i ] << '' ;
కోట్ << ' \n ' ;
తిరిగి 0 ;
}
అవుట్‌పుట్:
పై కోడ్‌ని అమలు చేసిన తర్వాత క్రింది అవుట్‌పుట్ కనిపిస్తుంది. వినియోగదారు నుండి తీసుకున్న ఐదు సంఖ్యలు వెక్టర్‌లోకి చొప్పించబడినట్లు అవుట్‌పుట్ చూపిస్తుంది.
ఉదాహరణ-3: నిర్దిష్ట పరిస్థితి ఆధారంగా వెక్టార్‌లో విలువలను చొప్పించండి
పూర్ణాంక శ్రేణి నుండి నిర్దిష్ట సంఖ్యలను ఖాళీ వెక్టర్‌లోకి చొప్పించడానికి క్రింది కోడ్‌తో C++ ఫైల్‌ను సృష్టించండి. కోడ్‌లో ఖాళీ వెక్టార్ మరియు 10 పూర్ణాంకాల సంఖ్యల శ్రేణి ప్రకటించబడ్డాయి. శ్రేణి యొక్క ప్రతి విలువను పునరావృతం చేయడానికి మరియు సంఖ్య 30 కంటే తక్కువ లేదా 60 కంటే ఎక్కువ ఉంటే push_back() ఫంక్షన్‌ని ఉపయోగించి వెక్టార్‌లోకి సంఖ్యను ఇన్సర్ట్ చేయడానికి 'for' లూప్ ఉపయోగించబడుతుంది. వెక్టర్ యొక్క కంటెంట్‌ని ఉపయోగించి ముద్రించబడుతుంది చొప్పించిన తర్వాత display_vector() ఫంక్షన్.
//అవసరమైన లైబ్రరీలను చేర్చండి#
#
ఉపయోగించి నేమ్‌స్పేస్ std ;
//వెక్టార్‌ని ప్రదర్శించు
శూన్యం డిస్ప్లే_వెక్టర్ ( వెక్టర్ < int > సంఖ్యలు )
{
//లూప్ ఉపయోగించి వెక్టర్ విలువలను ముద్రించండి
కోసం ( దానంతట అదే అతను = సంఖ్యలు. ప్రారంభం ( ) ; అతను ! = సంఖ్యలు. ముగింపు ( ) ; అతను ++ )
కోట్ << * అతను << '' ;
//కొత్త లైన్ జోడించండి
కోట్ << ' \n ' ;
}
int ప్రధాన ( )
{
//పూర్ణాంక వెక్టార్‌ని ప్రకటించండి
వెక్టర్ < int > intVector ;
//సంఖ్యల శ్రేణిని ప్రకటించండి
int నాఅరే [ 10 ] = { 9 , నాలుగు ఐదు , 13 , 19 , 30 , 82 , 71 , యాభై , 35 , 42 } ;
/*
శ్రేణిలోని ప్రతి మూలకాన్ని చదవడానికి లూప్‌ను మళ్ళించండి
మరియు ఆ విలువలను వెక్టర్‌లోకి చొప్పించండి
30 కంటే తక్కువ మరియు 60 కంటే ఎక్కువ
push_back() ఫంక్షన్‌ని ఉపయోగిస్తోంది
*/
కోసం ( int i = 0 ; i < 10 ; i ++ ) {
ఉంటే ( నాఅరే [ i ] < 30 || నాఅరే [ i ] > 60 )
intVector. వెనుకకు నెట్టడం ( నాఅరే [ i ] ) ;
}
కోట్ << 'చొప్పించిన తర్వాత వెక్టర్ విలువలు:' << endl ;
డిస్ప్లే_వెక్టర్ ( intVector ) ;
తిరిగి 0 ;
}
అవుట్‌పుట్:
పై కోడ్‌ని అమలు చేసిన తర్వాత క్రింది అవుట్‌పుట్ కనిపిస్తుంది. 9, 13, 19, 82 మరియు 71 సంఖ్యలు వెక్టార్‌లోకి చొప్పించబడినట్లు అవుట్‌పుట్ చూపిస్తుంది.
ముగింపు:
ప్రారంభంలో లేదా ముగింపులో డేటాను ఇన్సర్ట్ చేయడానికి C++లో అనేక ఫంక్షన్‌లు ఉన్నాయి లేదా పుష్_ఫ్రంట్(), ఇన్సర్ట్(), మొదలైన వెక్టర్ యొక్క ఏదైనా నిర్దిష్ట స్థానం. ఈ ట్యుటోరియల్‌లో చూపిన ఉదాహరణలను ప్రాక్టీస్ చేసిన తర్వాత push_back() ఫంక్షన్‌ని ఉపయోగించడం క్లియర్ చేయబడుతుంది. .