C++ istream విధులు

C Istream Vidhulu

C++లోని 'స్ట్రీమ్' అనే పదం ప్రోగ్రామ్ థ్రెడ్ మరియు i/o మధ్య అక్షరాల ప్రవాహాన్ని వివరిస్తుంది. IO పరికరాలు మరియు ఫైల్‌లలో ఇన్‌పుట్ మరియు అవుట్‌పుట్ చర్యలకు C++ స్ట్రీమ్ తరగతులు అవసరం. ఈ తరగతులు ప్రోగ్రామ్ యొక్క ఇన్‌పుట్ మరియు అవుట్‌పుట్‌ను నిర్వహించడానికి రూపొందించబడ్డాయి మరియు అవి నిర్దిష్ట కార్యాచరణను కలిగి ఉంటాయి.

స్ట్రీమ్ క్లాస్ హైరార్కీ

ఒక C++ క్లాస్ అది కలిగి ఉన్న డేటాను నిర్వహించడానికి మరియు నియంత్రించడానికి అవసరమైన పద్ధతులతో రూపొందించబడింది.

ఫ్లోట్, డబుల్స్ మరియు క్లాస్‌లు పూర్ణాంకానికి సమానమైన డేటా రకాలు. తరగతి డేటా రకంగా ఉన్న ప్రత్యేకమైన వేరియబుల్‌ను C++ ఆబ్జెక్ట్‌గా సూచిస్తారు. ముందుగా పేర్కొన్న ప్రత్యేక వస్తువులు 'సిన్' మరియు 'కౌట్' వాటి డేటా రకాలుగా వివిధ తరగతులను కలిగి ఉంటాయి.



C++లోని ప్రోగ్రామ్‌లలోకి లేదా వెలుపలకు డేటా ప్రవాహాలకు ఉదాహరణలుగా 'కౌట్' లేదా 'cin' నుండి చదవబడిన డేటా. ప్రస్తుతం, మేము దీని కోసం క్రింది నాలుగు తరగతులను పరిశీలిస్తున్నాము:



దానిని ప్రసారం చేయండి
ఈ ఇన్‌పుట్ స్ట్రీమ్ ద్వారా ఏదైనా ప్రయోజనం పొందవచ్చు. ఐస్ట్రీమ్ యొక్క ఉదాహరణ సిన్.



ఓస్ట్రీమ్
ఇది అనేక ఉపయోగాలతో కూడిన అవుట్‌పుట్ స్ట్రీమ్. ఓస్ట్రీమ్‌లు కౌట్ మరియు సిన్ రూపాల్లో వస్తాయి.

స్ట్రీమ్ అయితే
ఇది ఇన్‌పుట్ ఫైల్‌ల స్ట్రీమ్.

స్ట్రీమ్
ఇది అవుట్‌పుట్ ఫైల్‌ల స్ట్రీమ్. వారసత్వం అనేది C++ వంటి ఆబ్జెక్ట్-ఓరియెంటెడ్ ప్రోగ్రామింగ్‌లో ఎక్కువగా ఉపయోగించబడే భావన, ఇక్కడ కొన్ని తరగతులు ఇప్పటికే సృష్టించబడిన ఇతర తరగతుల లక్షణాలను తీసుకుంటాయి. పూర్వీకుల తరగతులు కొత్త లక్షణాలను చేర్చడం ద్వారా తమలో తాము ప్రత్యేకతలుగా మారతాయి.



స్ట్రీమ్ క్లాస్ అయితే
ఐఫ్‌స్ట్రీమ్‌ను ఐస్ట్రీమ్ మాదిరిగానే పరిగణించవచ్చు, అది అదే.

స్ట్రీమ్ క్లాస్
ifstreams ఫంక్షన్లు చేసే విధంగానే, కానీ ఇన్‌పుట్‌కు బదులుగా అవుట్‌పుట్‌తో, ఆఫ్‌స్ట్రీమ్ అనేది అవుట్‌పుట్ ఫైల్ స్ట్రీమ్. ఒక ఆఫ్‌స్ట్రీమ్‌ను నిర్మించి, తెరిచిన తర్వాత మరియు లోపాలు లేవని ధృవీకరించిన తర్వాత కౌట్ మాదిరిగానే ఉపయోగించబడుతుంది.

