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