పరిచయం
క్యూ అనేది అంశాల సమాహారం, ఇక్కడ జాబితాలో చేర్చబడిన మొదటి అంశం తప్పనిసరిగా తీసివేయబడే మొదటి అంశం. ఐటెమ్‌లు సేకరణకు జోడించబడినప్పుడు, అది పరిమాణంలో పెరుగుతోంది, అనగా పొడవు పెరుగుతుంది. ఎప్పుడైనా ఏదైనా వస్తువు తీసివేయబడాలంటే, అది తప్పనిసరిగా జోడించబడిన మొదటిది. ఐటెమ్‌లు నిరంతరంగా తీసివేయబడితే, తర్వాత తీసివేయబడినది రెండవ అంశం; మూడవది తరువాత తీసివేయబడుతుంది మరియు మొదలైనవి.
అసలు జాబితాలోని మొదటి అంశం తీసివేయబడిన తర్వాత, రెండవది మొదటి అంశం అవుతుంది. రెండవ అంశం తీసివేయబడిన తర్వాత, మూడవది మొదటి అంశం అవుతుంది, మరియు అందువలన న.
సేవ కోసం లేదా మంచి కోసం వేచి ఉండటానికి ప్రజలు వరుసలో ఉన్నప్పుడు క్యూకు మంచి నిజ జీవిత ఉదాహరణ. మొదటి వ్యక్తికి చివరి వ్యక్తికి ముందుగా సేవ చేస్తారు. ఏదేమైనా, ఈ ట్యుటోరియల్‌లో క్యూ గురించి మాట్లాడబడింది, ఇది సి ++ లో రూపొందించినట్లుగా సాఫ్ట్‌వేర్ క్యూ.
FIFO
FIFO అంటే ఫస్ట్-ఇన్, ఫస్ట్-అవుట్. ఇది క్యూను ప్రశంసించడానికి మరొక మార్గం. దీని అర్థం, జాబితాలో ప్రవేశించిన మొదటి అంశం, తీసివేత జరిగినప్పుడు తొలగించాల్సిన మొదటి అంశం. జాబితా ప్రారంభాన్ని తల లేదా ముందు అని పిలుస్తారు; జాబితా ముగింపును వెనుక లేదా తోక అంటారు.
అవసరమైన కార్యకలాపాలు
ఒక సాఫ్ట్‌వేర్ క్యూ తప్పనిసరిగా కనీసం కింది కార్యకలాపాలను కలిగి ఉండాలి:
పుష్
ఈ ఆపరేషన్, క్యూ వెనుక భాగంలో కొత్త మూలకాన్ని జోడిస్తుంది. ఈ ఆపరేషన్‌ను అధికారికంగా ఎన్‌క్యూ అంటారు.
మార్పు
ఈ ఆపరేషన్ క్యూలోని మొదటి మూలకాన్ని తొలగిస్తుంది మరియు రెండవ మూలకం కొత్త మొదటి మూలకం అవుతుంది. ఈ ఆపరేషన్ అధికారికంగా dequeue అంటారు. దీనిని C ++ లో పాప్ అంటారు.
ఈ కథనం C ++ క్యూ డేటా నిర్మాణాన్ని ఎలా ఉపయోగించాలో వివరిస్తుంది. ఈ ఆర్టికల్‌ని అర్థం చేసుకోవడానికి మీరు C ++ పాయింటర్‌లు మరియు రిఫరెన్స్‌లను తెలుసుకోవాలి.
తరగతి మరియు వస్తువులు
క్లాస్ అనేది వేరియబుల్స్ మరియు ఫంక్షన్ల సమితి, ఇవి కలిసి పనిచేస్తాయి, ఇక్కడ వేరియబుల్స్‌కు కేటాయించిన విలువలు ఉండవు. వేరియబుల్స్‌కు విలువలు కేటాయించినప్పుడు, తరగతి ఒక వస్తువు అవుతుంది. ఒకే తరగతికి ఇచ్చిన విభిన్న విలువలు వేర్వేరు వస్తువులను కలిగిస్తాయి; అంటే, విభిన్న వస్తువులు ఒకే విలువ కలిగిన ఒకే తరగతి. తరగతి నుండి ఒక వస్తువును సృష్టించడం ఆ వస్తువును తక్షణం చెప్పడం.
పేరు, క్యూ, ఒక తరగతి. క్యూ క్లాస్ నుండి సృష్టించబడిన ఒక ఆబ్జెక్ట్ ప్రోగ్రామర్ ఎంచుకున్న పేరును కలిగి ఉంది.
తరగతికి చెందిన ఒక వస్తువును తరగతి నుండి తక్షణం అమలు చేయడానికి అవసరం. C ++ లో, ఆ ఫంక్షన్ క్లాస్ పేరు వలె అదే పేరును కలిగి ఉంటుంది. తరగతి నుండి సృష్టించబడిన (తక్షణం) ఆబ్జెక్ట్‌లు ప్రోగ్రామర్ ద్వారా వారికి వేర్వేరు పేర్లు ఇవ్వబడ్డాయి.
తరగతి నుండి ఒక వస్తువును సృష్టించడం అంటే వస్తువును నిర్మించడం; ఇది తక్షణం అని కూడా అర్థం.
క్యూ క్లాస్‌ని ఉపయోగించే C ++ ప్రోగ్రామ్, ఫైల్ ఎగువన కింది పంక్తులతో మొదలవుతుంది:
#చేర్చండి#చేర్చండి
నేమ్‌స్పేస్ std ఉపయోగించి;
మొదటి లైన్ ఇన్‌పుట్/అవుట్‌పుట్ కోసం. క్యూ లైన్ యొక్క అన్ని ఫీచర్‌లను ఉపయోగించడానికి ప్రోగ్రామ్‌ను అనుమతించడం రెండవ లైన్. మూడవ పంక్తి ప్రామాణిక నేమ్‌స్పేస్‌లోని పేర్లను ఉపయోగించడానికి ప్రోగ్రామ్‌ను అనుమతిస్తుంది.
ఫంక్షన్‌ని ఓవర్‌లోడ్ చేస్తోంది
రెండు లేదా అంతకంటే ఎక్కువ విభిన్న ఫంక్షన్ సంతకాలు ఒకే పేరును కలిగి ఉన్నప్పుడు, ఆ పేరు ఓవర్‌లోడ్ చేయబడిందని చెప్పబడింది. ఒక ఫంక్షన్ అని పిలవబడినప్పుడు, ఆర్గ్యుమెంట్‌ల సంఖ్య మరియు రకం, వాస్తవానికి ఏ ఫంక్షన్ అమలు చేయబడుతుందో నిర్ణయించండి.
నిర్మాణం
క్యూ<రకం>పేరు()కింది డిక్లరేషన్ ఒక క్యూ అని పేరు పెట్టబడింది, టైప్ int యొక్క క్యూ.
క్యూ<int>అని;క్యూ ఖాళీగా ఉంది. డిక్లరేషన్ రిజర్వ్డ్ వర్డ్‌తో ప్రారంభమవుతుంది, డేటా టైప్‌తో యాంగిల్ బ్రాకెట్‌ల తర్వాత క్యూ. అప్పుడు మీరు ప్రోగ్రామర్‌కు క్యూ కోసం పేరు ఇవ్వబడింది.
ఇనిషియలైజర్ జాబితాతో నిర్మాణం
కింది నిర్వచనం ఇనిషియలైజర్ జాబితాతో క్యూను ఎలా సృష్టించాలో చూపుతుంది:
క్యూ<తేలుతాయి>అని({1.1, 2.2, 3.3, 4.4});ఒక క్యూను నాశనం చేయడం
ఒక క్యూను నాశనం చేయడానికి, అది పరిధి నుండి బయటపడనివ్వండి.
క్యూ ఎలిమెంట్ యాక్సెస్
పుష్ (విలువ)
క్యూ అనేది ఫస్ట్-ఇన్-ఫస్ట్-అవుట్ జాబితా. కాబట్టి, ప్రతి విలువ వెనుక నుండి జోడించబడుతుంది. కింది కోడ్ సెగ్మెంట్ ఖాళీ క్యూను సృష్టిస్తుంది, ఆ తర్వాత వెనుక నుండి ఐదు ఫ్లోట్ విలువలు జోడించబడతాయి:
క్యూ<తేలుతాయి>అని;అని.పుష్(1.1);
అని.పుష్(2.2);
అని.పుష్(3.3);
అని.పుష్(4.4);
అని.పుష్(5.5);
పరిమాణం () const
ఇది క్యూలోని మూలకాల సంఖ్యను అందిస్తుంది. కింది కోడ్ వివరిస్తుంది:
క్యూ<తేలుతాయి>అని;అని.పుష్(1.1);అని.పుష్(2.2);అని.పుష్(3.3);అని.పుష్(4.4);అని.పుష్(5.5);
ఖరీదు<<అని.పరిమాణం() << ' n';
అవుట్‌పుట్ 5.
ముందు ()
ఇది మూలకాన్ని తీసివేయకుండా, క్యూలోని మొదటి మూలకానికి సూచనను అందిస్తుంది. కింది కోడ్ యొక్క అవుట్‌పుట్ 1.1.
క్యూ<తేలుతాయి>అని;అని.పుష్(1.1);అని.పుష్(2.2);అని.పుష్(3.3);అని.పుష్(4.4);అని.పుష్(5.5);
ఖరీదు<<అని.ముందు() << ' n';
మూలకం క్యూ నుండి తీసివేయబడలేదు.
ముందు () const
క్యూ నిర్మాణానికి ముందు కాన్స్టాట్ ఉన్నప్పుడు, ఫ్రంట్ () కు బదులుగా ఫ్రంట్ ఫ్రంట్ () కానిస్ట్రక్షన్ అమలు చేయబడుతుంది. ఇది క్రింది కోడ్‌లో ఉపయోగించబడుతుంది, ఉదాహరణకు.
కానిస్టేట్క్యూ<తేలుతాయి>అని({1.1, 2.2, 3.3, 4.4, 5.5});ఖరీదు<<అని.ముందు() << ' n';
స్థిరమైన సూచన తిరిగి ఇవ్వబడుతుంది. వెక్టర్ నుండి మూలకం తీసివేయబడలేదు. క్యూ మూలకాలు మార్చబడవు.
తిరిగి ()
ఇది మూలకాన్ని తీసివేయకుండా, క్యూలోని చివరి మూలకానికి సూచనను అందిస్తుంది. కింది కోడ్ యొక్క అవుట్‌పుట్ 5.5.
క్యూ<తేలుతాయి>అని;అని.పుష్(1.1);అని.పుష్(2.2);అని.పుష్(3.3);అని.పుష్(4.4);అని.పుష్(5.5);
ఖరీదు<<అని.తిరిగి() << ' n';
తిరిగి () కానిస్టేట్
క్యూ నిర్మాణానికి ముందు కాన్స్టాట్ చేసినప్పుడు, ఎక్స్‌ప్రెషన్ బ్యాక్ () కాని బదులుగా (() బదులుగా అమలు చేయబడుతుంది. ఇది క్రింది కోడ్‌లో ఉపయోగించబడుతుంది, ఉదాహరణకు.
కానిస్టేట్క్యూ<తేలుతాయి>అని({1.1, 2.2, 3.3, 4.4, 5.5});ఖరీదు<<అని.తిరిగి() << ' n';
స్థిరమైన సూచన తిరిగి ఇవ్వబడుతుంది. మూలకం క్యూ నుండి తీసివేయబడలేదు. క్యూ నిర్మాణానికి మునుపటి కాన్స్టాట్‌తో, క్యూలోని మూలకాలను మార్చలేము.
క్యూ సామర్థ్యం
పరిమాణం () const
- పైన చుడండి
ఖాళీ () const
క్యూలో మూలకాలు లేనట్లయితే ఇది నిజం కోసం 1 లేదా క్యూ ఖాళీగా ఉంటే తప్పు కోసం 0 ని అందిస్తుంది. కింది కోడ్ దీనిని వివరిస్తుంది:
క్యూ<తేలుతాయి>అది 1({1.1, 2.2, 3.3, 4.4, 5.5});ఖరీదు<<అది 1.ఖాళీ() << ' n';
క్యూ<తేలుతాయి>అది 2;
ఖరీదు<<అది 2.ఖాళీ() << ' n';
అవుట్‌పుట్:
01
క్యూ మోడిఫైయర్‌లు
పాప్ ()
క్యూ అనేది FIFO, కాబట్టి తీసివేయవలసిన ఏదైనా మూలకం తప్పనిసరిగా క్యూ ఎగువ (తల) నుండి తీసివేయబడాలి. ఈ మెంబర్ ఫంక్షన్ మొదటి మూలకాన్ని తిరిగి ఇవ్వకుండానే తీసివేస్తుంది. కింది కోడ్ దీనిని వివరిస్తుంది:
క్యూ<తేలుతాయి>అని({1.1, 2.2, 3.3, 4.4, 5.5});ఖరీదు<<అని.ముందు() << ' n';
అని.పాప్();
ఖరీదు<<అని.పరిమాణం() << ' n';
అవుట్‌పుట్:
1.14
a. swap (b)
ఈ కోడ్ విభాగంలో వివరించిన విధంగా రెండు క్యూలను మార్చుకోవచ్చు:
క్యూ<తేలుతాయి>అది 1({1.1, 2.2, 3.3, 4.4, 5.5});క్యూ<తేలుతాయి>అది 2({10, ఇరవై});
అది 1.మార్పిడి(అది 2);
ఖరీదు<< 'క్యూ 1 యొక్క మొదటి మూలకం మరియు పరిమాణం:
'<<అది 1.ముందు() <<','<<అది 1.పరిమాణం() << ' n';
ఖరీదు<< 'క్యూ 2 యొక్క మొదటి మూలకం మరియు పరిమాణం'<<
అది 2.ముందు() <<','<<అది 2.పరిమాణం() << ' n';
అవుట్‌పుట్:
క్యూ 1: 10, 2 యొక్క మొదటి మూలకం మరియు పరిమాణం
క్యూ 2 యొక్క మొదటి మూలకం మరియు పరిమాణం: 1.1, 5
అవసరమైతే క్యూ యొక్క పొడవు పెంచబడిందని గమనించండి. అలాగే, భర్తీ చేయని విలువలు కొంత డిఫాల్ట్ విలువతో భర్తీ చేయబడతాయి. డేటా రకాలు ఒకే రకంగా ఉండాలి.
క్యూల కోసం సమానత్వం మరియు రిలేషనల్ ఆపరేటర్లు
C ++ లో సాధారణ అక్షరాల కోసం, ఆరోహణ క్రమంలో, చిన్న అక్షరాలకు ముందు వచ్చే పెద్ద అక్షరాలకు ముందు సంఖ్యలు వస్తాయి. స్పేస్ క్యారెక్టర్ సున్నాకి ముందు వస్తుంది మరియు అవన్నీ.
సమానత్వ నిర్వాహకులు
నిజానికి 1 మరియు తప్పుడు 0 కి తిరిగి వస్తుంది.
== ఆపరేటర్
రెండు క్యూలు ఒకే పరిమాణాన్ని కలిగి ఉంటే మరియు సంబంధిత మూలకాలు సమానంగా ఉంటే 1 ని అందిస్తుంది; లేకుంటే అది 0. ని అందిస్తుంది. ఉదాహరణ:
క్యూ<కానిస్టేట్ చార్*>అది 1({'రకం', 'ఇంకేదో'});క్యూ<కానిస్టేట్ చార్*>అది 2({'దుర్మార్గుడు'});
intఒకదానిపై=అది 1==అది 2;
ఖరీదు<<ఒకదానిపై<< ' n';
అవుట్‌పుట్: 0.
ది! = ఆపరేటర్
- పై వాటికి వ్యతిరేకం. ఉదాహరణ:
క్యూ<కానిస్టేట్ చార్*>అది 1({'రకం', 'ఇంకేదో'});క్యూ<కానిస్టేట్ చార్*>అది 2({'దుర్మార్గుడు'});
intఒకదానిపై=అది 1! =అది 2;
ఖరీదు<<ఒకదానిపై<< ' n';
అవుట్‌పుట్: 1.
రిలేషనల్ ఆపరేటర్లు
నిజానికి 1 మరియు తప్పుడు 0 కి తిరిగి వస్తుంది.
ది
మొదటి క్యూ రెండవ క్యూ యొక్క ప్రారంభ ఉపసమితి అయితే రెండు సమాన భాగాల మూలకాలు ఒకే విధంగా మరియు ఒకే క్రమంలో ఉంటే 1 ని అందిస్తుంది. రెండు క్యూలు ఒకే సైజులో లేదా విభిన్న సైజుల్లో ఉండి, ఎడమ నుండి కుడికి వెళుతుంటే, మొదటి క్యూలో ఒక మూలకం ఎదురవుతుంది, ఇది రెండవ క్యూలోని సంబంధిత మూలకం కంటే తక్కువగా ఉంటుంది, అప్పుడు 1 ఇప్పటికీ తిరిగి ఇవ్వబడుతుంది. లేకపోతే 0 తిరిగి ఇవ్వబడుతుంది. ఉదాహరణ:
క్యూ<కానిస్టేట్ చార్*>అది 1({'రకం', 'ఇంకేదో'});క్యూ<కానిస్టేట్ చార్*>అది 2({'దుర్మార్గుడు'});
intఒకదానిపై=అది 1<అది 2;
ఖరీదు<<ఒకదానిపై<< ' n';
అవుట్‌పుట్ 1. > ఆపరేటర్ - పై వాటికి వ్యతిరేకం. ఉదాహరణ: అవుట్‌పుట్: 0 ది<= Operator - అదే విధంగా అవుట్‌పుట్: 1 > = ఆపరేటర్ - పై వాటికి వ్యతిరేకం. ఉదాహరణ: అవుట్‌పుట్: 0 ఒక విలువ ఒక డేటా రకానికి, ఒక తక్షణ వస్తువు ఒక తరగతికి చెందినది. క్యూ నిర్మాణం కూడా క్లాస్‌ని డేటా రకంగా ఆమోదించగలదు. కింది కార్యక్రమం దీనిని వివరిస్తుంది: అవుట్‌పుట్ 5. క్యూ జాబితాను సాంకేతికంగా లింక్డ్ లిస్ట్ అంటారు. క్యూ కోసం రెండు రకాల లింక్ లిస్ట్‌లు ఉన్నాయి: సింగిల్ లింక్డ్ లిస్ట్ మరియు రెట్టింపు లింక్డ్ లిస్ట్. సింగిల్‌గా లింక్ చేయబడిన లిస్ట్ ఎలిమెంట్‌ను ఇద్దరు సభ్యుల స్ట్రక్ట్ ద్వారా అమలు చేయవచ్చు. ఒక సభ్యుడు తదుపరి అంశానికి పాయింటర్‌ను కలిగి ఉంటాడు మరియు మరొక సభ్యుడు డేటమ్‌ను కలిగి ఉంటాడు (డేటా కోసం ఏకవచనం). రెట్టింపు లింక్ లిస్ట్ ఎలిమెంట్‌ను ముగ్గురు సభ్యుల స్ట్రక్ట్ ద్వారా అమలు చేయవచ్చు. మధ్య సభ్యుడు డేటమ్‌ను కలిగి ఉంటాడు, మొదటి మరియు మూడవ సభ్యులు తమ ప్రక్కనే ఉన్న అంశాలకు పాయింటర్‌లను కలిగి ఉంటారు. క్యూ అనేది ఫస్ట్-ఇన్-ఫస్ట్-అవుట్ డేటా స్ట్రక్చర్. క్యూ రూపంలో డేటా వచ్చినప్పుడు కంప్యూటింగ్‌లో పరిస్థితులు ఉన్నాయి, ముందుగా ఫస్ట్-ఇన్-ఫస్ట్-అవుట్ ప్రవర్తన అవసరం. కంప్యూటర్‌లోని వనరు పరిమిత లభ్యత యొక్క ఏదైనా భౌతిక లేదా వర్చువల్ భాగం. వాటిలో CPU, వీడియో కార్డ్, హార్డ్ డ్రైవ్ మరియు మెమరీ ఉన్నాయి. అటువంటి వనరును పంచుకోవడానికి ఒక క్యూ అవసరం. కంప్యూటర్ పెరిఫెరల్స్ ఎప్పటికప్పుడు కంప్యూటర్‌కు అంతరాయం కలిగించాలి. అంతరాయాలను వారు వచ్చిన విధంగానే నిర్వహించాల్సి ఉంటుంది. దీనికి క్యూ అవసరం. కంప్యూటర్‌లో ఫైల్‌లు నిల్వ చేయబడితే, ఉదాహరణకు, ఉద్యోగం కోసం అప్లికేషన్ ఫైల్‌లను నిర్వహించడానికి క్యూను ఉపయోగించవచ్చు. క్యూ అనేది లిస్ట్ డేటా స్ట్రక్చర్, ఇది సింగిల్ లింక్డ్ లిస్ట్ లేదా రెట్టింపు లింక్డ్ లిస్ట్. నియమం ప్రకారం, జాబితాలోకి ప్రవేశించే మొదటి మూలకం బయటకు వచ్చిన మొదటి మూలకం. C ++ దాని ప్రామాణిక లైబ్రరీలో క్యూ డేటా నిర్మాణాన్ని అందిస్తుంది. ఈ నిర్మాణం కోసం అందుబాటులో ఉన్న సభ్యుల విధులు మరియు ఆపరేటర్ల కేటగిరీలు క్యూ నిర్మాణం, క్యూ ఎలిమెంట్ యాక్సెస్, క్యూ సామర్థ్యం, క్యూ మాడిఫైయర్‌లు మరియు క్యూ ఓవర్‌లోడ్ ఆపరేటర్లు. ఏదైనా క్యూ డేటా స్ట్రక్చర్ కనీసం, పుష్ () మరియు పాప్ () సభ్యుల ఫంక్షన్‌లను తప్పక అందించాలి. పుష్ () అంటే, క్యూ వెనుక భాగంలో కొత్త మూలకాన్ని పంపడం; మరియు పాప్ () అంటే, క్యూ ముందు భాగంలో ఉండే మూలకాన్ని తొలగించడం. దురదృష్టవశాత్తూ, C ++ లో, ఈ ఫంక్షన్‌లు నెట్టిన లేదా పాప్ చేసిన విలువను తిరిగి ఇవ్వవు. కాబట్టి, నెట్టడానికి ముందు చివరి మూలకాన్ని తెలుసుకోవడానికి, అదనపు బ్యాక్ () ఫంక్షన్‌ను ఉపయోగించాల్సి ఉంటుంది; మరియు పాపింగ్‌కు ముందు మొదటి మూలకాన్ని తెలుసుకోవడానికి, అదనపు ఫ్రంట్ () ఫంక్షన్‌ను ఉపయోగించాల్సి ఉంటుంది. ఒక విలువ ఒక డేటా రకానికి, ఒక తక్షణ వస్తువు ఒక తరగతికి చెందినది. కాబట్టి, క్యూ టెంప్లేట్ తక్షణం కోసం ఒక నిర్దిష్ట తరగతిని డేటా రకంగా ఉపయోగించవచ్చు. తరగతికి సంబంధించిన విభిన్న వస్తువులు తరగతికి భిన్న విలువలు లాగా మారతాయి. క్యూలో కంప్యూటర్‌లో అప్లికేషన్లు ఉన్నాయి. ఉదాహరణకు, కంప్యూటర్‌లో ఫైల్‌లు నిల్వ చేయబడితే, ఉద్యోగం కోసం అప్లికేషన్ ఫైల్‌లను నిర్వహించడానికి దీనిని ఉపయోగించవచ్చు. క్రిస్
క్యూ<కానిస్టేట్ చార్*>అది 2({'దుర్మార్గుడు'});
intఒకదానిపై=అది 1>అది 2;
ఖరీదు<<ఒకదానిపై<< ' n';
క్యూ<కానిస్టేట్ చార్*>అది 2({'దుర్మార్గుడు'});
intఒకదానిపై=అది 1<=అది 2;
ఖరీదు<<ఒకదానిపై<< ' n';
క్యూ<కానిస్టేట్ చార్*>అది 2({'దుర్మార్గుడు'});
intఒకదానిపై=అది 1> =అది 2;
ఖరీదు<<ఒకదానిపై<< ' n'; తరగతి మరియు దాని తక్షణ వస్తువులు
#చేర్చండి
నేమ్‌స్పేస్ std ఉపయోగించి;
క్లాస్ TheCla
{
ప్రజా:
intఒకదానిపై;
స్టాటిక్ చార్చ;
శూన్యంఫంక్షన్(చార్లేదు, కానిస్టేట్ చార్ *p)
{
ఖరీదు<< 'ఉన్నాయి ' <<ఒకదానిపై<< 'విలువైన పుస్తకాలు' <<లేదు<<p<< 'స్టోర్‌లో.' << ' n';
}
స్టాటిక్ శూన్యంసరదాగా(చార్చ)
{
ఉంటే (చ== 'కు')
ఖరీదు<< 'అధికారిక స్టాటిక్ మెంబర్ ఫంక్షన్' << ' n';
}
};
intప్రధాన()
{
ది క్లా ఆబ్జెక్ట్ 1;ది క్లా ఆబ్జెక్ట్ 2;ది క్లా ఆబ్జెక్ట్ 3;ది క్లా ఆబ్జెక్ట్ 4;ది క్లా ఆబ్జెక్ట్ 5;
క్యూ<ది క్లా>అని;
అని.పుష్(ఆబ్జెక్ట్ 1);అని.పుష్(ఆబ్జెక్ట్ 2);అని.పుష్(ఆబ్జెక్ట్ 3);అని.పుష్(ఆబ్జెక్ట్ 4);అని.పుష్(ఆబ్జెక్ట్ 5);
ఖరీదు<<అని.పరిమాణం() << ' n';
తిరిగి 0;
} లింక్ చేసిన జాబితా
క్యూ యొక్క అప్లికేషన్లు
కంప్యూటర్ వనరులను పంచుకోవడం
నిర్వహణ అంతరాయాలు
సమాచారాన్ని నిర్వహించండి.
ముగింపు