IOS తరగతి
ఈ తరగతి నుండి, అన్ని స్ట్రీమ్ తరగతులు వచ్చాయి. ఇన్‌పుట్ మరియు అవుట్‌పుట్ స్ట్రీమ్‌లు రెండు వేర్వేరు రకాలు.

ఇది ios బేస్‌లో స్ట్రీమ్ ఇన్‌పుట్ లేదా అవుట్‌పుట్ స్థితి నుండి స్వతంత్రంగా ఉండే స్ట్రీమ్ భాగాలను నిర్వచిస్తుంది.

ios బేస్‌లో చర్చించబడిన సభ్యులకు విరుద్ధంగా, టెంప్లేట్ పారామితులపై ఆధారపడిన సభ్యులు ఈ భాగంలో వివరించబడ్డారు.

స్ట్రీమ్(ఇన్‌పుట్)
iostream లైబ్రరీ సంక్లిష్టత కారణంగా, మేము ఈ పాఠాలలో పూర్తిగా కవర్ చేయలేము. అయితే, మేము ఎక్కువగా ఉపయోగించే ఫంక్షన్‌లను హైలైట్ చేస్తాము. ఈ విభాగంలో, మేము ఇన్‌పుట్ క్లాస్‌ని వివిధ కోణాల నుండి చూస్తాము (istream).

ఇన్‌పుట్ స్ట్రీమ్ నుండి డేటాను పొందేందుకు ఎక్స్‌ట్రాక్షన్ ఆపరేటర్ (>>) ఉపయోగించబడుతుందని మేము తెలుసుకున్నాము.

స్ట్రీమ్

C++ ప్రోగ్రామింగ్ లాంగ్వేజ్‌లో, ఇన్‌పుట్ స్ట్రీమ్ istream క్లాస్ ద్వారా నిర్వహించబడుతుంది. ఇన్‌పుట్ ఈ ఇన్‌పుట్ స్ట్రీమ్ ఆబ్జెక్ట్‌లను ఉపయోగించి అక్షరాల శ్రేణిగా చదవబడుతుంది మరియు అర్థం అవుతుంది. ఇన్‌పుట్ సిన్ ద్వారా నిర్వహించబడుతుంది.

సభ్యుల తరగతులు

istream::సెంట్రీ
అనేక పనులను నిర్వహించే తరగతి మరియు ప్రతిసారీ ఇన్‌పుట్ విధానం నిర్వహించబడుతుంది. దాని డిస్ట్రక్టర్ ఎటువంటి చర్యలను చేయవలసిన అవసరం లేదు. ఏదేమైనప్పటికీ, సెంట్రీ ఆబ్జెక్ట్‌లను సృష్టించడం మరియు నాశనం చేయడం ద్వారా అన్ని ఇన్‌పుట్ కార్యకలాపాల ద్వారా భాగస్వామ్యం చేయబడిన స్ట్రీమ్‌లో అదనపు స్టార్టప్ లేదా క్లీనప్ టాస్క్‌లను అమలు చేయవచ్చు.

విధులు

istream::gcount
ఆబ్జెక్ట్ యొక్క అత్యంత ఇటీవలి ఫార్మాట్ చేయని ఇన్‌పుట్ చర్య నుండి పొందిన అక్షర గణనను అందిస్తుంది. ఫార్మాట్ చేయని ఇన్‌పుట్ విధానాలు- గెట్, గెట్‌లైన్, విస్మరించండి, పీక్ చేయండి, చదవండి, కొంత చదవండి, పుట్‌బ్యాక్ మరియు అన్‌గెట్- ఈ ఫంక్షన్ ద్వారా అందించబడిన విలువను మారుస్తుంది. అయితే, పీక్‌లు, పుట్‌బ్యాక్ లేదా అన్‌గెట్‌ని కాల్ చేయడం వల్ల అక్షరాలు ఏవీ సేకరించబడవని గుర్తుంచుకోండి. ఫలితంగా, గణన ఎల్లప్పుడూ 0ని అందిస్తుంది.

