సి ప్రోగ్రామింగ్ లాంగ్వేజ్ ఐదు దశాబ్దాల క్రితం ప్రారంభించబడింది. అప్పటి నుండి, ఇది ప్రోగ్రామింగ్ ప్రపంచంలో అపారమైన ప్రజాదరణ పొందింది. నిర్మాణాత్మక సరళత, విధులు, పోర్టబిలిటీ, సమర్ధవంతమైన మెమరీ నిర్వహణ మొదలైన వాటితో సహా దాని లక్షణాల కారణంగా ఇది ఇతర భాషల కంటే అత్యుత్తమంగా ఉంది. అనేక ఇతర ఫీచర్లు ఉన్నప్పటికీ, C లోని ఫంక్షన్‌లు చాలా మంది వినియోగదారులకు బలమైన కోడ్ స్నిప్పెట్‌లను వ్రాయడంలో సహాయపడే అత్యంత ప్రముఖ ఆస్తులు.
ఇంకా, itoa అనేది డేటా రకం కన్వర్టర్‌గా పనిచేసే విస్తృతంగా ఉపయోగించే ప్రామాణికం కాని ఫంక్షన్. ఇది డేటా టైప్ intని ఇన్‌పుట్‌గా తీసుకుంటుంది మరియు దానిని స్ట్రింగ్‌గా మారుస్తుంది. అయితే, మీలో చాలా మందికి దీని ఉపయోగం తెలియదు. కాబట్టి, ఈ గైడ్ ఎటువంటి అవాంతరాలు లేకుండా C లో itoa ఫంక్షన్‌ను ఎలా ఉపయోగించాలో సంక్షిప్తంగా వివరిస్తుంది.
C లో Itoa ఫంక్షన్‌ను ఎలా ఉపయోగించాలి
ప్రాథమిక అంశాలతో ప్రారంభిద్దాం. itoa ఫంక్షన్ కోసం సాధారణ వాక్యనిర్మాణం ఇక్కడ ఉంది:
int ప్రధాన ( ) {
int ఒకదానిపై = 12345 ;
చార్ str [ ఇరవై ] ;
మునిగిపోయాడు ( ఒకదానిపై , str , 10 ) ;
printf ( 'పూర్ణాంకం: %d \n స్ట్రింగ్: %s \n ' , ఒకదానిపై , str ) ;
తిరిగి 0 ;
}
ఇచ్చిన ప్రోగ్రామ్‌లో, వివరాలు క్రింది విధంగా ఉన్నాయి:
- num అనేది పూర్ణాంకం
- str అనేది పాత్ర
- 10 అనేది బాస్
ఇప్పుడు, ముందుకు వెళ్దాం, ప్రోగ్రామ్‌ను వ్రాసి, itoa ఫంక్షన్‌ని అమలు చేయండి. ఉదాహరణకు, మేము నమోదు చేసిన సంఖ్యలను స్ట్రింగ్‌లోకి మార్చడానికి ప్రోగ్రామ్‌ను వ్రాయాలి.
#
#
శూన్యం మునిగిపోయాడు ( int ఒకదానిపై , చార్ * str , int బేస్ ) {
int i = 0 ;
int ప్రతికూలమైనది = 0 ;
ఉంటే ( ఒకదానిపై == 0 ) {
str [ i ++ ] = '0' ;
str [ i ] = ' \0 ' ;
తిరిగి ;
}
ఉంటే ( ఒకదానిపై < 0 && బేస్ != 10 ) {
ప్రతికూలమైనది = 1 ;
ఒకదానిపై = - ఒకదానిపై ;
}
అయితే ( ఒకదానిపై != 0 ) {
int రెం = ఒకదానిపై % బేస్ ;
str [ i ++ ] = ( రెం > 9 ) ? ( రెం - 10 ) + 'a' : రెం + '0' ;
ఒకదానిపై = ఒకదానిపై / బేస్ ;
}
ఉంటే ( ప్రతికూలమైనది && బేస్ == 10 )
str [ i ++ ] = '-' ;
str [ i ] = ' \0 ' ;
int ప్రారంభించండి = 0 ;
int ముగింపు = i - 1 ;
అయితే ( ప్రారంభించండి < ముగింపు ) {
చార్ ఉష్ణోగ్రత = str [ ప్రారంభించండి ] ;
str [ ప్రారంభించండి ] = str [ ముగింపు ] ;
str [ ముగింపు ] = ఉష్ణోగ్రత ;
ప్రారంభించండి ++;
ముగింపు --;
}
}
int ప్రధాన ( ) {
int ఒకదానిపై ;
printf ( 'పూర్ణాంకాన్ని నమోదు చేయండి:' ) ;
ఉంటే ( స్కాన్ఎఫ్ ( '%d' , & ఒకదానిపై ) != 1 ) {
fprintf ( stderr , 'చెల్లని ఇన్‌పుట్. దయచేసి పూర్ణాంకాన్ని నమోదు చేయండి. \n ' ) ;
తిరిగి EXIT_FAILURE ;
}
int గరిష్ట_పరిమాణం = snprintf ( శూన్య , 0 , '%d' , ఒకదానిపై ) + 1 ;
చార్ * str = ( చార్ * ) malloc ( గరిష్ట_పరిమాణం ) ;
ఉంటే ( str == శూన్య ) {
fprintf ( stderr , 'మెమరీ కేటాయింపు విఫలమైంది \n ' ) ;
తిరిగి EXIT_FAILURE ;
}
మునిగిపోయాడు ( ఒకదానిపై , str , 10 ) ;
printf ( 'పూర్ణాంకం: %d \n స్ట్రింగ్: %s \n ' , ఒకదానిపై , str ) ;
ఉచిత ( str ) ;
తిరిగి 0 ;
}
మునుపటి ప్రోగ్రామ్‌లో, itoa (int num, char *str, int base) అనేది itoa ఫంక్షన్. అంతేకాకుండా, ఇన్‌పుట్ సంఖ్య కూడా సున్నా అయినప్పుడు కింది వాక్యనిర్మాణం నేరుగా ఫలితానికి సున్నాని కేటాయిస్తుంది:
ఉంటే ( ఒకదానిపై == 0 ) {str [ i ++ ] = '0' ;
str [ i ] = ' \0 ' ;
తిరిగి ;
}
ఇన్‌పుట్ సంఖ్య ప్రతికూలంగా ఉన్నప్పుడు మరియు ఆధారం కూడా 10 కానప్పుడు, క్రింది ప్రోగ్రామ్ లైన్‌లు ప్రతికూల ఫ్లాగ్‌ను సెట్ చేస్తాయి:
ఉంటే ( ఒకదానిపై < 0 && బేస్ != 10 ) {
ప్రతికూలమైనది = 1 ;
ఒకదానిపై = - ఒకదానిపై ;
కింది లూప్ అన్ని అంకెలను ప్రాసెస్ చేస్తుంది మరియు వాటిని సంబంధిత అక్షరానికి మారుస్తుంది. అందువల్ల, 10 కంటే ఎక్కువ ఉన్న స్థావరాల కోసం, ప్రోగ్రామ్ 10 నుండి 15 అంకెలకు “a” నుండి “f” వరకు అక్షరాలను ఉపయోగిస్తుంది.
}అయితే ( ఒకదానిపై != 0 ) {
int రెం = ఒకదానిపై % బేస్ ;
str [ i ++ ] = ( రెం > 9 ) ? ( రెం - 10 ) + 'a' : రెం + '0' ;
ఒకదానిపై = ఒకదానిపై / బేస్ ;
}
సంఖ్య వాస్తవానికి ప్రతికూలంగా ఉన్నప్పుడు మరియు ఆధారం 10 అయినప్పుడు, ప్రోగ్రామ్ ప్రతికూల చిహ్నాన్ని ఫలిత స్ట్రింగ్‌కు జోడిస్తుంది.
ఉంటే ( ప్రతికూలమైనది && బేస్ == 10 )str [ i ++ ] = '-' ;
కింది పంక్తులు ఫలిత స్ట్రింగ్‌ను ముగించి, మార్పిడి ప్రక్రియలో అంకెలు రివర్స్ ఆర్డర్‌లో పొందబడినందున దాన్ని రివర్స్ చేస్తాయి:
str [ i ] = ' \0 ' ;// స్ట్రింగ్‌ను రివర్స్ చేయండి
int ప్రారంభించండి = 0 ;
int ముగింపు = i - 1 ;
అయితే ( ప్రారంభించండి < ముగింపు ) {
చార్ ఉష్ణోగ్రత = str [ ప్రారంభించండి ] ;
str [ ప్రారంభించండి ] = str [ ముగింపు ] ;
str [ ముగింపు ] = ఉష్ణోగ్రత ;
ప్రారంభించండి ++;
ముగింపు --;
}
అందువల్ల, ప్రోగ్రామ్ పూర్ణాంకాన్ని ఇన్‌పుట్‌గా తీసుకుంటుంది మరియు స్ట్రింగ్ ప్రాతినిధ్యం కోసం మెమరీని కేటాయిస్తుంది. ఆ తర్వాత, ఇది పూర్ణాంకాన్ని స్ట్రింగ్‌గా మార్చడానికి itoa అని పిలుస్తుంది మరియు అసలు పూర్ణాంకాన్ని ముద్రిస్తుంది. చివరగా, ఇది కేటాయించిన మెమరీని ఖాళీ చేస్తుంది. ఉదాహరణకు, ప్రోగ్రామ్‌కు సంఖ్యను ఇద్దాం:
అయితే, మీరు పూర్ణాంకం కాని సంఖ్యను నమోదు చేస్తే, ప్రోగ్రామ్ క్రింది ఫలితాన్ని చూపుతుంది:
ముగింపు
ఈ విధంగా మీరు సిలో ఇటోవా ఫంక్షన్‌ను సులభంగా అమలు చేయవచ్చు మరియు ఉపయోగించవచ్చు. మేము పూర్ణాంకాన్ని స్ట్రింగ్‌గా మార్చడానికి బహుళ ఫంక్షన్‌లను కలిగి ఉన్న వివరణాత్మక ఉదాహరణను ఉపయోగించాము. గుర్తుంచుకోండి, ఇది ఒక ఉదాహరణ మాత్రమే, కానీ మీరు అద్భుతమైన ప్రోగ్రామ్‌లను వ్రాయడానికి వివిధ ఫంక్షన్‌లతో itoa ఫంక్షన్‌ను మిళితం చేయవచ్చు.