ఉదాహరణ 1:
మేము వినియోగదారు నుండి పూర్ణాంక విలువను పొందే మొదటి కోడ్ ఇక్కడ ఉంది. మొదటి పంక్తిలో, మేము 'iostream' హెడర్ ఫైల్‌ను చేర్చుతాము ఎందుకంటే మనం ఇన్‌పుట్‌ను పొందాలి మరియు అవుట్‌పుట్‌ను ఇక్కడ ప్రదర్శించాలి. 'సిన్' మరియు 'కౌట్' ఫంక్షన్ల డిక్లరేషన్ ఈ హెడర్ ఫైల్‌లో చేయబడుతుంది. తర్వాత, “సిన్” మరియు “కౌట్” వంటి ఫంక్షన్‌లను నిర్వచించినందున “std” నేమ్‌స్పేస్ జోడించబడుతుంది. కాబట్టి, మన కోడ్ ప్రారంభంలో “namespace std”ని చొప్పించినట్లయితే, మనం ప్రతి ఫంక్షన్‌తో “std” అని టైప్ చేయవలసిన అవసరం లేదు.
అప్పుడు, మేము “ప్రధాన()” ఫంక్షన్‌ని పిలుస్తాము మరియు తదనంతరం పూర్ణాంక డేటా రకం యొక్క వేరియబుల్‌ను ప్రకటిస్తాము. “int_value” అనేది మనం ఇక్కడ ప్రకటించిన వేరియబుల్ పేరు. దీని తర్వాత, స్క్రీన్‌పై ఇచ్చిన డేటాను ప్రింట్ చేయడంలో సహాయపడే “కౌట్”ని మేము ఉపయోగిస్తాము. ఇక్కడ, 'పూర్ణాంక సంఖ్యను నమోదు చేయండి' అని మేము చెప్పే సందేశాన్ని వినియోగదారుకు ప్రదర్శిస్తాము. దీని క్రింద, మేము సంగ్రహణ చిహ్నాలు '>>'తో పాటుగా 'cin'ని ఉంచుతాము మరియు 'int_num' వేరియబుల్‌ను ఉంచుతాము.
ఇప్పుడు, మేము వినియోగదారు ఇన్‌పుట్‌ని తీసుకొని దానిని ఇక్కడ సేవ్ చేస్తాము. వినియోగదారు ఇక్కడ నమోదు చేసిన పూర్ణాంక సంఖ్యను కూడా మేము స్క్రీన్‌పై ప్రదర్శించాలనుకుంటున్నాము. కాబట్టి, మేము దీని క్రింద ఉన్న “కౌట్” ను ఉపయోగిస్తాము మరియు అక్కడ “int_value”ని ఉంచుతాము.
కోడ్ 1:
#చేర్చండి
ఉపయోగించి నేమ్‌స్పేస్ std ;
int ప్రధాన ( ) {
int int_value ;
కోట్ <> int_value ;
కోట్ << 'పూర్ణాంకం సంఖ్య:' << int_value ;
తిరిగి 0 ;
}
అవుట్‌పుట్:
ఇచ్చిన కోడ్ అమలు చేయబడినప్పుడు, మేము '89'ని నమోదు చేస్తాము మరియు అది వినియోగదారు ఇన్‌పుట్‌గా '89'ని తీసుకుంటాము. అప్పుడు, మేము 'Enter' నొక్కండి, కాబట్టి ఇది తదుపరి పంక్తిని ప్రదర్శిస్తుంది.
ఉదాహరణ 2:
మనం ఇన్‌పుట్‌ని పొందాలి మరియు అవుట్‌పుట్‌ను ఇక్కడ ప్రదర్శించాలి. కాబట్టి, మేము 'iostream' హెడర్ ఫైల్‌ను మొదటి పంక్తిలో చేర్చాము. ఈ హెడర్ ఫైల్ “సిన్” మరియు “కౌట్” ఫంక్షన్ల కోసం డిక్లరేషన్‌లను కలిగి ఉంది. తరువాత, “std” నేమ్‌స్పేస్ జోడించబడుతుంది. మన కోడ్ ప్రారంభంలో 'namespace std'ని జోడిస్తే ప్రతి ఫంక్షన్‌తో మనం 'std' అని టైప్ చేయనవసరం లేదు.
“ప్రధాన()” ఫంక్షన్‌కు కాల్ చేసిన తర్వాత, “ఫ్లోట్” డేటా టైప్ వేరియబుల్ ప్రకటించబడుతుంది. మనం ఇక్కడ ప్రకటించే వేరియబుల్‌ని “float_value” అంటారు. తర్వాత, టెర్మినల్‌లో అందించిన డేటాను అందించడంలో సహాయపడటానికి మేము 'కౌట్' ఫంక్షన్‌ని ఉపయోగిస్తాము. ఇక్కడ, మేము సందేశాన్ని ప్రదర్శించడం ద్వారా ఫ్లోట్ నంబర్‌ను నమోదు చేయమని వినియోగదారుకు చెబుతాము. “float_num” వేరియబుల్ మరియు సంగ్రహణ చిహ్నాలు “>>” దీని క్రింద “cin”తో పాటు ఉంచబడ్డాయి.
వినియోగదారు ఇన్పుట్ సేకరించబడింది మరియు 'float_num'లో సేవ్ చేయబడుతుంది. మేము దీని క్రింద మరోసారి 'కౌట్' ఫంక్షన్‌ని ఉపయోగిస్తాము మరియు 'float_value'ని చొప్పించాము, ఎందుకంటే మేము వినియోగదారు స్క్రీన్‌పై నమోదు చేసే ఫ్లోట్ నంబర్‌ను కూడా చూడాలనుకుంటున్నాము.
కోడ్ 2:
#ఉపయోగించి నేమ్‌స్పేస్ std ;
int ప్రధాన ( ) {
తేలుతుంది ఫ్లోట్_విలువ ;
కోట్ <> ఫ్లోట్_విలువ ;
కోట్ << 'ఫ్లోట్ సంఖ్య:' << ఫ్లోట్_విలువ ;
తిరిగి 0 ;
}
అవుట్‌పుట్ :
గతంలో పేర్కొన్న కోడ్ రన్ అయినప్పుడు, మేము వినియోగదారు ఇన్‌పుట్‌గా కీబోర్డ్ నుండి “87.5” అని టైప్ చేస్తాము. మేము 'Enter' క్లిక్ చేసినప్పుడు తదుపరి పంక్తి ఫ్లోట్ విలువను ప్రదర్శిస్తుంది.
ఉదాహరణ 3:
ఇప్పుడు, వినియోగదారు నుండి 'డబుల్' డేటా రకం విలువను పొందండి. ఇక్కడ, మేము 'డబుల్' డేటా రకం యొక్క 'double_value'ని ప్రారంభించి, ఆపై మేము వినియోగదారుకు చూపించాలనుకుంటున్న సందేశాన్ని ఉంచుతాము. దీని తర్వాత, మేము “cin>>”ని ఉపయోగిస్తాము మరియు “double_value” వేరియబుల్‌ను ఇక్కడ ఉంచుతాము. వినియోగదారు ఇన్పుట్ ఈ “డబుల్_వాల్యూ” వేరియబుల్లో సేవ్ చేయబడింది. వినియోగదారు అవుట్‌పుట్‌గా నమోదు చేసిన ఇన్‌పుట్‌ను ప్రదర్శించడానికి “డబుల్_వాల్యూ” వేరియబుల్‌ని చొప్పించిన చోట మేము మళ్లీ “కౌట్”ని ఉపయోగిస్తాము.
కోడ్ 3:
#చేర్చండిఉపయోగించి నేమ్‌స్పేస్ std ;
int ప్రధాన ( ) {
రెట్టింపు డబుల్_విలువ ;
కోట్ <> డబుల్_విలువ ;
కోట్ << 'రెట్టింపు సంఖ్య:' << డబుల్_విలువ ;
తిరిగి 0 ;
}
అవుట్‌పుట్ :
ఇక్కడ, మేము డబుల్ డేటా రకం సంఖ్యను నమోదు చేస్తాము మరియు 'Enter' నొక్కండి. కానీ ఇక్కడ, ఇది పూర్తి సంఖ్యను ప్రదర్శించదని మేము గమనించాము. పూర్తి “డబుల్” డేటా టైప్ నంబర్‌ను ప్రదర్శించడానికి, మాకు C++లో కొన్ని పద్ధతులు అవసరం.
ఉదాహరణ 4:
ఇక్కడ, మేము 'bits/stdc++.h' అనే మరో హెడర్ ఫైల్‌ని చేర్చుతాము, ఎందుకంటే ఇది అన్ని కావలసిన ఫంక్షన్ డిక్లరేషన్‌లను కలిగి ఉంటుంది. ఇక్కడ, 'డబుల్' డేటా రకం యొక్క 'డబుల్_డి'ని ప్రారంభించిన తర్వాత వినియోగదారు చూడటానికి కావలసిన సందేశాన్ని మేము సెట్ చేసాము. తర్వాత, మేము “cin>>” ఫంక్షన్‌ని ఉపయోగిస్తాము మరియు ఇక్కడ “double_d” వేరియబుల్‌ని కేటాయిస్తాము. ఇన్పుట్ “డబుల్_డి”లో సేవ్ చేయబడింది. వినియోగదారు ఇక్కడ అవుట్‌పుట్‌గా నమోదు చేసే ఇన్‌పుట్‌ను ప్రదర్శించడానికి, మేము “డబుల్_డి” వేరియబుల్‌ని మళ్లీ “కౌట్” ఫీల్డ్లో నమోదు చేస్తాము. మేము “10”ని జోడించే “setprecision()” ఫంక్షన్‌ని కూడా చేర్చుతాము, కనుక ఇది డబుల్ డేటా రకం విలువ యొక్క ఖచ్చితత్వాన్ని సర్దుబాటు చేస్తుంది మరియు తదనుగుణంగా దాన్ని ప్రింట్ చేస్తుంది. మేము ఇక్కడ సెట్ చేసిన ఖచ్చితత్వం “10”.
కోడ్ 4:
#చేర్చండి#చేర్చండి
ఉపయోగించి నేమ్‌స్పేస్ std ;
int ప్రధాన ( ) {
రెట్టింపు d_value2 ;
కోట్ <> d_value2 ;
కోట్ << నిర్దుష్టత ( 10 ) << 'రెట్టింపు సంఖ్య:' << d_value2 ;
తిరిగి 0 ;
}
అవుట్‌పుట్ :
ఇక్కడ, ఇది ఇన్‌పుట్‌ను సేకరిస్తుంది మరియు మేము ఇచ్చిన కోడ్‌లో సర్దుబాటు చేసిన అదే ఖచ్చితత్వం ప్రకారం “డబుల్” విలువను ప్రదర్శిస్తుంది.
ఉదాహరణ 5:
ఈ కోడ్‌లో, మేము వినియోగదారు నుండి అక్షర ఇన్‌పుట్‌ను పొందుతాము. మేము ఇక్కడ “char” వేరియబుల్ “char1”ని ప్రారంభించాము మరియు సందేశాన్ని ప్రదర్శించడానికి “cout”ని ఉపయోగిస్తాము. అప్పుడు, మనం “cin>>”ని ఉంచి, ఈ “char1”ని అక్కడ ఉంచుతాము. కాబట్టి, వినియోగదారు నమోదు చేసిన అక్షరం ఇక్కడ నిల్వ చేయబడుతుంది. అప్పుడు, “char1” వేరియబుల్లో నిల్వ చేయబడిన అక్షరాన్ని చూపించడానికి మేము మళ్లీ “cout”ని ఉపయోగిస్తాము.
కోడ్ 5:
#ఉపయోగించి నేమ్‌స్పేస్ std ;
int ప్రధాన ( ) {
చార్ చార్1 ;
కోట్ <> చార్1 ;
కోట్ << 'పాత్ర:' << చార్1 ;
తిరిగి 0 ;
}
అవుట్‌పుట్ :
అమలు చేసిన తర్వాత, ఈ సందేశం ప్రదర్శించబడుతుంది. మేము అక్షర ఇన్‌పుట్‌గా “z” అని టైప్ చేస్తాము. తరువాత, తదుపరి పంక్తిలో, నమోదు చేయబడిన అక్షరం ప్రదర్శించబడుతుంది.
ఉదాహరణ 6:
మేము ఈ కోడ్‌లో వినియోగదారు నుండి స్ట్రింగ్ ఇన్‌పుట్‌ను స్వీకరిస్తాము. ఇక్కడ, మేము “స్ట్రింగ్” వేరియబుల్ “myName”ని ప్రారంభిస్తాము మరియు సందేశాన్ని అవుట్‌పుట్ చేయడానికి “cout”ని ఉపయోగిస్తాము. తర్వాత, మేము ఆ స్థానంలో “myName” మరియు “cin>>” చొప్పించాము. అందువలన, వినియోగదారు నమోదు చేసిన స్ట్రింగ్ ఇక్కడ సేవ్ చేయబడుతుంది. తరువాత, “myName” వేరియబుల్లో సేవ్ చేయబడిన స్ట్రింగ్ను ప్రదర్శించడానికి మేము మళ్లీ “cout” ఆదేశాన్ని ఉపయోగిస్తాము.
కోడ్ 6:
#ఉపయోగించి నేమ్‌స్పేస్ std ;
int ప్రధాన ( ) {
స్ట్రింగ్ నా పేరు ;
కోట్ <> నా పేరు ;
కోట్ << 'నా పేరు: ' << నా పేరు ;
తిరిగి 0 ;
}
అవుట్‌పుట్:
కింది సందేశం కనిపిస్తుంది. మేము ఇన్పుట్ ఫీల్డ్లో 'పీటర్' స్ట్రింగ్ను నమోదు చేస్తాము. ఎంటర్ చేసిన స్ట్రింగ్ క్రింది లైన్‌లో చూపబడుతుంది:
ఉదాహరణ 7:
మనం ఇన్‌పుట్‌గా బహుళ స్ట్రింగ్‌లు లేదా లైన్‌ని తీసుకోవాలనుకున్నప్పుడు, మనం తప్పనిసరిగా “getline()” ఫంక్షన్‌ని ఉపయోగించాలి. మేము ఇక్కడ 'స్ట్రింగ్ పేరు'ని ప్రకటిస్తాము. అప్పుడు, మనం నమోదు చేసే సందేశం 'కౌట్' ఉపయోగించి ముద్రించబడుతుంది. మేము వినియోగదారు నుండి బహుళ స్ట్రింగ్ ఇన్‌పుట్‌లను పొందే “గెట్‌లైన్()” ఫంక్షన్‌లో “పేరు” మరియు “సిన్” లను ఉంచాము మరియు వాటిని “పేరు” వేరియబుల్లో నిల్వ చేస్తాము. ఇది వినియోగదారు నమోదు చేసిన స్ట్రింగ్‌లను సేవ్ చేస్తుంది. తరువాత, మేము 'cout' ఆదేశాన్ని ఉపయోగించి 'పేరు' వేరియబుల్లో సేవ్ చేయబడిన తీగలను ప్రదర్శిస్తాము.
కోడ్ 7:
#ఉపయోగించి నేమ్‌స్పేస్ std ;
int ప్రధాన ( ) {
స్ట్రింగ్ పేరు ;
కోట్ << 'దయచేసి ఇక్కడ మీ పూర్తి పేరును నమోదు చేయండి:' ;
గెట్‌లైన్ ( ఆహారపు , పేరు ) ;
కోట్ << 'మీ పూర్తి పేరు:' << పేరు ;
తిరిగి 0 ;
}
అవుట్‌పుట్:
ఇక్కడ, ఈ ఫలితంలో, మేము స్ట్రింగ్ డేటాగా 'జేమ్స్ శామ్యూల్'ని నమోదు చేస్తాము. మేము 'Enter' నొక్కినప్పుడు, మేము 'getline()' ఫంక్షన్‌ని ఉపయోగించాము కనుక ఇది పూర్తి పేరును ఇక్కడ ప్రదర్శిస్తుంది.
ముగింపు
మేము ఈ గైడ్‌లో “C++ యూజర్ ఇన్పుట్” గురించి చర్చించాము. మేము ఈ కాన్సెప్ట్‌ను అన్వేషించాము మరియు వినియోగదారు ఇన్‌పుట్‌ను పొందడానికి “>>” సంగ్రహణ చిహ్నాలతో పాటు “cin” కమాండ్ ఉపయోగించబడుతుందని తెలుసుకున్నాము. మేము “cin>>” కమాండ్ సహాయంతో వినియోగదారు నుండి పూర్ణాంకం, ఫ్లోట్, డబుల్, చార్ మరియు స్ట్రింగ్ డేటా రకం విలువలను ఇన్పుట్ చేసాము మరియు “యూజర్ ఇన్పుట్” కాన్సెప్ట్ వివరంగా వివరించబడిన C++ ఉదాహరణలను ప్రదర్శించాము. .