istream:: పొందండి
ఒకే పాత్ర ఒక పాత్రను స్ట్రీమ్ నుండి బయటకు తీస్తుంది. అక్షరం ఆర్గ్యుమెంట్ విలువగా సెట్ చేయబడింది లేదా తిరిగి ఇవ్వబడుతుంది (మొదటి సంతకం) (రెండవ సంతకం).

C స్ట్రింగ్: డీలిమిటింగ్ అక్షరం ఉన్నట్లయితే, అది ఇన్‌పుట్ సీక్వెన్స్ నుండి తీసివేయబడదు, బదులుగా అది ఉన్నట్లయితే స్ట్రీమ్ నుండి తిరిగి పొందేందుకు క్రింది అక్షరంగా ఉంచబడుతుంది.

istream::getline
ఫార్మాట్ చేయని ఇన్‌పుట్‌గా స్ట్రీమ్ నుండి అక్షరాలను తీసివేస్తుంది మరియు సంగ్రహించిన అక్షరం డీలిమిటింగ్ క్యారెక్టర్‌గా మారే వరకు లేదా “n” అక్షరాలు ‘s’కి వ్రాయబడే వరకు వాటిని “s” వేరియబుల్‌లో c-స్ట్రింగ్‌గా సేవ్ చేస్తుంది. అదనంగా, పద్ధతి ఫైల్ ముగింపుకు చేరుకున్నట్లయితే అక్షరాలను సంగ్రహించడం ఆపివేస్తుంది.

అంతర్గతంగా, ఫంక్షన్ ఇన్‌పుట్ సీక్వెన్స్‌ను యాక్సెస్ చేయడానికి ముందు ఒక వస్తువును సృష్టిస్తుంది. చివరగా, అది తిరిగి వచ్చే ముందు వస్తువును చంపుతుంది, దాని అనుబంధ స్ట్రీమ్ బఫర్ ఆబ్జెక్ట్ నుండి అక్షరాలను సంగ్రహిస్తుంది (ప్రతిదీ సక్రమంగా ఉందని భావించి) దాని సభ్య పద్ధతుల్లో ఒకదానిని అమలు చేస్తున్నట్లుగా.

istream::విస్మరించు
అక్షరాలు ఇన్‌పుట్ సీక్వెన్స్ నుండి తీసుకోబడతాయి మరియు “n” అక్షరాలు తీయబడే వరకు లేదా ఒకటి డీలిమ్‌తో సమానంగా సరిపోలే వరకు ఒక్కొక్కటిగా విస్మరించబడతాయి. అదనంగా, ఫైల్ ముగింపుకు చేరుకున్నట్లయితే, ఫంక్షన్ అక్షర సంగ్రహణను నిలిపివేస్తుంది. ఫంక్షన్ 'eofbit' ఫ్లాగ్‌ను చాలా త్వరగా ఈ స్థానానికి చేరుకున్నట్లయితే (n అక్షరాలను సంగ్రహించే ముందు లేదా డెలిమ్‌ని కనుగొనే ముందు) సెట్ చేస్తుంది.

ఇన్‌పుట్ సీక్వెన్స్‌ని యాక్సెస్ చేయడానికి ముందు, ఫంక్షన్ అంతర్గతంగా సెంట్రీ ఆబ్జెక్ట్‌ను నిర్మిస్తుంది (noskipwsతో ఇది నిజం అవుతుంది). చివరగా, ఇది తిరిగి వచ్చే ముందు సెంట్రీ ఆబ్జెక్ట్‌ను చంపుతుంది, దాని అనుబంధ స్ట్రీమ్ బఫర్ ఆబ్జెక్ట్ నుండి అక్షరాలను సంగ్రహిస్తుంది (ప్రతిదీ సక్రమంగా ఉందని భావించి) దాని సభ్య పద్ధతుల్లో ఒకదాన్ని అమలు చేస్తున్నట్లుగా: sbumpc లేదా sgetc.

istream:: ఆపరేటర్ >>
వెలికితీత ఆపరేటర్ (>>) ఈ ఆపరేటర్‌ను ఇన్‌పుట్ స్ట్రీమ్‌కు వర్తింపజేస్తుంది. ఇది ఫంక్షన్‌గా చాలా ఎక్కువ మంది సభ్యులను కలిగి ఉంది.

అంకగణిత రకం

