ది పుట్చార్() ఫంక్షన్ అనేది C ప్రోగ్రామింగ్‌లో ఒక ముఖ్యమైన ఫంక్షన్, ఇది అక్షరాన్ని చదవడానికి మరియు ముద్రించడానికి ఉపయోగించబడుతుంది. కానీ మీరు ఈ ఫంక్షన్‌తో ఫార్మాట్ స్పెసిఫైయర్‌లను ఉపయోగించలేరు. మీరు ఒక అక్షరాన్ని మాత్రమే ముద్రించాలనుకుంటే పుట్చార్() తో పోలిస్తే ఫంక్షన్ మరింత సమర్థవంతంగా ఉంటుంది printf().
ఈ వ్యాసం అన్వేషించబోతోంది పుట్చార్() f ఫంక్షన్, దాని వాక్యనిర్మాణం మరియు ఉదాహరణలతో దాని రిటర్న్ విలువ.
C లో పుట్చార్() ఫంక్షన్ అంటే ఏమిటి?
ది పుట్చార్() C ప్రోగ్రామింగ్‌లోని ఫంక్షన్ అనేది ప్రామాణిక అవుట్‌పుట్‌లో అక్షర(ల)ను వ్రాయడానికి ఉపయోగించే అవుట్‌పుట్ ఫంక్షన్ మరియు ఆ పాత్ర(ల)ని కన్సోల్‌కు ప్రదర్శిస్తుంది. ఈ ఫంక్షన్ ప్రామాణిక ఇన్‌పుట్/అవుట్‌పుట్ లైబ్రరీ ద్వారా చేర్చబడింది
int పుట్చార్ ( int చార్ ) ;
పరామితి : ఈ ఫంక్షన్ అవుట్‌పుట్ స్ట్రీమ్‌కు వ్రాయడానికి అవసరమైన చార్ అయిన ఒక పరామితిని మాత్రమే అంగీకరిస్తుంది.
రిటర్న్ విలువ : విజయవంతం అయినప్పుడు, ఫంక్షన్ కన్సోల్‌కు సంతకం చేయని అక్షరాన్ని అందిస్తుంది. లేకపోతే, ఇది EOF (ఫైల్ ముగింపు)ని అందిస్తుంది.
C లో putchar() ఫంక్షన్‌ని ఎలా ఉపయోగించాలి?
ఉపయోగం తెలుసుకోవడానికి క్రింది ఉదాహరణలను పరిగణించండి putchar() ఫంక్షన్ సి ప్రోగ్రామింగ్‌లో.
ఉదాహరణ 1
ఉపయోగించి ప్రోగ్రామ్ నుండి ఒక అక్షరాన్ని చదవడానికి ఒక సాధారణ ఉదాహరణను అనుసరించండి పుట్చార్() ఫంక్షన్ మరియు దానిని కన్సోల్‌లో ప్రదర్శిస్తుంది.
#
ప్రధాన ( ) {
// ఒక పాత్రను ప్రకటించండి
చార్ సి ;
//పాత్రను నమోదు చేయమని వినియోగదారుని అడగండి
printf ( 'దయచేసి ఒక అక్షరాన్ని నమోదు చేయండి:' ) ;
స్కాన్ఎఫ్ ( '%c' , & సి ) ;
//ఇచ్చిన అక్షరాన్ని కన్సోల్‌కు ప్రింట్ చేయడానికి పుట్చార్()ని ఉపయోగించండి
printf ( 'ప్రవేశించిన పాత్ర:' ) ;
పుట్చార్ ( సి ) ;
తిరిగి 0 ;
}
ఉదాహరణ 2
యొక్క పనిని ప్రదర్శించే మరొక C ప్రోగ్రామ్ ఇక్కడ ఉంది పుట్చార్() స్ట్రింగ్ నుండి అక్షరాలను చదవడం ద్వారా ఫంక్షన్.
#ప్రధాన ( ) {
// అక్షరాల శ్రేణిని ప్రకటించండి
చార్ str [ యాభై ] = 'linuxhintకి స్వాగతం.' ;
కోసం ( int i = 0 ; i <= 25 ; i ++ ) {
//కన్సోల్‌కు ఇచ్చిన అక్షరాల స్ట్రింగ్‌ను ప్రింట్ చేయడానికి పుట్చార్()ని ఉపయోగించండి
పుట్చార్ ( str [ i ] ) ;
}
తిరిగి 0 ;
}
ఉదాహరణ 3
మీరు కూడా ఉపయోగించవచ్చు పుట్చార్() ఫైల్ నుండి అక్షరాలను చదవడానికి ఫంక్షన్ మరియు అటువంటి సందర్భానికి ఉదాహరణ ఇక్కడ ఉంది.
#int ప్రధాన ( )
{
ఫైల్ * ఫైల్ ;
చార్ సి ;
// రీడింగ్ మోడ్‌లో ఫైల్‌ను తెరవడం
ఫైల్ = ఫోపెన్ ( 'file.txt' , 'r' ) ;
ఉంటే ( శూన్య == ఫైల్ )
{
printf ( 'ఫైల్ తెరవబడదు \n ' ) ;
}
// లూప్‌ని ఉపయోగించి పుట్చార్(), క్యారెక్టర్ బై క్యారెక్టర్‌ని ఉపయోగించి ఫైల్‌లో వ్రాసిన వాటిని ముద్రించడం.
చేయండి {
సి = fgetc ( ఫైల్ ) ;
పుట్చార్ ( సి ) ;
// అక్షరం EOF కాదా అని తనిఖీ చేస్తోంది. EOF అయితే చదవడం ఆపండి.
} అయితే ( సి != EOF ) ;
// ఫైల్‌ను మూసివేయడం
fclose ( ఫైల్ ) ;
తిరిగి 0 ;
}
అవుట్‌పుట్
ముగింపు
ది పుట్చార్() ఫంక్షన్ అనేది C ప్రోగ్రామింగ్‌లో ఒక పాత్రను కన్సోల్‌కు ప్రింట్ చేయడానికి ఉపయోగించే ముఖ్యమైన ఫంక్షన్. ఇది ప్రత్యేక ఫార్మాట్‌లను అనుమతించనప్పటికీ, దాని కంటే ఇది మరింత ఉపయోగకరంగా ఉంటుంది printf() కేవలం ఒక అక్షరాన్ని ప్రింట్ చేస్తున్నప్పుడు. ఇది సాధారణ సింటాక్స్ మరియు రిటర్న్ విలువతో C ప్రోగ్రామ్‌లలో ఉపయోగించడం మరియు ఉపయోగించడం సులభం. వినియోగదారు ఇన్‌పుట్, స్ట్రింగ్‌లు మరియు డేటా నుండి అక్షరాలను చదవడం కోసం ఉపయోగించండి ఉదాహరణలు అందించబడ్డాయి, తద్వారా మీరు ఎలా ఉపయోగించాలో సులభంగా అర్థం చేసుకోవచ్చు పుట్చార్() వివిధ సాధారణ పరిస్థితులలో.