Stack and its Applications (Lecture 07)-aG0HjeXBUDU

 C ++ ప్రోగ్రామింగులో  మాడ్యూల్ 5 కు స్వాగతం.
 మీరు సాధారణంగా సి లో వ్రాసిన వివిధ ఉదాహరణ ప్రోగ్రామ్‌లను మేము చర్చిస్తున్నాము మరియు ఇప్పుడు వాటిని సి ++ లో ఎలా వ్రాయవచ్చో చూపిస్తున్నాము.
 దీని కోసం సి ++ ప్రామాణిక లైబ్రరీని ఎంత తరచుగా ఉపయోగించవచ్చో మరియు దీనితో, సి ++ ప్రోగ్రామింగ్ సౌలభ్యాన్ని ఎలా పెంచుతుందో చూపించాలనుకుంటున్నాము.
 కాబట్టి, ఈ మాడ్యూల్‌లో మనం స్టాక్‌లు మరియు దాని అనువర్తనాల గురించి మాట్లాడుతాము.
 సి లో స్టాక్ అమలు మరియు వాడకాన్ని అర్థం చేసుకోవడానికి మేము ప్రయత్నిస్తాము, ఇది మీ అందరికీ తెలుసు, ఆపై సి ++ లో ప్రామాణిక స్టాక్ లైబ్రరీని ఎలా ఉపయోగించవచ్చో చూపిస్తాము.
 అందువల్ల, ఇవి స్ట్రింగ్ (స్ట్రింగ్) ను రివర్స్ చేయడం ద్వారా పోస్ట్‌ఫిక్స్ వ్యక్తీకరణను ఉదాహరణగా అంచనా వేసే అంశాలు.
 స్టాక్ పరిచయంపై, రీక్యాప్ చేయడానికి.
 స్టాక్ అనేది LIFO నిర్మాణం; డేటా అంశాల యొక్క ఏకపక్ష సంఖ్యల సేకరణను నిర్వహించే చివరి-మొదటి-మొదటి కంటైనర్.
 శ్రేణిలో పరిమితులు లేవు; శ్రేణుల పరిమాణాన్ని బట్టి నేను ఎన్ని అంశాలను ఉంచగలను అనే దానిపై పరిమితులు ఉన్నాయి.
 ఎటువంటి నిర్వచనం లేకుండా స్టాక్ చేయండి, స్టాక్‌లో ఉండే అన్ని ఎలిమెంట్ డేటా ఎలిమెంట్స్ ఒకే రకంగా ఉండాలి, కాని నేను ఎన్ని మూలకాలను కలిగి ఉంటాను.
 కాబట్టి, సి లో స్టాక్ చేయడానికి, మనం చేయాలి; ఇవి మనం అనుసరించాల్సిన సాధారణ దశలు.
 మొదట మనం మూలకం యొక్క డేటా రకాన్ని నిర్ణయించాలి, ఒక నిర్మాణం లేదా కంటైనర్‌ను నిర్వచించాలి, వాస్తవానికి సి లో మనం కొంత గరిష్ట పరిమాణాన్ని ఉపయోగించాల్సి ఉంటుంది, లేకపోతే సి కంపైలర్ దీనిని నిర్వచించటానికి అనుమతించదు, శీర్షాన్ని ప్రకటించండి స్టాక్ (స్టాక్) పైభాగాన్ని నిర్వహించే వేరియబుల్ మరియు ఆ స్టాక్ (స్టాక్) యొక్క ఆపరేషన్ కోసం అవసరమైన నాలుగు ఫంక్షన్లను వ్రాయాలి.
 ఫంక్షన్ పుష్, ఇది స్టాక్‌కు ఒక మూలకాన్ని జోడిస్తుంది; ఫంక్షన్ పాప్, ఇది అగ్ర మూలకాన్ని తొలగిస్తుంది, మూలకం చివరిగా జోడించబడింది; ఫంక్షన్ టాప్, ఇది తీసివేయకుండా నాకు చాలా ఎక్కువ మూలకాన్ని ఇస్తుంది, చివరకు, మనకు ఒక ఫంక్షన్ (ఫంక్షన్) isempty () లేదా ఖాళీగా ఉండాలి, ఇది స్టాక్ (స్టాక్) లో ఏదైనా మూలకాలను కలిగి ఉంటే నాకు తెలియజేస్తుంది. కాదు.
 కాబట్టి, isempty () నిజమైతే, పాప్ మరియు టాప్ వంటి ఆపరేషన్లు చెల్లవు ఎందుకంటే తొలగించడానికి లేదా తిరిగి రావడానికి అగ్ర మూలకం లేదు.
 అందువల్ల, మేము స్టాక్ కోసం మూలకాల రకాన్ని మార్చిన వెంటనే, మనం తిరిగి దరఖాస్తు చేసుకోవాలి, స్టాక్ యొక్క మొత్తం కోడ్‌ను తిరిగి వ్రాయాలి, ఇది పూర్ణాంకం యొక్క స్టాక్. (స్టాక్) కోసం కోడ్ స్టాక్, మరియు స్టాక్ (స్టాక్) కోసం కోడ్ తీగలను స్టాక్ భిన్నంగా ఉంటుంది, అయినప్పటికీ LIFO యొక్క ప్రాథమిక umption హ రెండు సందర్భాల్లోనూ చెల్లుతుంది.
 కాబట్టి, సి స్టాండర్డ్ లైబ్రరీలో మనకు ఉన్న ఈ ఫంక్షన్లన్నింటికీ కాకుండా, గణితంలో మనం ఇంతకుముందు చూశాము, మనకు చాలా లైబ్రరీ ఫంక్షన్లు ఉన్నాయి.
 కాబట్టి, నేను గుర్తును లెక్కించాలనుకుంటే లేదా వర్గమూలాన్ని లెక్కించాలనుకుంటే లేదా ఆర్క్టాన్‌ను లెక్కించాలనుకుంటే, నేను ఆ ఫంక్షన్‌ను (ఫంక్షన్) వ్రాయవలసిన అవసరం లేదు, నేను దానిని లైబ్రరీ నుండి మాత్రమే ఉపయోగించగలను.
 దీనికి విరుద్ధంగా, సి స్టాండర్డ్ లైబ్రరీ నాకు స్టాక్‌ను ఉపయోగించటానికి ఒక యంత్రాంగాన్ని ఇవ్వదు.
 నేను వెంటనే ఉపయోగించగల స్టాక్ నాకు ఇవ్వదు.
 కాబట్టి, సి ప్రోగ్రామింగ్‌తో ప్రస్తుత పరిస్థితుల పరిస్థితి ఇది.
 కాబట్టి, ఈ సందర్భంలో, మీరు C ++ ఉపయోగిస్తే విషయాలు ఎలా మారతాయో చూడటానికి మేము ప్రయత్నిస్తాము.
 కాబట్టి, స్టాక్ ఉపయోగించి పరిష్కరించడానికి మేము ప్రయత్నించిన కొన్ని సాధారణ సమస్యలపై కూడా దృష్టి పెడదాం.
 నేను ఎడమ నుండి కుడికి క్రమంలో ఉన్న స్ట్రింగ్‌ను రివర్స్ చేయాలనుకుంటున్నాను, ఇది ఎడమ నుండి కుడికి మార్చాలనుకుంటున్నాను ఒక నిర్దిష్ట ప్రోగ్రామ్.
 మరొక పోస్ట్‌ఫిక్స్ అనేది వ్యక్తీకరణల మూల్యాంకనం, ఆపరేటర్లు ఒపెరాండ్ల మధ్య ఉన్న చోట మేము సాధారణంగా వ్యక్తీకరణలను అఫిక్స్ సంజ్ఞామానం తో వ్రాస్తాము.
 కాబట్టి, నేను ఈ వ్యక్తీకరణను అంచనా వేయాలనుకుంటే 1 + 2 * 3 - 4 ఉదాహరణను చూపిస్తున్నాను; మేము వ్యక్తీకరణను ఎడమ నుండి కుడికి చదివినప్పటికీ, దాన్ని అంచనా వేయడానికి వెళ్ళినప్పుడు మనం దానిని ఎడమ నుండి కుడికి ఖచ్చితంగా అంచనా వేయలేము.
 నక్షత్రం గుణకారం అదనంగా మరియు వ్యవకలనం కంటే ఎక్కువ ప్రాధాన్యతనిస్తుందని మాకు తెలుసు.
 కాబట్టి, మొదట మనం 2 తో 3 తో ​​గుణించాలి, ఫలితం 6 ను పొందాలి, ఆపై మనకు ప్లస్ మరియు మైనస్ ఉన్నాయి, ఇవి రెండూ ఒకే పూర్వజన్మను కలిగి ఉంటాయి, కానీ అవి అనుబంధంగా ఉంటాయి.
 అందువల్ల, మనం ఎడమ నుండి కుడికి కదిలి, ఫలితం 3 అవుతుందని లెక్కించాలి.
 కాబట్టి, మనం వ్యక్తీకరణను ఎలా వ్రాస్తామో పరంగా ఇన్ఫిక్స్ సంజ్ఞామానం చాలా మంచిది.
 ఈ వ్యక్తీకరణలను వ్రాయడానికి మరియు దానిని అంచనా వేయడానికి BODMAS నియమాలను అనుసరించడానికి మా పాఠశాల రోజుల నుండి మాకు నేర్పించాం, కాని పోస్ట్‌ఫిక్స్ వ్యక్తీకరణలను అంచనా వేయడం చాలా కష్టమవుతుంది ఎందుకంటే ఆపరేటర్ల క్రమాన్ని అమలు చేయాలి, ఇది అసోసియేషన్ ఆధారంగా వారి ప్రాధాన్యత.
 అందువల్ల, మేము పోస్ట్ఫిక్స్ సంజ్ఞామానం అని పిలువబడే వేరే సంజ్ఞామానాన్ని ఆశ్రయిస్తాము.
 పోస్ట్‌ఫిక్స్ సంజ్ఞామానం లో, ఇది మొదట ఒపెరాండ్ పేర్కొనబడి, ఆపై ఆపరేటర్ వస్తాడు. అందుకే ఇది పోస్ట్‌ఫిక్స్.
 కాబట్టి, నాకు సి ఆపరేటర్ ఉంటే, దాని కోసం ఒపెరాండ్ ఇప్పటికే జరిగింది.
 కాబట్టి, ఆపరేటర్‌కు శ్రేణి 2 ఉంటే, ఆ ఆపరేటర్‌కు 2 ఆపరేటర్ ఒపెరాండ్‌లు వెంటనే వర్తింపజేయాలని నాకు తెలుసు.
 కాబట్టి, ఇక్కడ ఇచ్చిన సమాచారంతో భర్తీ చేయబడిన ఈ వ్యక్తీకరణను నేను చూస్తే, నా వ్యక్తీకరణ 1 2 3 * + 4 - మరియు ఇది ఇన్ఫిక్స్ను ఎలా మార్చాలో కూడా ఒక సమస్య అని మీరు చూడగల ఉదాహరణను ఇక్కడ చూపిస్తాము. వ్యక్తీకరణ ఉపసర్గ వ్యక్తీకరణకు.
 ఇది స్టాక్‌ను ఉపయోగించి కూడా పరిష్కరించవచ్చు, కాని ఇక్కడ పోస్ట్‌ఫిక్స్ వ్యక్తీకరణ ఇచ్చినట్లయితే, స్టాక్‌ను ఉపయోగించి దాన్ని ఎలా అంచనా వేస్తామో చూపిస్తాము.
 కాబట్టి, ఇవన్నీ మనం చేయగలిగినవి చేయగల వేర్వేరు స్టాక్‌లు; వ్యక్తీకరణను ఎడమ నుండి కుడికి స్కాన్ చేయండి, ఉచిత ఒపెరాండ్ తీసుకోండి, దాన్ని స్టాక్‌లోకి చొప్పించండి, మేము ఆపరేటర్‌లోకి వచ్చే వరకు స్టాకింగ్ ఉంచండి.
 కాబట్టి, ఇక్కడ మనం 1 పుష్ (పుష్) ఇస్తాము, తరువాత మనం 2 పుష్ (పుష్) ఇస్తాము, తరువాత 3 పుష్ (పుష్) ఇస్తాము, ఆపై 2 నిర్వచనాలు ఉన్న ఆపరేటర్ స్టార్ వద్దకు వస్తాము.
 కాబట్టి, దీనికి చివరి 2 ఒపెరాండ్ అవసరమని నాకు తెలుసు, మేము ఈ 2 ని పాప్ చేస్తాము.
 3 శక్తిని పొందడానికి 6 ను పొందండి మరియు దానిని వెనక్కి నెట్టండి.
 అప్పుడు మనకు ప్లస్ నెక్స్ట్ ఆపరేటర్ వస్తుంది.
 అందువల్ల, రెండు ఒపెరాండ్‌లు కూడా అవసరమని మాకు తెలుసు.
 కాబట్టి, మేము 6 మరియు 1 ని పాప్ చేస్తాము, స్టాక్ ఖాళీ అవుతుంది, 7 ను పొందటానికి మేము దానిని ప్లస్ తో ఆపరేట్ చేస్తాము మరియు దానిని వెనుకకు నెట్టేస్తాము మరియు ఫలితాన్ని పొందడానికి మేము ఈ విధంగా కదులుతాము.
 అందువల్ల, చూడటానికి మంచి ఉదాహరణ ఏమిటంటే, స్టాక్ యొక్క విభిన్న విధులను ఉపయోగించి మనం ముందుకు సాగాలి, ఇది మనకు అందుబాటులో ఉన్న పోస్ట్‌ఫిక్స్ వ్యక్తీకరణను వాస్తవంగా లెక్కిస్తుంది.
 అదేవిధంగా, రెండు వైపుల నుండి ఒకే విధమైన పఠనం ఉన్న, మధ్యలో ఒక ప్రత్యేక పాత్ర అయిన సెంటర్ మార్కర్‌తో లేదా లేకుండా, పాలిండ్రోమ్ యొక్క గుర్తింపు వంటి అనేక ఇతర సమస్యలను స్టాక్ ఉపయోగించి గుర్తించవచ్చు. వాస్తవానికి, ఇన్ఫిక్స్ వ్యక్తీకరణ పోస్ట్‌ఫిక్స్ ద్వారా లోతుగా అన్వేషించవచ్చు మరియు ఒక ఉదాహరణ చాలా ఉంది.
 కాబట్టి, ఏదైనా సాఫ్ట్‌వేర్ సిస్టమ్ యొక్క ప్రోగ్రామింగ్‌లో స్టాక్ ఒక ముఖ్యమైన పాత్ర పోషిస్తుంది మరియు అందువల్ల, స్టాక్‌ను ఉపయోగించడానికి మీకు అనుకూలమైన, నమ్మదగిన, దృ mechan మైన యంత్రాంగం ఉంటే మేము గట్టిగా ప్రయోజనం పొందుతాము.అప్పుడు సి ++ మాకు రెడీమేడ్‌గా ఇస్తుంది పరిష్కారం.
 కాబట్టి, స్ట్రింగ్ రివర్స్ చేయడాన్ని చూద్దాం.
 ఇది మీ కోసం రీక్యాప్ కంటే ఎక్కువ, ఇది స్ట్రింగ్ రివర్స్ చేయడానికి ప్రయత్నిస్తున్న సి ప్రోగ్రామ్, ఎందుకంటే స్టాక్ ఒక నిర్మాణంగా నిర్వచించబడిందని మీరు చూడవచ్చు, మూలకాల కంటైనర్ మరియు మార్కర్ అయిన మార్కర్ ఉన్న శ్రేణిని కలిగి ఉంటుంది. అత్యధిక మూలకం యొక్క ప్రస్తుత సూచికను నిర్వహించే సూచిక, మరియు ఈ నాలుగు ఫంక్షన్ల అమలు ఖాళీ, టాప్, బుష్ మరియు పాప్; శీర్ష విలువ -1 అని ఖాళీగా తనిఖీ చేస్తుంది; -1 మూలకాలు లేవని సూచిస్తుంది ఎందుకంటే శ్రేణి (శ్రేణి) కనిష్ట సూచిక విలువను 0 కలిగి ఉంటుంది.
 అందువల్ల, ఇది మైనస్ 1 అయితే, స్టాక్ ఖాళీగా ఉందని మేము నిర్దేశిస్తాము.
 పైభాగం మూలకాన్ని ఎగువ స్థానం నుండి తిరిగి ఇస్తుంది; పుష్ గరిష్ట స్థానాన్ని పెంచుతుంది మరియు స్టాక్‌లోని స్టాక్‌కు జోడించబడిన క్రొత్త మూలకాన్ని తిరిగి ఇస్తుంది మరియు పాప్ కేవలం టాప్ పాయింట్ లేదా టాప్ ఇండెక్స్‌ను తీసివేస్తుంది.