అక్షరాలు స్ట్రీమ్ నుండి తీసివేయబడతాయి మరియు సరైన రకానికి చెందిన విలువను సూచించడానికి వరుసగా అన్వయించబడతాయి, అది “val” విలువగా సేవ్ చేయబడుతుంది. ఇన్‌పుట్ సీక్వెన్స్‌ను యాక్సెస్ చేయడానికి ముందు, ఫంక్షన్ అంతర్గతంగా సెంట్రీ ఆబ్జెక్ట్‌ను నిర్మిస్తుంది (noskipws తప్పు అవుతుంది). ప్రతిదీ సరిగ్గా జరిగితే, అది స్ట్రీమ్ యొక్క అంతర్గత స్థితి ఫ్లాగ్‌లను సవరించేటప్పుడు సంగ్రహణ మరియు అన్వయ ప్రక్రియలను పూర్తి చేయడానికి num get::ని అమలు చేస్తుంది. సెంట్రీ ఆబ్జెక్ట్ చివరికి అది బయలుదేరే ముందు నాశనం చేయబడుతుంది.

ఇన్‌పుట్ క్రమాన్ని చదవడానికి ముందు ఫంక్షన్ అంతర్గతంగా సెంట్రీ ఆబ్జెక్ట్‌ను ఉత్పత్తి చేస్తుంది, ఇది ఫార్మాట్ చేసిన ఇన్‌పుట్‌గా పరిగణించబడుతుంది. చివరగా, ఇది తిరిగి వచ్చే ముందు సెంట్రీ ఆబ్జెక్ట్‌ను చంపుతుంది, దాని అనుబంధ స్ట్రీమ్ బఫర్ ఆబ్జెక్ట్ నుండి అక్షరాలను సంగ్రహిస్తుంది (ప్రతిదీ సక్రమంగా ఉందని భావించి) దాని సభ్య పద్ధతుల్లో ఒకదానిని అమలు చేస్తున్నట్లుగా.

మానిప్యులేటర్లు

pf (*ఇది) అని పిలుస్తారు, ఇక్కడ pf ఒక మానిప్యులేటర్ కావచ్చు. మానిప్యులేటర్‌లు అనేవి ఈ ఆపరేటర్‌ని ప్రారంభించినప్పుడు ప్రత్యేకంగా కాల్ చేయడానికి సృష్టించబడిన నిత్యకృత్యాలు. ఇన్‌పుట్ సీక్వెన్స్ ఈ విధానం ద్వారా ప్రభావితం కాదు మరియు అక్షరాలు ఏవీ సంగ్రహించబడవు.

istream::putback
పునరుద్ధరించబడిన అక్షరం కర్సర్‌ను స్ట్రీమ్‌లోని ఒక అక్షరం క్రిందికి తరలించడానికి ప్రయత్నిస్తుంది, తద్వారా స్ట్రీమ్ నుండి తిరిగి పొందిన చివరి అక్షరాన్ని ఇన్‌పుట్ ఆపరేషన్ల ద్వారా మళ్లీ సంగ్రహించవచ్చు.

ఇన్‌పుట్ సీక్వెన్స్‌ని యాక్సెస్ చేయడానికి ముందు, ఫంక్షన్ అంతర్గతంగా సెంట్రీ ఆబ్జెక్ట్‌ను నిర్మిస్తుంది. అది దాని అనుబంధ స్ట్రీమ్ బఫర్ ఆబ్జెక్ట్‌పై (మంచి ఉంటే) sputbackc(c)ని పిలుస్తుంది. సెంట్రీ ఆబ్జెక్ట్ చివరికి అది బయలుదేరే ముందు నాశనం చేయబడుతుంది.

istream::చదవండి
డేటా బ్లాక్‌ని చదవండి:

'n' అక్షరాలు స్ట్రీమ్ నుండి తీసుకోబడ్డాయి మరియు ఆ తర్వాత 's' ద్వారా సూచించబడే శ్రేణిలో నిల్వ చేయబడతాయి. ఈ ఫంక్షన్ డేటా యొక్క కంటెంట్‌లను తనిఖీ చేయకుండా లేదా చివరిలో శూన్య అక్షరాన్ని జోడించకుండా కేవలం డేటా బ్లాక్‌ను ప్రతిబింబిస్తుంది.

