C లో %c ఎందుకు ఉపయోగించబడుతుంది?
ఏ ఇతర ప్రోగ్రామింగ్ లాంగ్వేజ్ లాగా, C కూడా ప్రోగ్రామ్‌లను రూపొందించడానికి అనుసరించాల్సిన స్థిరమైన వాక్యనిర్మాణాన్ని కలిగి ఉంది. C యొక్క ప్రాథమిక వాక్యనిర్మాణం వినియోగదారులు చేర్చవలసి ఉంటుంది సి హెడర్ ఫైల్స్ మొదటిది, అవి
int ప్రధాన ( శూన్యం ) {
}
మరియు అవుట్‌పుట్‌ను ప్రదర్శించడానికి ప్రింట్ కమాండ్ ఉపయోగించబడుతుంది. ఉదాహరణకు, ఒక లేఖను ముద్రించడానికి ప్రయత్నిద్దాం కె అవుట్‌పుట్‌గా మరియు దాని కోసం, ప్రధాన ఫంక్షన్‌లో దిగువ వ్రాసిన ఆదేశాన్ని ఉపయోగించండి:
printf ( '%d' , 'k' ) ;
అవుట్‌పుట్‌లో, మీరు అక్షరానికి బదులుగా దాన్ని చూడవచ్చు k, ఒక సంఖ్య అవుట్‌పుట్‌గా ప్రదర్శించబడుతుంది. గందరగోళం?
అక్షరానికి బదులుగా సంఖ్య ఎందుకు ముద్రించబడిందో ఇప్పుడు ఈ భావనను అర్థం చేసుకుందాం కె , కాబట్టి సమాధానం ఏమిటంటే, కంప్యూటర్ అనేది సంఖ్యలపై పనిచేసే యంత్రం కాబట్టి ప్రతి అక్షరం లేదా అక్షరానికి సమానమైన యంత్ర సంఖ్య (ASCII కోడ్) ఉంటుంది. ఉదాహరణకి; పై ఉదాహరణలో యంత్రానికి సమానమైన సంఖ్య కె ఉంది 107 . ఒక వినియోగదారు ఉపయోగిస్తుంటే %d ఒక అక్షరంతో, ప్రోగ్రామ్ అక్షరం యొక్క ASCII కోడ్‌ను ప్రదర్శిస్తుంది మరియు అసలు అక్షరాన్ని కాదు.
ఇష్టం %d , ది %c అసలు అక్షరాన్ని ప్రదర్శించడానికి ఉపయోగించబడుతుంది. ఇప్పుడు ప్రింట్ చేయడానికి పై ఆదేశాన్ని అమలు చేద్దాం కె కేవలం భర్తీ %d తో %c , క్రింద చూపిన విధంగా:
printf ( '%c' , 'k' ) ; 
ఇప్పుడు అవుట్‌పుట్‌లో, మీరు సంఖ్యకు బదులుగా అక్షరాన్ని స్పష్టంగా చూడవచ్చు కె స్వయంగా ముద్రించబడింది. కాబట్టి, వినియోగదారులు అక్షరాన్ని ముద్రించాలనుకున్నప్పుడు, వారు ఉపయోగించవచ్చు %c ప్రింట్ కమాండ్ లోపల. ది %c ప్రాతినిధ్యం వహిస్తుంది 'పాత్ర' మరియు అక్షర అవుట్‌పుట్ అవసరమని కంపైలర్‌కు తెలియజేస్తుంది:
అర్రేలలో %cని ఉపయోగిస్తోంది
ఇప్పుడు అక్షర శ్రేణిని ఉపయోగించి ప్రింట్ చేద్దాం %c ప్రింట్ కమాండ్‌తో. దిగువ ప్రోగ్రామ్‌లో, నేను శ్రేణిని నిర్వచించాను 9 అక్షరాలు మరియు నేను ఈ ఖచ్చితమైన శ్రేణి మూలకాలను ఒక్కొక్కటిగా ముద్రించాలనుకుంటున్నాను. దాని కోసం, నేను ఒక ఉపయోగించాను లూప్ కోసం లోపల ఇది printf కమాండ్ తో పాటు ఉంటుంది %c :
##
int ప్రధాన ( శూన్యం ) {
చార్ అమరిక [ ] = { 'ఎల్' , 'నేను' , 'N' , 'IN' , 'X' , 'H' , 'నేను' , 'N' , 'టి' } ;
కోసం ( int x = 0 ; x < 9 ; x ++ ) {
printf ( '%c' , అమరిక [ x ] ) ;
printf ( ' \n ' ) ;
}
}
ప్రోగ్రామ్‌ని అమలు చేసిన తర్వాత, అవుట్‌పుట్ అక్షరాన్ని ఒక్కొక్కటిగా ప్రదర్శించినట్లు మీరు చూడవచ్చు:
ఇప్పుడు ప్రోగ్రామ్‌ను అలాగే ఉంచండి మరియు భర్తీ చేయండి %c తో %d printf కమాండ్ లోపల మరియు అవుట్‌పుట్‌లో తేడాను గమనించండి:
##
int ప్రధాన ( శూన్యం ) {
చార్ అమరిక [ ] = { 'ఎల్' , 'నేను' , 'N' , 'IN' , 'X' , 'H' , 'నేను' , 'N' , 'టి' } ;
కోసం ( int x = 0 ; x < 9 ; x ++ ) {
printf ( '%d' , అమరిక [ x ] ) ;
printf ( ' \n ' ) ;
}
}
ఇప్పుడు అవుట్‌పుట్‌లో, దాన్ని మార్చడం ద్వారా మీరు దాన్ని చూడవచ్చు %c, అవుట్‌పుట్ పూర్తిగా మారిపోయింది. అక్షరాలకు బదులుగా, వాటి ASCII కోడ్‌లు ప్రదర్శించబడతాయి:
ముగింపు
ది %c C ప్రోగ్రామింగ్ భాషలో పాత్రను సూచించడానికి ఉపయోగిస్తారు. వినియోగదారులు అక్షరాన్ని లేదా అక్షరాల శ్రేణిని ప్రింట్ చేయాలనుకుంటే వారు కేవలం ఉపయోగించుకోవచ్చు %c printf కమాండ్‌తో కంపైలర్‌కు అవుట్‌పుట్ అక్షర రూపంలో అవసరమని తెలియజేయడానికి. ఉంటే %d బదులుగా ఉపయోగించబడుతుంది %c , అవుట్‌పుట్ పూర్తిగా మారుతుంది మరియు అక్షర అవుట్‌పుట్‌ను ప్రదర్శించడానికి బదులుగా, ఇది ప్రతి అక్షరం యొక్క ASCII కోడ్‌ను ప్రదర్శిస్తుంది.