சி நிரலாக்க மொழி ஐந்து தசாப்தங்களுக்கு முன்பு தொடங்கப்பட்டது. அப்போதிருந்து, இது நிரலாக்க உலகில் பெரும் புகழ் பெற்றது. கட்டமைப்பு எளிமை, செயல்பாடுகள், பெயர்வுத்திறன், திறமையான நினைவக மேலாண்மை போன்ற அதன் அம்சங்களின் காரணமாக இது மற்ற மொழிகளில் சிறந்து விளங்குகிறது. பல்வேறு அம்சங்களைக் கொண்டிருந்தாலும், C இல் உள்ள செயல்பாடுகள் பல பயனர்களுக்கு வலுவான குறியீடு துணுக்குகளை எழுதுவதற்கு உதவும் மிக முக்கியமான சொத்துகளாகும்.
மேலும், itoa என்பது தரவு வகை மாற்றியாகச் செயல்படும் பரவலாகப் பயன்படுத்தப்படும் தரமற்ற செயல்பாடாகும். இது தரவு வகை int ஐ உள்ளீடாக எடுத்து அதை சரமாக மாற்றுகிறது. இருப்பினும், உங்களில் பலருக்கு அதன் பயன்பாடு தெரியாது. எனவே, இந்த வழிகாட்டியானது, எந்த தொந்தரவும் இல்லாமல் C இல் இட்டோவா செயல்பாட்டை எவ்வாறு பயன்படுத்துவது என்பதை சுருக்கமாக விளக்குகிறது.
C இல் Itoa செயல்பாட்டை எவ்வாறு பயன்படுத்துவது
அடிப்படைகளுடன் ஆரம்பிக்கலாம். itoa செயல்பாட்டிற்கான எளிய தொடரியல் இங்கே:
முழு எண்ணாக முக்கிய ( ) {
முழு எண்ணாக ஒன்றில் = 12345 ;
கரி str [ இருபது ] ;
மூழ்கினார் ( ஒன்றில் , str , 10 ) ;
printf ( 'முழு எண்: %d \n சரம்: %s \n ' , ஒன்றில் , str ) ;
திரும்ப 0 ;
}
கொடுக்கப்பட்ட திட்டத்தில், விவரங்கள் பின்வருமாறு:
- எண் என்பது முழு எண்
- str என்பது பாத்திரம்
- 10 என்பது பாஸ்
இப்போது, முன்னோக்கி நகர்வோம், ஒரு நிரலை எழுதி, itoa செயல்பாட்டை செயல்படுத்துவோம். எடுத்துக்காட்டாக, உள்ளிடப்பட்ட எண்களை சரத்தில் மாற்ற ஒரு நிரலை எழுத வேண்டும்.
#
#
வெற்றிடமானது மூழ்கினார் ( முழு எண்ணாக ஒன்றில் , கரி * str , முழு எண்ணாக அடித்தளம் ) {
முழு எண்ணாக நான் = 0 ;
முழு எண்ணாக எதிர்மறையானது = 0 ;
என்றால் ( ஒன்றில் == 0 ) {
str [ நான் ++ ] = '0' ;
str [ நான் ] = ' \0 ' ;
திரும்ப ;
}
என்றால் ( ஒன்றில் < 0 && அடித்தளம் != 10 ) {
எதிர்மறையானது = 1 ;
ஒன்றில் = - ஒன்றில் ;
}
போது ( ஒன்றில் != 0 ) {
முழு எண்ணாக rem = ஒன்றில் % அடித்தளம் ;
str [ நான் ++ ] = ( rem > 9 ) ? ( rem - 10 ) + 'a' : rem + '0' ;
ஒன்றில் = ஒன்றில் / அடித்தளம் ;
}
என்றால் ( எதிர்மறையானது && அடித்தளம் == 10 )
str [ நான் ++ ] = '-' ;
str [ நான் ] = ' \0 ' ;
முழு எண்ணாக தொடங்கு = 0 ;
முழு எண்ணாக முடிவு = நான் - 1 ;
போது ( தொடங்கு < முடிவு ) {
கரி வெப்பநிலை = str [ தொடங்கு ] ;
str [ தொடங்கு ] = str [ முடிவு ] ;
str [ முடிவு ] = வெப்பநிலை ;
தொடங்கு ++;
முடிவு --;
}
}
முழு எண்ணாக முக்கிய ( ) {
முழு எண்ணாக ஒன்றில் ;
printf ( 'ஒரு முழு எண்ணை உள்ளிடவும்:' ) ;
என்றால் ( ஸ்கேன்எஃப் ( '%d' , & ஒன்றில் ) != 1 ) {
fprintf ( stderr , 'தவறான உள்ளீடு. முழு எண்ணை உள்ளிடவும். \n ' ) ;
திரும்ப EXIT_FAILURE ;
}
முழு எண்ணாக அதிகபட்ச_அளவு = 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 [ நான் ++ ] = '0' ;
str [ நான் ] = ' \0 ' ;
திரும்ப ;
}
உள்ளீட்டு எண் எதிர்மறையாகவும், அடிப்படை 10 ஆகவும் இல்லாதபோது, பின்வரும் நிரல் வரிகள் எதிர்மறைக் கொடியை அமைக்கும்:
என்றால் ( ஒன்றில் < 0 && அடித்தளம் != 10 ) {
எதிர்மறையானது = 1 ;
ஒன்றில் = - ஒன்றில் ;
பின்வரும் லூப் அனைத்து இலக்கங்களையும் செயலாக்குகிறது மற்றும் அவற்றை தொடர்புடைய எழுத்துக்கு மாற்றுகிறது. எனவே, 10ஐ விட அதிகமாக இருக்கும் அடிப்படைகளுக்கு, நிரல் 10 முதல் 15 வரையிலான இலக்கங்களுக்கு “a” முதல் “f” வரையிலான எழுத்துக்களைப் பயன்படுத்துகிறது.
}போது ( ஒன்றில் != 0 ) {
முழு எண்ணாக rem = ஒன்றில் % அடித்தளம் ;
str [ நான் ++ ] = ( rem > 9 ) ? ( rem - 10 ) + 'a' : rem + '0' ;
ஒன்றில் = ஒன்றில் / அடித்தளம் ;
}
எண் முதலில் எதிர்மறையாகவும், அடிப்படை 10 ஆகவும் இருக்கும்போது, நிரல் எதிர்மறை அடையாளத்தை முடிவு சரத்தில் சேர்க்கும்.
என்றால் ( எதிர்மறையானது && அடித்தளம் == 10 )str [ நான் ++ ] = '-' ;
பின்வரும் வரிகள் முடிவு சரத்தை முடித்து, மாற்றும் செயல்பாட்டின் போது இலக்கங்கள் தலைகீழ் வரிசையில் பெறப்படுவதால் அதைத் தலைகீழாக மாற்றும்:
str [ நான் ] = ' \0 ' ;// சரத்தை தலைகீழாக மாற்றவும்
முழு எண்ணாக தொடங்கு = 0 ;
முழு எண்ணாக முடிவு = நான் - 1 ;
போது ( தொடங்கு < முடிவு ) {
கரி வெப்பநிலை = str [ தொடங்கு ] ;
str [ தொடங்கு ] = str [ முடிவு ] ;
str [ முடிவு ] = வெப்பநிலை ;
தொடங்கு ++;
முடிவு --;
}
எனவே, நிரல் முழு எண்ணை உள்ளீடாக எடுத்து, சரம் பிரதிநிதித்துவத்திற்கு நினைவகத்தை ஒதுக்குகிறது. அதன் பிறகு, இது முழு எண்ணை சரமாக மாற்ற itoa ஐ அழைக்கிறது மற்றும் அசல் முழு எண்ணை அச்சிடுகிறது. இறுதியாக, அது ஒதுக்கப்பட்ட நினைவகத்தை விடுவிக்கிறது. எடுத்துக்காட்டாக, நிரலுக்கு ஒரு எண்ணைக் கொடுப்போம்:
இருப்பினும், நீங்கள் முழு எண் அல்லாத எண்ணை உள்ளிட்டால், நிரல் பின்வரும் முடிவைக் காண்பிக்கும்:
முடிவுரை
இப்படித்தான் நீங்கள் C இல் itoa செயல்பாட்டை எளிதாகச் செயல்படுத்தலாம் மற்றும் பயன்படுத்தலாம். முழு எண்ணை சரமாக மாற்ற பல செயல்பாடுகளைக் கொண்ட ஒரு விரிவான உதாரணத்தைப் பயன்படுத்தினோம். நினைவில் கொள்ளுங்கள், இது ஒரு எடுத்துக்காட்டு மட்டுமே, ஆனால் நீங்கள் அற்புதமான நிரல்களை எழுத பல்வேறு செயல்பாடுகளுடன் itoa செயல்பாட்டை இணைக்கலாம்.