ఫంక్షన్‌లో, ఇన్‌పుట్ సీక్వెన్స్ యాక్సెస్ చేయడానికి ముందు సెంట్రీ ఆబ్జెక్ట్ మొదట సృష్టించబడుతుంది. చివరగా, ఇది తిరిగి వచ్చే ముందు సెంట్రీ ఆబ్జెక్ట్‌ను చంపుతుంది, దాని అనుబంధ స్ట్రీమ్ బఫర్ ఆబ్జెక్ట్ నుండి అక్షరాలను సంగ్రహిస్తుంది (ప్రతిదీ సక్రమంగా ఉందని భావించి) దాని సభ్య పద్ధతుల్లో ఒకదాన్ని అమలు చేస్తున్నట్లుగా: sbumpc లేదా sgetc.

సభ్యుల సంఖ్యను కాల్ చేయడం వలన ఈ ఫంక్షన్ సరిగ్గా చదివిన మరియు నిల్వ చేసిన అక్షరాల మొత్తం సంఖ్యను అందిస్తుంది.

istream:: చదవదగినది
ఈ ఫంక్షన్ స్ట్రీమ్‌కు అనుసంధానించబడిన నిర్దిష్ట స్ట్రీమ్ బఫర్ ఆబ్జెక్ట్ యొక్క అంతర్గత పనితీరుపై ఆధారపడి ఉంటుంది, దీని ప్రవర్తన ప్రామాణిక తరగతుల కోసం ఎక్కువగా అమలు-నిర్వచించబడుతుంది.

ఫంక్షన్‌లో, ఇన్‌పుట్ సీక్వెన్స్ యాక్సెస్ చేయడానికి ముందు సెంట్రీ ఆబ్జెక్ట్ మొదట సృష్టించబడుతుంది. ఆపై (విజయవంతమైతే), 'sbumpc'కి కాల్ చేయడానికి ముందు, ఆ సంఖ్యలో అక్షరాలను (లేదా sgetc) సంగ్రహించడానికి ముందు ఇప్పుడు ఎన్ని అక్షరాలు అందుబాటులో ఉన్నాయో తెలుసుకోవడానికి స్ట్రీమ్ బఫర్ ఆబ్జెక్ట్ అందుబాటులో ఉన్న మెంబర్ ఫంక్షన్‌ని కాల్ చేస్తుంది. సెంట్రీ ఆబ్జెక్ట్ చివరికి అది బయలుదేరే ముందు నాశనం చేయబడుతుంది.

istream::seekg
ఇన్‌పుట్ లైన్‌లోని స్థానం ఇన్‌పుట్ స్ట్రీమ్ నుండి కింది అక్షరం ఎక్కడ లాగబడుతుందో నిర్ణయిస్తుంది. ఇన్‌పుట్ సీక్వెన్స్ చదవడానికి ముందు, ఫంక్షన్ అంతర్గతంగా సెంట్రీ ఆబ్జెక్ట్‌ను నిర్మిస్తుంది. అప్పుడు (సరే అయితే), సంబంధిత స్ట్రీమ్ బఫర్ ఆబ్జెక్ట్‌కు ఇది రెండు కాల్‌లలో ఒకటి చేస్తుంది: pubseekpos (1) లేదా pubseekoff (2), (ఏదైనా ఉంటే). చివరగా, ఇది సెంట్రీ ఐటెమ్‌ను తుడిచిపెట్టి, బయలుదేరుతుంది.

istream:: సమకాలీకరణ
ఇన్‌పుట్ బఫర్‌ను సమలేఖనం చేయండి:

లింక్ చేయబడిన స్ట్రీమ్ బఫర్ యొక్క నియంత్రిత ఇన్‌పుట్ క్రమాన్ని సమకాలీకరణలోకి తీసుకువస్తుంది. స్ట్రీమ్‌కు కనెక్ట్ చేయబడిన స్ట్రీమ్ బఫర్ ఆబ్జెక్ట్ యొక్క నిర్దిష్ట అమలు ఆపరేషన్ యొక్క ప్రత్యేకతలను నిర్ణయిస్తుంది.

istream:: చెప్పండి
ఇన్‌పుట్ సీక్వెన్స్ స్థానాన్ని పొందండి:

