C ++ యొక్క వివిధ అంతర్నిర్మిత ఫంక్షన్లను ఉపయోగించడం ద్వారా వెక్టర్ యొక్క పరిమాణాన్ని తగ్గించవచ్చు. పాప్‌బ్యాక్ () ఫంక్షన్ వాటిలో ఒకటి. వెక్టర్ యొక్క చివరి మూలకాన్ని వెనుక నుండి తీసివేయడానికి మరియు వెక్టర్ పరిమాణాన్ని 1. తగ్గించడానికి ఇది ఉపయోగించబడుతుంది. అయితే వెక్టర్ యొక్క చివరి మూలకం ఎరేస్ () ఫంక్షన్ లాగా శాశ్వతంగా తొలగించబడదు. ఈ ఫంక్షన్ యొక్క వివిధ ఉపయోగాలు ఈ ట్యుటోరియల్‌లో వివరించబడ్డాయి.
వాక్యనిర్మాణం:
వెక్టర్::పాప్_బ్యాక్();ఈ ఫంక్షన్‌కు ఎటువంటి వాదన లేదు మరియు అది ఏమీ ఇవ్వదు.
ముందస్తు అవసరం:
ఈ ట్యుటోరియల్ యొక్క ఉదాహరణలను తనిఖీ చేయడానికి ముందు, మీరు సిస్టమ్‌లో g ++ కంపైలర్ ఇన్‌స్టాల్ చేయబడిందో లేదో తనిఖీ చేయాలి. మీరు విజువల్ స్టూడియో కోడ్‌ని ఉపయోగిస్తుంటే, ఎక్జిక్యూటబుల్ కోడ్‌ను సృష్టించడానికి C ++ సోర్స్ కోడ్‌ని కంపైల్ చేయడానికి అవసరమైన ఎక్స్‌టెన్షన్‌లను ఇన్‌స్టాల్ చేయండి. ఇక్కడ, C ++ కోడ్‌ను కంపైల్ చేయడానికి మరియు అమలు చేయడానికి విజువల్ స్టూడియో కోడ్ అప్లికేషన్ ఉపయోగించబడింది. పాప్‌బ్యాక్ () ఫంక్షన్‌ను ఉపయోగించి వెక్టర్ పరిమాణాన్ని తగ్గించే మార్గాలు ఈ ట్యుటోరియల్ యొక్క తదుపరి భాగంలో చూపబడ్డాయి.
ఉదాహరణ -1: వెక్టర్ నుండి బహుళ అంశాలను తొలగించండి
పాప్_బ్యాక్ () ఫంక్షన్ ఉపయోగించి వెక్టర్ పరిమాణాన్ని తగ్గించడం ద్వారా వెక్టర్ కంటైనర్ నుండి రెండు ఎలిమెంట్‌లను తీసివేయడానికి కింది కోడ్‌తో C ++ ఫైల్‌ని సృష్టించండి. కోడ్‌లో 5 స్ట్రింగ్ విలువల వెక్టర్ ప్రకటించబడింది. వెక్టర్ నుండి రెండు చివరి ఎలిమెంట్‌లను తాత్కాలికంగా తొలగించడానికి మరియు వెక్టర్ పరిమాణాన్ని తగ్గించడానికి పాప్‌బ్యాక్ () ఫంక్షన్ రెండుసార్లు ఇక్కడ పిలువబడింది. పాప్‌బ్యాక్ () ఫంక్షన్‌ను ఉపయోగించే ముందు మరియు తర్వాత వెక్టర్ కంటెంట్ రెండుసార్లు ముద్రించబడింది
// అవసరమైన లైబ్రరీలను చేర్చండి
#చేర్చండి
#చేర్చండి
ఉపయోగించి నేమ్‌స్పేస్గంటలు;
intప్రధాన() {
// స్ట్రింగ్ విలువల వెక్టర్‌ని ప్రకటించండి
వెక్టర్<స్ట్రింగ్>పువ్వులు= {'గులాబీ','లైటీ','బంతి పువ్వు','తులిప్','వాటర్ లియి'};
ఖరీదు << వెక్టర్ విలువలు: n';
// విలువలను ముద్రించడానికి లూప్‌ని ఉపయోగించి వెక్టర్‌ను గుర్తించండి
కోసం(inti= 0;i<పువ్వులు.పరిమాణం(); ++i)
ఖరీదు <<పువ్వులు[i] << '';
ఖరీదు << ' n';
// వెక్టర్ నుండి చివరి రెండు విలువలను తొలగించండి
పువ్వులు.పాప్_బ్యాక్();
పువ్వులు.పాప్_బ్యాక్();
ఖరీదు << ' nతీసివేసిన తర్వాత వెక్టర్ విలువలు: n';
// విలువలను ముద్రించడానికి లూప్‌ని ఉపయోగించి వెక్టర్‌ను గుర్తించండి
కోసం(inti= 0;i<పువ్వులు.పరిమాణం(); ++i)
ఖరీదు <<పువ్వులు[i] << '';
ఖరీదు << ' n';
తిరిగి 0;
}
అవుట్‌పుట్:
పై కోడ్‌ను అమలు చేసిన తర్వాత కింది అవుట్‌పుట్ కనిపిస్తుంది.
ఉదాహరణ -2: మరొక వెక్టర్ నుండి కొత్త వెక్టర్‌ను సృష్టించండి
పాప్_బ్యాక్ () ఫంక్షన్‌ని ఉపయోగించి మూలకాలను తీసివేయడం ద్వారా నిర్దిష్ట విలువలను మరొక వెక్టర్ నుండి ఖాళీ వెక్టర్‌లోకి చేర్చడానికి కింది కోడ్‌తో C ++ ఫైల్‌ని సృష్టించండి. 8 పూర్ణాంక సంఖ్యల వెక్టర్ మరియు పూర్ణాంక రకం ఖాళీ వెక్టర్ కోడ్‌లో ప్రకటించబడ్డాయి. 'అయితే' లూప్ మొదటి వెక్టర్‌లోని ప్రతి మూలకాన్ని పునరుద్ఘాటించడానికి మరియు సంఖ్యను 2 ద్వారా భాగిస్తే మూలకాన్ని కొత్త వెక్టర్‌లోకి చేర్చడానికి ఉపయోగించబడింది. అన్ని సరి సంఖ్యల మొత్తం కూడా ఇక్కడ లెక్కించబడుతుంది. లూప్ యొక్క ముగింపు స్థితిని చేరుకోవడానికి లూప్ యొక్క ప్రతి పునరుక్తిలో పాప్_బ్యాక్ () ఫంక్షన్ ద్వారా మొదటి వెక్టర్ యొక్క ప్రతి మూలకం తీసివేయబడుతుంది.
// అవసరమైన లైబ్రరీలను చేర్చండి
#చేర్చండి
#చేర్చండి
ఉపయోగించి నేమ్‌స్పేస్గంటలు;
intప్రధాన()
{
// పూర్ణాంక డేటా యొక్క వెక్టర్‌ని ప్రకటించండి
వెక్టర్<int>intVector{ 5,9,4,7,2,8,1,3 };
// ఖాళీ వెక్టర్‌ని ప్రకటించండి
వెక్టర్<int>కొత్త వెక్టర్;
ఖరీదు << 'అసలు వెక్టర్ విలువలు: n';
// విలువలను ముద్రించడానికి లూప్‌ని ఉపయోగించి వెక్టర్‌ను గుర్తించండి
కోసం(inti= 0;i<intVector.పరిమాణం(); ++i)
ఖరీదు <<intVector[i] << '';
ఖరీదు << ' n';
// ఫలితాన్ని ప్రారంభించండి
intఫలితం= 0;
// వెక్టర్ ఖాళీ అయ్యే వరకు లూప్‌ని మళ్లీ చేయండి
అయితే(!intVector.ఖాళీ())
{
/ *
కొత్త వెక్టర్‌లోకి చొప్పించడానికి సరి సంఖ్యలను కనుగొనండి
మరియు సరి సంఖ్యల మొత్తాన్ని లెక్కించండి
* /
ఉంటే (intVector.తిరిగి() % 2 == 0)
{
ఫలితం+=intVector.తిరిగి();
కొత్త వెక్టర్వెనుకకు నెట్టడం(intVector.తిరిగి());
}
// intVactor చివర నుండి మూలకాన్ని తొలగించండి
intVector.పాప్_బ్యాక్();
}
ఖరీదు << 'కొత్త వెక్టర్ విలువలు: n';
// విలువలను ముద్రించడానికి లూప్‌ని ఉపయోగించి వెక్టర్‌ను గుర్తించండి
కోసం(inti= 0;i<కొత్త వెక్టర్పరిమాణం(); ++i)
ఖరీదు <<కొత్త వెక్టర్[i] << '';
ఖరీదు << ' n';
ఖరీదు << 'అన్ని సరి సంఖ్యల మొత్తం:' <<ఫలితం<< ' n';
తిరిగి 0;
}
అవుట్‌పుట్:
పై కోడ్‌ను అమలు చేసిన తర్వాత కింది అవుట్‌పుట్ కనిపిస్తుంది. మొదటి వెక్టర్‌లో మూడు సరి సంఖ్యలు ఉన్నాయి. 8, 2 మరియు 4 ఉన్నాయి.
ఉదాహరణ -3: వెక్టర్ యొక్క చివరి మూలకం తీసివేయబడిందా లేదా అని తనిఖీ చేయండి
పాప్_బ్యాక్ () వెక్టర్ నుండి ఎలిమెంట్‌లను శాశ్వతంగా తీసివేయదని మరియు వెక్టర్ పరిమాణాన్ని మాత్రమే తగ్గించడం ద్వారా ఇది ఎలిమెంట్‌ను తీసివేస్తుందని ముందే పేర్కొనబడింది. కాబట్టి, వెక్టర్ పరిమాణం పెరిగి మూలకాన్ని మరొక మూలకంతో భర్తీ చేసే వరకు తీసివేయబడిన మూలకం అదే స్థితిలో ఉంటుంది. పాప్‌బ్యాక్ () ఫంక్షన్ ద్వారా తొలగించబడిన మూలకం ఉందో లేదో తనిఖీ చేయడానికి కింది కోడ్‌తో C ++ ఫైల్‌ని సృష్టించండి. పాప్_బ్యాక్ () ఫంక్షన్‌ను ఉపయోగించే ముందు మరియు తరువాత అసలు వెక్టర్ యొక్క చివరి స్థానం ముద్రించబడింది.
#చేర్చండి#చేర్చండి
ఉపయోగించి నేమ్‌స్పేస్గంటలు;
intప్రధాన()
{
// పూర్ణాంక డేటా యొక్క వెక్టర్‌ని ప్రకటించండి
వెక్టర్<int>intVector{ 54,19,46,72,22,83,10,53 };
// ఖాళీ వెక్టర్‌ని ప్రకటించండి
వెక్టర్<int>కొత్త వెక్టర్;
// ఒక పూర్ణాంక వేరియబుల్‌ని ప్రకటించండి
intపొడవు;
// వెక్టర్ పరిమాణం ఆధారంగా చివరి మూలకాన్ని ముద్రించండి
పొడవు=intVector.పరిమాణం();
ఖరీదు << 'వెక్టర్ యొక్క ప్రస్తుత పరిమాణం:' <<పొడవు<< ' n';
ఖరీదు << తొలగించడానికి ముందు వెక్టర్ యొక్క చివరి విలువ: ' <<intVector[పొడవు-1] << ' n';
// వెక్టర్ చివర నుండి మూలకాన్ని తొలగించండి
intVector.పాప్_బ్యాక్();
// తొలగించిన తర్వాత వెక్టర్ పరిమాణం ఆధారంగా చివరి మూలకాన్ని ముద్రించండి
పొడవు=intVector.పరిమాణం();
ఖరీదు << 'వెక్టర్ యొక్క ప్రస్తుత పరిమాణం:' <<పొడవు<< ' n';
ఖరీదు << తొలగించిన తర్వాత వెక్టర్ యొక్క చివరి విలువ: ' <<intVector[పొడవు] << ' n';
తిరిగి 0;
}
అవుట్‌పుట్:
పై కోడ్‌ను అమలు చేసిన తర్వాత కింది అవుట్‌పుట్ కనిపిస్తుంది. వెక్టర్ పరిమాణం 1 ద్వారా తగ్గించబడిందని అవుట్‌పుట్ చూపిస్తుంది, అయితే అసలు వెక్టర్ యొక్క చివరి స్థానం యొక్క మూలకం ఇప్పటికీ ఉంది.
ముగింపు:
పాప్_బ్యాక్ () ఫంక్షన్ యొక్క మూడు విభిన్న ఉపయోగాలు సాధారణ ఉదాహరణలను ఉపయోగించి ఈ ట్యుటోరియల్‌లో వివరించబడ్డాయి. ఈ ట్యుటోరియల్ యొక్క ఉదాహరణలను అభ్యసించిన తర్వాత ఈ ఫంక్షన్‌ను ఉపయోగించడం యొక్క ముఖ్య ఉద్దేశ్యం పాఠకుల కోసం క్లియర్ చేయబడుతుంది.