అందువల్ల, పైభాగా పరిగణించబడిన మూలకం ఇప్పటికీ పైభాగా పరిగణించబడలేదు, దాని క్రింద ఉన్న మూలకం వెంటనే పైభాగా పరిగణించబడుతుంది మరియు స్టాక్ ఇప్పటికే ఉంటే మేము ఈ ఆపరేషన్ చేయలేము కాబట్టి ఖాళీగా ఉంటే, ఏమిటో తనిఖీ చేయడం మంచిది క్రింద? మేము నిజంగా పాప్ ఆపరేషన్ చేయడానికి ముందు స్టాక్ ఖాళీగా ఉంది.
 ఇప్పుడు అది; మీరు ఇక్కడ ABCDE స్ట్రింగ్ ఉపయోగిస్తుంటే, మేము ఒక లూప్‌లోకి వెళ్లి, ఈ అక్షరాలన్నింటినీ ABCD మరియు E లను ఒకదాని తరువాత ఒకటి స్టాక్‌లో చేర్చగలమని మనందరికీ తెలుసు. 
 ఆపై మనం టాప్ ఎలిమెంట్‌ను గుర్తించి, ఆ పైభాగాన్ని పాపింగ్ చేస్తే మూలకం, అప్పుడు E ఖచ్చితంగా చివరిగా జోడించబడుతుంది.
 కాబట్టి, అది మొదట బయటకు రాకముందే D జతచేయబడుతుంది, కాబట్టి ఇది తరువాత బయటకు వస్తుంది మరియు దాని ఫలితంగా మనం ఇక్కడ చూపిస్తున్న స్ట్రింగ్ వస్తుంది, ఇది EDCBA మరియు మనందరికీ దాని గురించి బాగా తెలుసు.
 కాబట్టి, మీరు రివర్స్ స్ట్రింగ్‌ను ప్రోగ్రామ్ చేయాలనుకుంటే ఇదే మార్గం, మీరు ఈ ప్రధాన ఫంక్షన్ (ఫంక్షన్) లేదా ఫంక్షన్ (ఫంక్షన్) ను వ్రాయవలసి ఉంటుంది, ఇది స్ట్రింగ్ రివర్స్ చేయడానికి స్టాక్, ఉపయోగాలు, మీరు ఇచ్చిన కోడ్‌ను కూడా వ్రాయాలి .
 సి లోని దృష్టాంతమైన ఎడమ కాలమ్‌లో, పోస్ట్‌ఫిక్స్ వ్యక్తీకరణను అంచనా వేయడానికి ఇలాంటి దృశ్యం ఇవ్వబడుతుంది, మళ్ళీ సి ఎడమ కాలమ్‌లోని మునుపటి ఉదాహరణతో సమానంగా ఉంటుంది, ఇక్కడ స్టాక్ అమలు ఇవ్వబడుతుంది మరియు కుడి కాలమ్ ఇవ్వబడుతుంది. 
 ఇది నేను రెండు స్లైడ్‌లకు వివరించిన అల్గోరిథం కోడ్ మాత్రమే; మీరు దాని ద్వారా వెళ్లి మాకు నిజంగా ఏమి పని చేస్తుందో అర్థం చేసుకోవచ్చు.
 మీరు ఈ పాయింట్‌పై ప్రత్యేకంగా దృష్టి పెడితే, ఈ సమయంలో ఏదైనా ఆపరేషన్ ఉందా అని తెలుసుకోవడానికి ఇది పనిచేస్తుంది.
 వ్యక్తీకరణలోని కొన్ని అక్షరాలు ఒపెరాండ్స్ కాదా అని మేము గుర్తించామని మీరు చూస్తారు.
 కాబట్టి, ఇది అంకె అయితే దాన్ని న్యూమరేటర్‌గా పరిగణిస్తారు.
 కాబట్టి, ఈ వ్యక్తీకరణలో, ప్రతి అంకె ch అయితే, అది ఒక అంకె కాదా అనేది ఒక ఒపెరాండ్, ఒకే అంకెల ఒపెరాండ్, ఆపై మనం దానిని పుష్ (పుష్) ఇవ్వగలము, లేకపోతే మనం హుహ్ అని భావిస్తాము.
 ఇది ఒక ఆపరేటర్ అని మాకు తెలుసు మరియు ఆ ఆపరేటర్ ప్రకారం అది అగ్రశ్రేణి అంశాలను కనుగొని తీసుకుంటుంది, వాటిని బయటకు తీసుకొని ఫలితాన్ని లెక్కించి వెనక్కి నెట్టివేస్తుంది.
 పోస్ట్‌ఫిక్స్ వ్యక్తీకరణ యొక్క సాధారణ కోడ్ చాలా క్లిష్టంగా ఉంటుంది ఎందుకంటే మీరు ఆపరేటర్ యొక్క యోగ్యతలను కూడా పరిగణనలోకి తీసుకోవాలి మరియు దాని ఆధారంగా మాకు నాలుగు ఆపరేటర్లు తెలుసు, ఆపరేటర్ బైనరీ.
 కాబట్టి, ఆ పైల్స్ అన్నీ ఇక్కడ లేవు.
 ఇప్పుడు, సి ++ లో ఏమి జరుగుతుందో చూద్దాం.
 C ++ లో, మంచి విషయం ఏమిటంటే, C ++ ప్రామాణిక లైబ్రరీ మాకు రెడీమేడ్ స్టాక్‌ను అందిస్తుంది.
 కాబట్టి, ఆ స్టాక్‌ను సృష్టించడం లేదా మనం చేయవలసిన స్టాక్‌ను ఉపయోగించడం అంటే స్టాక్ (స్టాక్) హెడర్ అని పిలువబడే కొత్త హెడర్‌ను చేర్చడం.
 స్టాక్ శీర్షికలో నిర్వచించబడిన స్టాక్‌ను వేగవంతం చేసి, ఆపై ఆ స్టాక్ (స్టాక్) ఆబ్జెక్ట్ యొక్క ఫంక్షన్లను ఉపయోగించడం ప్రారంభించండి మరియు మనకు స్టాక్ (స్టాక్) సిద్ధంగా ఉంటుంది.
 కాబట్టి, ఇక్కడ మేము రివర్స్ స్ట్రింగ్ ఉదాహరణను చూపిస్తున్నాము.
 మళ్ళీ కుడి వైపున సి ప్రోగ్రామ్ ఉంది, మనం ఇప్పటికే చర్చించిన మరియు ఇక్కడ చూపించని స్టాక్ కోడ్, స్టాక్ (స్టాక్) వాడకం రివర్స్ స్టాకింగ్ విషయంలో మాత్రమే చూపబడుతుంది. మరియు సమానమైన కోడ్ ఎడమ చేతిలో వ్రాయబడుతుంది వైపు.
 ఇక్కడ, దయచేసి C ++ కోడ్‌లో, మేము స్టాక్ కోడ్‌ను వ్రాయవలసిన అవసరం లేదు, బదులుగా మనం చేయడానికి ప్రయత్నిస్తున్నది నిర్దిష్ట శీర్షికను కలిగి ఉంటుంది.
 ఈ హెడర్ స్టాక్‌ను కలిగి ఉంది, ఇది స్టాక్ హెడర్‌ను కలిగి ఉంది.
 మేము చేర్చాము, ఇందులో స్టాక్ నిర్వచనాలు ఉన్నాయి మరియు ఈ విధంగా మేము స్టాక్‌ను ఆపుతాము.
 మేము శ్రేణులకు విరుద్ధంగా వెక్టర్స్ గురించి మాట్లాడినప్పుడు మీరు ఈ సంజ్ఞామానాన్ని చూశారు, మీరు గమనించారా, నాకు వెక్టర్ ఉంటే మూలకం రకాన్ని మూలలో బ్రాకెట్‌లో సమానంగా ఉంచగలను, ఈ కోణ బ్రాకెట్‌లో నాకు స్టాక్ ఉంటే, అప్పుడు మేము చూపిస్తున్నాము స్టాక్ ఏ రకమైన మూలకంతో తయారు చేయబడింది మరియు స్టాక్ వస్తువులకు s అని పేరు పెట్టబడుతుంది.
 ఇప్పుడు, మేము దానిని ఎలా ఉపయోగిస్తాము అనే దానిపై దృష్టి పెడతాము.
 ఇక్కడ సి లో, మీరు నెట్టాలనుకుంటే, మేము రెండు పారామితులను పాస్ చేయాలి, స్టాక్ అంటే ఏమిటి, ఇది చిరునామా మరియు మనం నెట్టాలనుకునే మూలకం ఏది.
 ఇక్కడ, మేము డాట్; వెక్టర్ సందర్భంలో మీరు ఈ సంజ్ఞామానాన్ని కూడా క్లుప్తంగా చూశారు, కాని మేము దీని గురించి మరింత మాట్లాడుతాము, కానీ ఇది ఒక నిర్దిష్ట సంజ్ఞామానం; మేము నిర్మాణాలలో ఏమి ఉపయోగిస్తున్నామో, కానీ కొంత భిన్నంగా వివరించబడుతుందనే like హ వలె, s.push () ఇది స్టాక్ (ల) లో, నేను నెట్టాలనుకుంటున్నాను (నెట్టడం) మరియు నేను ఏమి నెట్టాలనుకుంటున్నాను? నేను ప్రత్యేకమైన మూలకం అయిన str ని నెట్టాలనుకుంటున్నాను.
 అదేవిధంగా, నేను దీన్ని ఇక్కడ చేయాలనుకుంటే, నేను ఖాళీగా ఉన్న శూన్యతను తనిఖీ చేయాలనుకుంటున్నాను.
 దీనికి విరుద్ధంగా, ఇక్కడ నేను చూడగలిగే విధంగా నేను s.empty () చేస్తాను.
 కాబట్టి, కోడ్ సందర్భంలో స్టాక్ ఉపయోగించే కోడ్ చాలా సారూప్యంగా ఉందని మీరు చూడవచ్చు మరియు వాస్తవానికి మనం అర్థం చేసుకోగలిగినట్లుగా కోడ్ రాయడం చాలా సులభం ఎందుకంటే నాకు సి వంటి పునరావృత పారామితులు లేవు, నేను ఎక్కడ పాస్ చేయాలి పారామితులు, ప్రతి పాయింట్ వద్ద స్టాక్‌కు పాయింటర్ మరియు నేను ఫంక్షన్ కాల్ వెలుపల ఉంచవచ్చు మరియు పుష్ విషయంలో అవసరమైన పారామితులను పాస్ చేయవచ్చు ఒక పరామితి; మిగిలిన కేసులో పారామితులు అవసరం లేదు.
 చివరగా, C లో కూడా గమనించండి, మేము స్టాక్‌ను నిర్వచించినప్పుడు; మేము మైనస్ 1 యొక్క టాప్ మార్కర్‌ను కూడా ప్రారంభించాల్సిన అవసరం ఉంది.
 ఇక్కడ, సిస్టమ్ ఏదో ఒకవిధంగా జాగ్రత్త తీసుకుంటుంది మరియు కంపైలర్ దానిని చూసుకుంటుంది.
 కాబట్టి, ఈ అగ్ర మార్కర్‌ను ప్రారంభించడం గురించి నేను బాధపడవలసిన అవసరం లేదు.
 కాబట్టి, మేము ప్రామాణిక లైబ్రరీ నుండి స్టాక్‌ను ఉపయోగిస్తే, ప్రతిసారీ స్టాక్ కోడ్‌ను తిరిగి వ్రాయకుండా ఉండటంలో ప్రయోజనం ఉంది.
 ఈ పాయింట్లు ఇక్కడ క్రింద ఇవ్వబడ్డాయి మరియు బదులుగా, దీని కోసం మాకు బాగా పరీక్షించిన రెడీమేడ్ స్టాక్ అందుబాటులో ఉంది.
 మీరు తరువాతి ఉదాహరణలో చూస్తే నేను ముందుకు వెళ్తాను.
 ఇది మేము C లో చేసినట్లుగానే ఉంది, కాని ఇప్పుడు మేము C ++ లో పోస్ట్‌ఫిక్స్ వ్యక్తీకరణలో పోస్ట్‌ఫిక్స్ వ్యక్తీకరణను అంచనా వేయడానికి ఇలా చేస్తున్నాము మరియు ఈ కోడ్ మళ్ళీ మన వద్ద ఉన్న C కోడ్‌తో సమానంగా ఉంటుంది. స్టాక్ హెడర్ చేర్చడానికి వ్రాయబడింది మినహాయింపు, ఈ సంజ్ఞామానం తో స్టాక్‌ను నిర్వచించండి, ఆపై అన్ని స్టాక్ (స్టాక్) ఫంక్షన్లు (ఫంక్షన్) కొద్దిగా భిన్నమైన ఆకృతిలో వ్రాయబడతాయి, కాని కోడ్ లేకపోతే, ఎందుకంటే ఇది సి లో ఉంది మరియు మనకు ఏమీ చేయలేని ప్రయోజనంతో.
 సి స్టాక్ కోడ్ అమలు.
 కాబట్టి, ఈ మాడ్యూల్‌లో మేము చూపించినవి, మీరు సి ++ లో ప్రోగ్రామింగ్ చేస్తుంటే, స్టాక్‌ను ఉపయోగించడం ద్వారా మీకు పెద్ద ప్రయోజనం లభిస్తుంది.
 మీరు స్టాక్ కోడ్‌ను అమలు చేయవలసిన అవసరం లేదు; స్టాక్ కోసం కంటైనర్ యొక్క గరిష్ట పరిమాణం ఎలా ఉండాలో మీరు ఆందోళన చెందాల్సిన అవసరం లేదు.
 C ++ ప్రామాణిక లైబ్రరీ స్టాక్ స్వయంచాలకంగా దానిని చూసుకుంటుంది.
 ఆ శీర్షికను ఎలా ప్రారంభించాలో ఇది జాగ్రత్త తీసుకుంటుంది మరియు స్టాక్ కోసం నాకు అవసరమైన ఏ రకమైన మూలకానికైనా ఉపయోగించవచ్చు మరియు మొత్తం C ++ ప్రోగ్రామింగ్ మరియు ప్రామాణిక లైబ్రరీ (లైబ్రరీ యొక్క చాలా ఆసక్తికరమైన మరియు ఉత్తేజకరమైన భాగం) కథ లేదు దానితో ఆగవద్దు.
 క్యూ వంటి తరచుగా అవసరమయ్యే అన్ని సాధారణ డేటా నిర్మాణాలు వెలుపల ఉన్నాయి; క్యూక్, ఇది డబుల్ ఎండ్ క్యూ (క్యూ), ఇక్కడ మీరు ఒక క్రమం యొక్క రెండు చివరలను జోడించవచ్చు మరియు తీసివేయవచ్చు.
 జాబితా; ఒకే లింక్డ్ జాబితా, మ్యాప్, ఇది పేరు విలువ జత లాంటిది; సెట్, ఆర్డరింగ్ ముఖ్యం కానప్పుడు, మీరు దానిలోని యూనియన్‌ను దాటవచ్చు.
 ఈ డేటా నిర్మాణాలన్నీ సి ++ ప్రామాణిక లైబ్రరీలో రెడీమేడ్‌లో అందుబాటులో ఉన్నాయి.
 కాబట్టి, ప్రోగ్రామింగ్ భాష యొక్క వివరణాత్మక సూక్ష్మ నైపుణ్యాలను అర్థం చేసుకోవడానికి ముందు మేము C ++ లో ప్రోగ్రామింగ్ ప్రారంభించేటప్పుడు, C ++ ప్రామాణిక లైబ్రరీని మళ్లీ మళ్లీ పరిశీలించాలనుకుంటున్నాము.ఈ ప్రోగ్రామ్‌లన్నీ డేటా స్ట్రక్చర్‌లను ఉపయోగించే ప్రోగ్రామ్‌లను వ్రాస్తాయి మరియు మనవి ప్రోగ్రామింగ్ సులభం మరియు ఉపయోగించడానికి మరింత బలంగా ఉంది.