ఇది ఇన్‌పుట్ స్ట్రీమ్‌లో ప్రస్తుత పాత్ర యొక్క స్థానాన్ని ఇస్తుంది. ఫంక్షన్ అప్పుడు -1ని అందిస్తుంది. సభ్యుడు విఫలమైతే, అది నిజమని చూపుతుంది.

ఇది rdbuf()->pubseekoff కాకపోతే (0,cur,in)ని అందిస్తుంది. సెంట్రీ ఆబ్జెక్ట్ చివరికి అది బయలుదేరే ముందు నాశనం చేయబడుతుంది.

istream::unget
అక్షరాన్ని తీసివేయండి:

స్ట్రీమ్‌లోని ఒక అక్షరం కిందకు కర్సర్‌ను తరలించడానికి ప్రయత్నిస్తుంది, తద్వారా స్ట్రీమ్ నుండి తిరిగి పొందిన చివరి అక్షరాన్ని ఇన్‌పుట్ ఆపరేషన్‌ల ద్వారా మళ్లీ సంగ్రహించవచ్చు.

సభ్యులు కానివారు

ఆపరేటర్ >> (istream)
ఎక్స్‌ట్రాక్షన్ ఆపరేటర్ (>>) ఇన్‌పుట్ స్ట్రీమ్‌కి వర్తింపజేసినప్పుడు ఈ చర్యతో ఫార్మాట్ చేయబడిన ఇన్‌పుట్‌ను అందిస్తుంది.

ఒక అక్షరం: క్యారెక్టర్ సీక్వెన్స్ దాని నుండి తదుపరి అక్షరాన్ని తీసివేస్తుంది మరియు దానిని 'సి' విలువగా నిల్వ చేస్తుంది. నుండి అక్షరాలను సంగ్రహించడం మరియు వాటిని sలో నిల్వ చేయడం, c-స్ట్రింగ్‌గా, వైట్‌స్పేస్ అక్షరం ఎదురైనప్పుడు లేదా (వెడల్పు ()-1) అక్షరాలు సంగ్రహించబడినప్పుడు (వెడల్పు సున్నా కాకపోతే) ఆగిపోతుంది.

rvalue యొక్క సంగ్రహణ: rvalue istream ఆబ్జెక్ట్‌ల నుండి సంగ్రహించడాన్ని ప్రారంభిస్తుంది, ఇది lvalues ​​నుండి సంగ్రహించిన అదే ఫలితాన్ని కలిగి ఉంటుంది: ఇది>> Value అని పిలుస్తుంది.

ఉదాహరణ 1

ఈ సందర్భంలో, మేము వినియోగదారు నుండి ఏదైనా విలువను ఎలా పొందవచ్చో పరిశీలిస్తాము మరియు దానిని స్క్రీన్‌పై ఫలితంగా ప్రదర్శిస్తాము.

# చేర్చండి
ఉపయోగించి నేమ్‌స్పేస్ std ;
int ప్రధాన ( )
{
int నం ;
కోట్ << 'దయచేసి ఒక సంఖ్యను నమోదు చేయండి' ;
ఆహారపు >> నం ;
కోట్ << 'నమోదు చేయబడిన విలువ:' << నం << ' \n ' ;
}

మేము హెడర్ ఫైల్‌ని చేర్చుతాము. తరువాత, మేము ప్రామాణిక నేమ్‌స్పేస్‌లో నేమ్‌స్పేస్ 'std'ని ఉపయోగిస్తాము. మేము ఫంక్షన్‌ను మెయిన్ () అని పిలుస్తాము. ఈ పద్ధతిలో 'నో' అనే వేరియబుల్ ప్రకటించబడుతుంది. ఈ వేరియబుల్ కోసం “int” డేటా రకం సూచించబడుతుంది. 'పూర్ణాంక' అనే పదం పూర్ణాంకం యొక్క సంక్షిప్తీకరణ. తరువాత, 'కౌట్' ప్రకటన ఉపయోగించబడుతుంది. ఈ ఆదేశం లైన్‌ను ప్రింట్ చేస్తుంది.

