స్ట్రింగ్ ఫార్మాట్ చేయండి
ఫార్మాట్ స్ట్రింగ్ అనేది నమోదు చేసిన డేటా కోసం ఫార్మాట్. ఈ ఫార్మాట్ % సైన్‌తో మొదలవుతుంది మరియు దాని తర్వాత ఫార్మాట్ స్పెసిఫైయర్ ఉంటుంది. ఫార్మాట్ స్పెసిఫైయర్ అనేది ఒక నిర్దిష్ట అక్షరం, ఇది ఏ రకమైన డేటా చదవబడుతుందో ఉపయోగించబడుతుంది.
arg1, arg2, arg3 ... నమోదు చేసిన డేటా నిల్వ చేయబడే వేరియబుల్స్ యొక్క చిరునామాలు.
scanf () ఫంక్షన్
వాక్యనిర్మాణం: int scanf (ఫార్మాట్ స్ట్రింగ్, arg1, arg2, arg3 ...)
తరచుగా ఉపయోగించే కొన్ని స్పెసిఫైయర్‌లు క్రింది విధంగా ఉన్నాయి:
- డి - పూర్ణాంక విలువలకు ఉపయోగిస్తారు.
- f - ఫ్లోటింగ్ నంబర్ కోసం ఉపయోగిస్తారు.
- c - ఒకే అక్షర విలువ కోసం ఉపయోగిస్తారు.
- లు - తీగలకు ఉపయోగిస్తారు.
సింగిల్ ఉపయోగించి scanf () ఫంక్షన్, ఒకటి లేదా బహుళ ఇన్పుట్ యూజర్ నుండి తీసుకోవచ్చు.
ది scanf () ఫంక్షన్ ప్రామాణిక ఇన్పుట్ (కీబోర్డ్) నుండి ఇన్పుట్ తీసుకుంటుంది మరియు విలువను వేరియబుల్‌లో నిల్వ చేస్తుంది. వినియోగదారు ఎంటర్ కీని నొక్కే వరకు ఫంక్షన్ యూజర్ ఇన్పుట్ కోసం వేచి ఉంటుంది. నమోదు చేసిన విలువ బఫర్‌లో నిల్వ చేయబడుతుంది. ఎంటర్ కీ నొక్కినప్పుడు, scanf () ఫంక్షన్ చదవడం మొదలవుతుంది.
ఉదాహరణ 1: పూర్ణాంక ఇన్పుట్
// ఉదాహరణ 1..సి#చేర్చండి
intప్రధాన(){
inti;
printf ('1 వ పూర్ణాంక విలువను నమోదు చేయండి:');
scanf ('%d', &i);
printf ('మీరు ప్రవేశించారు: %d n',నేను);
printf ('2 వ పూర్ణాంక విలువను నమోదు చేయండి:');
scanf ('%d', &i);
printf ('మీరు ప్రవేశించారు: %d n',నేను);
తిరిగి 0;
}
Example1.c లో, మేము పూర్ణాంక విలువలను నమోదు చేసి ఎంటర్ కీని నొక్కినప్పుడు చూశాము. ది scanf () ఫంక్షన్ విలువను తీసుకొని వేరియబుల్‌లో నిల్వ చేస్తుంది. మనం స్పేస్ ద్వారా వేరు చేయబడిన విలువలను నమోదు చేస్తే, స్పేస్ ఎదురైనప్పుడు ఫంక్షన్ తిరిగి వస్తుంది కానీ స్పేస్ తర్వాత విలువలు ఇన్పుట్ బఫర్‌లో ఉంటాయి. అందుకే రెండవది scanf () ఫంక్షన్ వినియోగదారు ఇన్పుట్ కోసం వేచి ఉండదు, బదులుగా అది బఫర్ నుండి ఇన్పుట్ తీసుకుంటుంది.
ఉదాహరణ 2: సింగిల్ క్యారెక్టర్ ఇన్పుట్
// ఉదాహరణ 2.సి#చేర్చండి
intప్రధాన(){
చార్c;
printf ('అక్షరాన్ని నమోదు చేయండి:');
scanf ('% c', &c);
printf ('మీరు ప్రవేశించారు: %c n',c);
తిరిగి 0;
}
Example2.c లో, మనం ఉపయోగించినప్పుడు చూశాము % సి నిర్ధిష్ట, ది scanf () మేము ఒకటి కంటే ఎక్కువ అక్షరాలను నమోదు చేసినప్పటికీ ఫంక్షన్ ఒక అక్షరాన్ని మాత్రమే తీసుకుంటుంది.
ఉదాహరణ 3: సింగిల్ క్యారెక్టర్ ఇన్పుట్ (మల్టిపుల్ టైమ్స్)
// ఉదాహరణ 3. సి#చేర్చండి
intప్రధాన(){
చార్c;
printf ('1 వ అక్షరాన్ని నమోదు చేయండి:');
scanf ('% c', &c);
printf ('మీరు ప్రవేశించారు: %c n',c);
printf ('2 వ అక్షరాన్ని నమోదు చేయండి:');
scanf ('% c', &c);
printf ('మీరు ప్రవేశించారు: %c n',c);
తిరిగి 0;
}
ఉదాహరణ 4 :
// ఉదాహరణ 4. సి#చేర్చండి
intప్రధాన(){
చార్c;
printf ('1 వ అక్షరాన్ని నమోదు చేయండి:');
scanf ('% c', &c);
printf ('మీరు ప్రవేశించారు: %c n',c);
printf ('2 వ అక్షరాన్ని నమోదు చేయండి:');
scanf ('% c', &c);
printf ('మీరు ప్రవేశించారు: %c n',c);
తిరిగి 0;
}
ఉదాహరణ 5: స్ట్రింగ్ ఇన్పుట్
// ఉదాహరణ 5. సి#చేర్చండి
intప్రధాన(){
చార్పేరు[పదిహేను];
printf ('మీ పేరు రాయుము, మీ పేరు రాయండి: ');
scanf ('%s',పేరు);
printf ('మీరు ప్రవేశించారు: %s n',పేరు);
తిరిగి 0;
}
getc () ఫంక్షన్
వాక్యనిర్మాణం: int getc (ఫైల్ *స్ట్రీమ్)
getc () FILE పాయింటర్ (స్ట్రీమ్) నుండి అక్షరాన్ని చదవడానికి ఫంక్షన్ ఉపయోగించబడుతుంది. కీబోర్డ్ నుండి చదవడానికి, మేము ఉపయోగించాలి stdin . ఈ ఫంక్షన్ చదివిన అక్షరం యొక్క పూర్ణాంక విలువను అందిస్తుంది.
ఉదాహరణ 6:
//Example6.c#చేర్చండి
intప్రధాన(){
చార్c;
printf ('1 వ అక్షరాన్ని నమోదు చేయండి:');
అయితే((c= getc (stdin))==' n');
printf ('మీరు ప్రవేశించారు: %c n',c);
అయితే( getc (stdin)! =' n');
printf ('2 వ అక్షరాన్ని నమోదు చేయండి:');
అయితే((c= getc (stdin))==' n');
printf ('మీరు ప్రవేశించారు: %c n',c);
తిరిగి 0;
}
getchar () ఫంక్షన్
వాక్యనిర్మాణం: int getchar (శూన్యం)
పొందండి () ఫంక్షన్ అదే getc () . ఒక్కటే తేడా getc () ఫంక్షన్ ఏదైనా ఇన్పుట్ స్ట్రీమ్ నుండి చదవగలదు, అయితే పొందండి () ఫంక్షన్ ప్రామాణిక ఇన్పుట్ నుండి మాత్రమే చదవబడుతుంది.
ఉదాహరణ 7:
// ఉదాహరణ 7. సి#చేర్చండి
intప్రధాన(){
చార్c;
printf ('1 వ అక్షరాన్ని నమోదు చేయండి:');
అయితే((c= పొందండి ())==' n');
printf ('మీరు ప్రవేశించారు: %c n',c);
అయితే( పొందండి ()! =' n');
printf ('2 వ అక్షరాన్ని నమోదు చేయండి:');
అయితే((c= పొందండి ())==' n');
printf ('మీరు ప్రవేశించారు: %c n',c);
తిరిగి 0;
}
ముగింపు
ఈ వ్యాసంలో, సి భాషలో ఇన్పుట్ ఫంక్షన్లు ఎలా ఉపయోగించబడుతున్నాయో చూశాము. ఈ ఫంక్షన్లన్నీ ఇన్పుట్ బఫర్ నుండి ఇన్పుట్ తీసుకోబడ్డాయి మరియు మేము ఈ ఫంక్షన్‌లను అనేకసార్లు ఉపయోగించినప్పుడు, మేము బఫర్‌ను క్లియర్ చేయాలి. లేకపోతే, ఫంక్షన్లు వినియోగదారు ఇన్పుట్ కోసం వేచి ఉండవు మరియు బఫర్ నుండి ఇన్‌పుట్‌ను తీసుకోవు.