என்பதை இந்த கட்டுரையில் பார்ப்போம் calloc() செயல்பாடு மற்றும் அதை C++ இல் எவ்வாறு வெற்றிகரமாகப் பயன்படுத்தலாம்.
calloc() செயல்பாடு என்றால் என்ன?
தி calloc() செயல்பாடு C++ நிரலாக்கத்தில் நினைவக ஒதுக்கீடு செயல்பாடு ஆகும். இது ஒரு வரிசை அல்லது மாறிகளின் தொகுப்பிற்கு நினைவக தொகுதியை ஒதுக்க பயன்படுகிறது. தி calloc() செயல்பாடு போன்றது malloc() செயல்பாடு, ஒதுக்கப்பட்ட நினைவகத்தை ஆரம்பத்தில் பூஜ்ஜியமாக அமைக்கிறது. ஒதுக்கப்பட்ட நினைவகம் அறியப்பட்ட மதிப்பிற்கு துவக்கப்படுவதை இது உறுதி செய்கிறது, இது வரிசைகள் மற்றும் கட்டமைப்புகளுடன் பணிபுரியும் போது பயனுள்ளதாக இருக்கும்.
க்கான தொடரியல் calloc() செயல்பாடு பின்வருமாறு:
வெற்றிடமானது * calloc ( அளவு_டி nmemb , அளவு_டி அளவு )
செயல்பாடு இரண்டு வாதங்களை எடுக்கும்: nmemb மற்றும் அளவு . தி nmemb வாதம் ஒதுக்கப்படும் வரிசையில் உள்ள உறுப்புகளின் எண்ணிக்கையைக் குறிப்பிடுகிறது அளவு வாதம் ஒவ்வொரு தனிமத்தின் அளவையும் பைட்டுகளில் குறிப்பிடுகிறது.
மேலும், நினைவக ஒதுக்கீடு வெற்றி பெற்றால், தி calloc() செயல்பாடு ஒரு பூஜ்ய சுட்டியை வழங்குகிறது, இல்லையெனில் அது புதிதாக உருவாக்கப்பட்ட நினைவக தொகுதியின் தொடக்கத்திற்கு ஒரு சுட்டியை வழங்குகிறது. நினைவக கசிவைத் தவிர்க்க, நினைவகம் ஒதுக்கப்பட்டது calloc() பயன்படுத்தி அகற்றப்பட வேண்டும் இலவச() முறை இனி தேவையில்லை.
C++ இல் calloc() செயல்பாட்டை எவ்வாறு பயன்படுத்துவது?
உபயோகிக்க calloc() C++ இல் செயல்பட, கீழே கொடுக்கப்பட்டுள்ள படிகளைப் பின்பற்றவும்:
படி 1: தேவையான தலைப்புக் கோப்பைச் சேர்க்கவும் calloc() செயல்பாடு, இது
படி 2: பின்னர் விரும்பிய தரவு வகையின் சுட்டி மாறியை அறிவிக்கவும்.
படி 3: அதன் பிறகு பயன்படுத்தவும் calloc() நினைவகத்தை ஒதுக்கி அதை 0 க்கு துவக்கும் செயல்பாடு.
படி 4: ஒதுக்கப்பட்ட நினைவகத்தை தேவைக்கேற்ப பயன்படுத்தவும்.
படி 5: ஒதுக்கப்பட்ட நினைவகத்தைப் பயன்படுத்தி முடித்தவுடன், அதைப் பயன்படுத்தி அதை விடுவிக்கவும் இலவச() செயல்பாடு.
பின்வரும் உதாரணம் காட்டுகிறது calloc() C++ இல் செயல்பாடு செயல்படுத்தல்.
##
பெயர்வெளி std ஐப் பயன்படுத்துகிறது ;
முழு எண்ணாக முக்கிய ( ) {
முழு எண்ணாக * ptr ;
ptr = ( முழு எண்ணாக * ) calloc ( 6 , அளவு ( முழு எண்ணாக ) ) ;
என்றால் ( ! ptr ) {
கூட் << 'நினைவக ஒதுக்கீடு தோல்வியடைந்தது' ;
வெளியேறு ( 1 ) ;
}
கூட் << 'மதிப்புகளைத் தொடங்குதல்...' << endl
<< endl ;
க்கான ( முழு எண்ணாக நான் = 0 ; நான் < 6 ; நான் ++ ) {
ptr [ நான் ] = நான் * 3 ;
}
கூட் << 'தொடக்க மதிப்புகள்.' << endl ;
க்கான ( முழு எண்ணாக நான் = 0 ; நான் < 6 ; நான் ++ ) {
கூட் << * ( ptr + நான் ) << endl ;
}
இலவசம் ( ptr ) ;
திரும்ப 0 ;
}
மேலே உள்ள குறியீட்டில், ஒரு முழு எண் சுட்டிக்காட்டி ptr முதலில் அறிவிக்கப்படுகிறது. நினைவகம் பின்னர் 6 முழு எண்களுக்கு ஒதுக்கப்படுகிறது calloc(), நினைவகம் 0 உடன் துவக்கப்படுகிறது அளவு முழு எண்களை சேமிக்க எவ்வளவு நினைவகம் தேவை என்பதைக் கணக்கிட செயல்பாடு பயன்படுத்தப்படுகிறது. வெற்றியை உறுதி செய்வதற்காக நினைவக ஒதுக்கீடு பிழைகள் உள்ளதா எனச் சரிபார்க்கப்படுகிறது. இல்லையெனில், நிரல் நிறுத்தப்படும் மற்றும் ஒரு பிழை செய்தி காட்டப்படும்.
ஒதுக்கப்பட்ட நினைவகம் பின்னர் பெருக்குவதன் மூலம் பெறப்பட்ட எண்களைப் பயன்படுத்தி துவக்கப்படுகிறது 'i*3' ஒரு பயன்படுத்தி க்கான வளைய. ஒதுக்கப்பட்ட நினைவகத்தில் வைக்கப்பட்டுள்ள மதிப்புகள் லூப் மற்றும் பாயிண்டர் எண்கணிதத்திற்கான வினாடியைப் பயன்படுத்தி அச்சிடப்படுகின்றன. *(ptr + i) . இறுதியில், மாறும் வகையில் ஒதுக்கப்பட்ட நினைவகம் ஐ அழைப்பதன் மூலம் வெளியிடப்படுகிறது இலவச() செயல்பாடு, நினைவக கசிவை நிறுத்துகிறது. நிரல் வெற்றிகரமாக இயங்கியதற்கான அடையாளமாக, அது 0 ஐ வழங்குகிறது.
வெளியீடு
முடிவுரை
C++ இல், தி calloc() நினைவகத்தை மாறும் வகையில் ஒதுக்குவதற்கு செயல்பாடு பயனுள்ளதாக இருக்கும். இது நினைவகத்தை ஒதுக்குவது மட்டுமல்லாமல், அதை பூஜ்ஜியமாக்குகிறது, இது வரிசைகள் மற்றும் கட்டமைப்புகளுடன் பணிபுரியும் போது பயனுள்ளதாக இருக்கும். எப்படிப் பயன்படுத்துவது என்பதைப் புரிந்துகொள்வது calloc() நினைவக கசிவைத் தவிர்ப்பதற்கும் நிரல் செயல்படுத்தல் வெற்றியை உறுதி செய்வதற்கும் திறம்பட முக்கியமானது. டெவலப்பர்கள் பாதுகாப்பாகப் பயன்படுத்தலாம் calloc() இந்த கட்டுரையில் கொடுக்கப்பட்டுள்ள வழிமுறைகளைப் பின்பற்றுவதன் மூலம் அவர்களின் C++ நிரல்களில் முறை.