స్క్రీన్‌పై ఈ వచనం ప్రదర్శించబడిన తర్వాత వినియోగదారు ఏదైనా యాదృచ్ఛిక విలువను ఇన్‌పుట్ చేస్తారు. అప్పుడు, “సిన్” స్టేట్‌మెంట్ ఉపయోగించబడి ఉండేది. ఈ ఆదేశానికి వినియోగదారు విలువను సూచించవలసి ఉంటుంది. వినియోగదారు నమోదు చేసిన నంబర్ వేరియబుల్‌లో సేవ్ చేయబడుతుంది. వినియోగదారు అందించిన విలువ 'cout' ఆదేశాన్ని ఉపయోగించి స్క్రీన్‌పై ప్రదర్శించబడుతుంది.

ఉదాహరణ 2

ఈ సందర్భంలో, మేము వినియోగదారు నుండి ఏదైనా పేరును ఎలా పొందుతాము మరియు దాని ఫలితంగా స్క్రీన్‌పై చూపుతాము.

#include
ఉపయోగించి నేమ్‌స్పేస్ std ;

int ప్రధాన ( )

{

చార్ పేరు [ 125 ] ;
కోట్ << 'మీ పేరు రాయుము, మీ పేరు రాయండి' << endl ;


ఆహారపు >> ws ;

ఆహారపు . గెట్‌లైన్ ( పేరు, 125 ) ;

కోట్ << పేరు << endl ;

తిరిగి 0 ;

}

మేము హెడర్ ఫైల్ ని చేర్చుతాము. తరువాత, మేము ప్రామాణిక నేమ్‌స్పేస్‌ను ‘std’గా ఉపయోగిస్తాము. మేము ప్రధాన() ఫంక్షన్‌ను అమలు చేస్తాము. ఈ పద్ధతిలో, మేము వేరియబుల్‌ని ప్రకటిస్తాము. ఈ వేరియబుల్ ‘char’ డేటా రకాన్ని కలిగి ఉంటుంది. అప్పుడు 'కౌట్' ప్రకటన పని చేస్తుంది. ఈ కమాండ్ స్క్రీన్‌పై 'మీ పేరును నమోదు చేయండి' అనే వచనాన్ని చూపుతుంది. స్క్రీన్‌పై ఈ వచనాన్ని ప్రదర్శించిన తర్వాత, వినియోగదారు ఏదైనా పేరును నమోదు చేస్తారు. అప్పుడు, మేము 'సిన్' స్టేట్‌మెంట్‌ను ఉపయోగిస్తాము.

ఈ ఆదేశం వినియోగదారు నుండి విలువను తీసుకుంటుంది. అందించిన పేరు 'ws' వేరియబుల్‌లో నిల్వ చేయబడుతుంది. ఇక్కడ, మరోసారి, మేము 'cin' ఆదేశాన్ని ఉపయోగిస్తాము. ఈ ఆదేశంలో, getline() ఫంక్షన్ వర్తింపజేయబడుతోంది. ఈ ఫంక్షన్ వినియోగదారు నమోదు చేసిన పేరు మరియు పేరు యొక్క పొడవును కలిగి ఉన్న పరామితిని కలిగి ఉంటుంది. వినియోగదారు అందించిన పేరును చూపించడానికి 'cout' కమాండ్ ఉపయోగించబడుతుంది. కోడ్‌ను ముగించడానికి, 'రిటర్న్ 0' కమాండ్ ఉపయోగించబడుతుంది.

ముగింపు

మొదట, మేము C++ istream ఫంక్షన్‌ల గురించి మాట్లాడాము. అప్పుడు మేము పేర్కొన్న అనేక విధులు మరియు ముఖ్యమైన నిర్వచనాలను గమనిస్తాము. ఈ కథనంలో, మేము వివిధ రకాల istream ఫంక్షన్‌లను కలిగి ఉన్న విభిన్న కోడ్‌లను అమలు చేసాము. మొదటి కోడ్‌లో, మేము వినియోగదారు నుండి ఏదైనా సంఖ్యను తీసుకుంటాము మరియు ఆ సంఖ్యను స్క్రీన్‌పై ప్రదర్శిస్తాము. రెండవదానిలో, వినియోగదారు పేరును నమోదు చేసి, ఆ పేరును స్క్రీన్‌పై ముద్రించారు.