C++ இல் Size_t

C Il Size T



C++ என்பது மிகவும் பிரபலமான மற்றும் பரந்த மொழியாகும், இது எங்கள் வேலையை மிகவும் வசதியாக்கும் செயல்பாடுகள் நிறைந்தது. எந்தவொரு தரவு வகையின் அதிகபட்ச அளவையும் சேமிக்க உதவும் “size_t” வகையுடன் இது நமக்கு உதவுகிறது. 'size_t' எனப்படும் தனித்துவமான கையொப்பமிடப்படாத முழு எண் வகை C++ நிலையான நூலகங்களில் வரையறுக்கப்பட்டுள்ளது. SIZE_MAX மாறிலி என்பது 'size_t' வகைக்கு ஒதுக்கப்படும் மிகப்பெரிய மதிப்பாகும். கோட்பாட்டளவில் கற்பனை செய்யக்கூடிய வரிசை அல்லது பொருள்களின் மிகப்பெரிய அளவு 'size_t' இல் சேமிக்கப்படும். பெரிய மெட்ரிக்குகள், அணிவரிசைகள் போன்றவை தேவைப்படும்போது மட்டுமே அதைப் பயன்படுத்தவும். C++ நிரலாக்கத்தில் “size_t” எதிர்மறையாக இருக்க முடியாது.

எடுத்துக்காட்டு 1:

'stddef.h', 'limits' மற்றும் 'iostream' ஆகிய வெவ்வேறு தலைப்புக் கோப்புகள் இங்கு இறக்குமதி செய்யப்படுகின்றன. அடிக்கடி பயன்படுத்தப்படும் மாறிகள், வகைகள் மற்றும் சுட்டிகளின் வரையறைகளை “stddef.h” இல் காணலாம் மற்றும் “வரம்புகள்” தலைப்புக் கோப்பு பல்வேறு தரவு வகைகளுக்கான நிமிடம் மற்றும் அதிகபட்ச மதிப்புகள் போன்ற ஒருங்கிணைந்த வகைகளின் எல்லைகளைக் குறிக்கும் மாறிலிகளாகப் பயன்படுத்தப்படுகிறது. , இந்த தலைப்பு கோப்பு மூலம் அணுகலாம். பின்னர், 'iostream' சேர்க்கப்பட்டது, ஏனெனில் தரவை உள்ளீடு/வெளியீடு செய்யப் பயன்படுத்தப்படும் செயல்பாடுகள் அதில் வரையறுக்கப்பட்டுள்ளன.

இதற்குப் பிறகு, 'std' பெயர்வெளி இங்கே சேர்க்கப்படும். இதன் கீழ், 'முக்கிய()' முறை செயல்படுத்தப்படுகிறது. இதன் உள்ளே, நாங்கள் இங்கே வைக்கும் தரவை வழங்குவதற்கு உதவும் 'கவுட்' ஐ வைக்கிறோம். 'numeric_limits::max()' என தட்டச்சு செய்யப்பட்டுள்ளது, ஏனெனில் இது 'T' என்ற எண் வகையை பிரதிநிதித்துவப்படுத்தக்கூடிய மிக உயர்ந்த வரையறுக்கப்பட்ட மதிப்பை வழங்குகிறது. ஒவ்வொரு வரம்புக்குட்பட்ட வகைக்கும் இது குறிப்பிடத்தக்கது ஆனால் அது எதிர்மறையாக இருக்க முடியாது.







குறியீடு 1:



# அடங்கும்
#அடங்கும் <வரம்புகள்>
# அடங்கும்
பயன்படுத்தி பெயர்வெளி வகுப்பு ;
முழு எண்ணாக முக்கிய ( ) {
கூட் << 'அளவு_t இன் அதிகபட்ச அளவு' << எண்_வரம்புகள் :: அதிகபட்சம் ( ) << endl ;
}

வெளியீடு:
'டி' வகையின் அதிகபட்ச அளவு இப்போது வழங்கப்படுவதை நாம் கவனிக்கலாம், இது பின்வருவனவற்றில் காட்டப்பட்டுள்ளபடி மிகப் பெரிய மதிப்பாகும்:







எடுத்துக்காட்டு 2:

'வரம்புகள்' மற்றும் 'iostream உட்பட இரண்டு தலைப்பு கோப்புகள் இங்கு இறக்குமதி செய்யப்படுகின்றன. தரவு உள்ளீடு மற்றும் வெளியீட்டிற்கு தேவையான செயல்பாடுகள் அதில் வரையறுக்கப்பட்டுள்ளதால், 'iostream' இங்கே சேர்க்கப்பட்டுள்ளது. பின்னர், வெவ்வேறு தரவு வகைகளுக்கான நிமிடம் மற்றும் அதிகபட்ச மதிப்புகள் போன்ற ஒருங்கிணைந்த வகைகளின் எல்லைகளை விவரிக்கும் மாறிலிகளை அணுக “வரம்புகள்” தலைப்பு கோப்பு பயன்படுத்தப்படுகிறது.

பின்னர், 'std' பெயர்வெளி இங்கு அறிமுகப்படுத்தப்பட்டு, 'main()' செயல்பாடு அழைக்கப்படுகிறது. இதன் அடியில், C++ நிரலாக்கத்தில் முழு எண் தரவு வகையின் மேல் வரம்பின் அதிகபட்ச மதிப்பை வழங்க, 'cout' இன் உள்ளே 'INT_MAX' ஐப் பயன்படுத்துகிறோம். பின்னர், பின்வரும் வரியில், அதிக மதிப்பைக் கொடுக்கும் “size_t” ஐப் பயன்படுத்துகிறோம்.



குறியீடு 2:

# அடங்கும்
# அடங்கும்
பயன்படுத்தி பெயர்வெளி வகுப்பு ;
முழு எண்ணாக முக்கிய ( ) {
கூட் << 'அதிகபட்ச முழு எண் மதிப்பு:' << INT_MAX << endl ;

கூட் << 'size_t செயல்பாடு வைத்திருக்கும் அளவு:' << ( அளவு_டி ) 0 - 1 << endl ;
திரும்ப 0 ;
}

வெளியீடு :
முழு எண்ணின் அதிகபட்ச அளவு முதலில் ரெண்டர் செய்யப்படுகிறது, அதை நாம் 'INT_MAX' உதவியுடன் பெறுகிறோம். பின்னர், 'size_t' ஸ்டோர்களின் அதிகபட்ச அளவு, இந்த குறியீட்டில் உள்ள 'size_t' உதவியுடன் நாம் பெறும்.

எடுத்துக்காட்டு 3:

இங்கே, இரண்டு தலைப்பு கோப்புகள், 'climits' மற்றும் 'iostream', இறக்குமதி செய்யப்படுகின்றன. 'iostream' இங்கே சேர்க்கப்பட்டுள்ளது, ஏனெனில் தரவை உள்ளிடுவதற்கும் வெளியிடுவதற்கும் தேவையான செயல்பாடுகள் அதில் வரையறுக்கப்பட்டுள்ளன. அடுத்து, பல்வேறு தரவு வகைகளுக்கான குறைந்தபட்ச மற்றும் அதிகபட்ச மதிப்புகள் போன்ற ஒருங்கிணைந்த வகைகளின் எல்லைகளை விவரிக்கும் மாறிலிகள் 'climits' தலைப்பு கோப்பைப் பயன்படுத்தி அணுகப்படும்.

இங்கே, 'main()' செயல்பாடு இப்போது செயல்படுத்தப்படுகிறது மற்றும் 'std' பெயர்வெளி பின்னர் அறிமுகப்படுத்தப்பட்டது. இதற்குக் கீழே, C++ நிரலாக்கத்தில் முழு எண் தரவு வகையின் அதிகபட்ச மதிப்பின் மேல் எல்லையை வெளியிட, 'cout' இன் உள்ளே உள்ள 'INT_MAX' ஐப் பயன்படுத்துகிறோம். இதன் கீழ், 'int' தரவு வகையின் குறைந்த மதிப்பை வழங்கும் 'INT_MIN' ஐப் பயன்படுத்துகிறோம். பின்னர், 'size_t' ஐப் பயன்படுத்துகிறோம், இது பின்வரும் வரியில் சேமிக்கும் அதிகபட்ச மதிப்பை அளிக்கிறது:

குறியீடு 3:

# அடங்கும்
# அடங்கும்
பயன்படுத்தி பெயர்வெளி வகுப்பு ;
முழு எண்ணாக முக்கிய ( ) {
கூட் << 'மிகப்பெரிய முழு எண் மதிப்பு:' << INT_MAX << endl ;
கூட் << 'மிகச் சிறிய முழு எண்:' << INT_MIN << endl ;
கூட் << 'size_t செயல்பாடு வைத்திருக்கும் அளவு:' << ( அளவு_டி ) 0 - 1 << endl ;
திரும்ப 0 ;
}

வெளியீடு:
முதலில், 'INT_MAX' இன் உதவியுடன் நாம் பெறும் முழு எண்ணின் அதிகபட்ச அளவு காட்டப்படும். இரண்டாவதாக, 'INT_MIN' இன் உதவியுடன் நாம் பெறும் முழு எண்ணின் குறைந்தபட்ச அளவு காட்டப்படும். பின்னர், இந்தக் குறியீட்டில் உள்ள “size_t” இன் உதவியுடன், “size_t” ஸ்டோர்கள் ரெண்டர் செய்யப்படும் அதிகபட்ச அளவு.

எடுத்துக்காட்டு 4:

இந்த குறியீட்டில் உள்ள தலைப்பு கோப்புகள் “cstddef”, “iostream” மற்றும் “array” ஆகும். இந்த தலைப்பு கோப்புகள் சேர்க்கப்பட்டுள்ளன, இதன் மூலம் இந்த தலைப்பு கோப்புகளில் வரையறைகள் வரையறுக்கப்பட்டுள்ள செயல்பாடுகளை நாங்கள் பயன்படுத்தலாம். இந்த குறியீட்டில் உள்ள 'வரிசைகள்' மற்றும் செயல்பாடுகளுடன் நாம் வேலை செய்ய வேண்டியிருப்பதால், 'வரிசை' தலைப்பு கோப்பு இங்கே சேர்க்கப்பட்டுள்ளது. இங்கே “my_sVar” மாறியை “const size_t” உடன் அறிவித்து, அதன் அளவை வழங்க “1000” மதிப்புடன் துவக்குகிறோம்.

இதற்குப் பிறகு, “int” தரவு வகையின் “num[]” வரிசையை அறிவித்து அதன் அளவாக “my_sVar” ஐ அனுப்புவோம். பின்னர், “size_of()” செயல்பாட்டைப் பயன்படுத்துகிறோம், அதில் “num” மாறியை அளவுருவாக வைத்து, “size_t” வகையின் “my_size” மாறியில் சேமிக்கிறோம். பின்னர், 'cout' ஐப் பயன்படுத்தி, 'SIZE_MAX' என டைப் செய்கிறோம், எனவே அது 'my_sVar' மாறியின் அதிகபட்ச அளவை வழங்குகிறது.

அடுத்து, வரிசை வகை கூறுகளை சிறிய எண்களில் காட்டுகிறோம். 10 ஐ 1000 ஆகக் காட்ட மட்டுமே நாங்கள் அதைத் தேர்ந்தெடுக்கிறோம், இது வெளியீட்டில் பொருத்த முடியாத அளவுக்கு அதிகமாக உள்ளது. 'size_t' வகையைப் பயன்படுத்தி, அட்டவணைப்படுத்தல் மற்றும் எண்ணுதல் ஆகிய இரண்டிற்கும் 'size_t' எவ்வாறு பயன்படுத்தப்படலாம் என்பதைக் காட்ட, குறியீட்டு 0 இல் தொடங்குகிறோம். எண்கள் குறையும் என்பதால், குறியீட்டில் “–a” ஐ வைப்பதால், வரிசை இறங்கு வரிசையில் காட்டப்படும்.

குறியீடு 4:

# அடங்கும்
# அடங்கும்
# அடங்கும்
பயன்படுத்தி பெயர்வெளி வகுப்பு ;
முழு எண்ணாக முக்கிய ( ) {
நிலையான அளவு_டி my_sVar = 1000 ;
முழு எண்ணாக ஒன்றில் [ my_sVar ] ;
அளவு_டி என்_அளவு = அளவு ( ஒன்றில் ) ;
கூட் << 'my_sVar இன் அதிகபட்ச அளவு =' << SIZE_MAX << endl ;
கூட் << 'எண்களின் வரிசையுடன் பணிபுரியும் போது, ​​அளவு_t வகை பின்வருமாறு இருக்கும்.' ;
வரிசை < அளவு_டி , 10 > my_arr ;
க்கான ( அளவு_டி = 0 ; ! = my_arr. அளவு ( ) ; ++ )
my_arr [ ] = ;
க்கான ( அளவு_டி = my_arr. அளவு ( ) - 1 ; < my_arr. அளவு ( ) ; -- )
கூட் << my_arr [ ] << '' ;
திரும்ப 0 ;
}

வெளியீடு:
இது மாறியின் அதிகபட்ச அளவை முதலில் ரெண்டர் செய்து பின்னர் வரிசையை இறங்கு வரிசையில் வழங்குகிறது.

எடுத்துக்காட்டு 5:

இந்தக் குறியீட்டில் “cstddef”, “iostream” மற்றும் “array” தலைப்புக் கோப்புகள் உள்ளன. இந்த குறியீடு 'வரிசைகள்' மற்றும் செயல்பாடுகளுடன் வேலை செய்ய வேண்டும் என்பதால், 'வரிசை' தலைப்பு கோப்பு இங்கே வைக்கப்பட்டுள்ளது. “var” மாறியின் அளவை வழங்க, அதை “const size_t” மதிப்புடன் இங்கே அறிவித்து “1000” உடன் துவக்குவோம். 'கவுட்' செயல்பாட்டைப் பயன்படுத்தி, இந்தப் புலத்தில் 'SIZE_MAX' எனக் குறிப்பிட்டதால், 'var' மாறியின் அதிகபட்ச அளவு இங்கே வழங்கப்படுகிறது.

அடுத்து, வரிசை வகை உருப்படிகளை சிறிய அளவில் காட்ட முயற்சிக்கிறோம். இதுவரை, 1000 வெளியீட்டை நிரப்பும் என்பதால், 20ஐ மட்டுமே காட்டத் தேர்ந்தெடுத்துள்ளோம். 'size_t' என்பது 'size_t' வகையைப் பயன்படுத்தி, குறியீட்டு 0 இல் தொடங்கி, அட்டவணைப்படுத்தல் மற்றும் எண்ணுதல் ஆகிய இரண்டிற்கும் எவ்வாறு பயன்படுத்தப்படலாம் என்பதை நாங்கள் விளக்குகிறோம். வரிசையானது இறங்கு வரிசையில் காட்டப்படும், ஏனெனில் '-a' இன் இடத்தின் மூலம் எண்கள் குறையும். பின்வரும் குறியீடு:

குறியீடு 5:

# அடங்கும்
# அடங்கும்
# அடங்கும்
பயன்படுத்தி பெயர்வெளி வகுப்பு ;
முழு எண்ணாக முக்கிய ( ) {
நிலையான அளவு_டி இருந்தது = 1000 ;
கூட் << 'வரத்தின் அதிகபட்ச அளவு =' << SIZE_MAX << endl ;
கூட் << 'எண்களின் வரிசையுடன் பயன்படுத்தப்படும் size_t வகை இவ்வாறு கொடுக்கப்பட்டுள்ளது' ;

வரிசை < அளவு_டி , இருபது > வரிசை_எண் ;
க்கான ( அளவு_டி நான் = 0 ; நான் ! = வரிசை_எண். அளவு ( ) ; ++ நான் )
வரிசை_எண் [ நான் ] = நான் ;
க்கான ( அளவு_டி நான் = வரிசை_எண். அளவு ( ) - 1 ; நான் < வரிசை_எண். அளவு ( ) ; -- நான் )
கூட் << வரிசை_எண் [ நான் ] << '' ;
திரும்ப 0 ;
}

வெளியீடு :
மாறியை அதன் அதிகபட்ச அளவிற்கு வழங்கிய பிறகு இது வரிசையை குறையும் வரிசையில் வழங்குகிறது.

முடிவுரை

C++ நிரலாக்கத்தில் உள்ள “size_t” வகை இந்தக் கட்டுரையில் முழுமையாக ஆராயப்பட்டது. எங்கள் C++ குறியீடுகளில் “size_t” ஐப் பயன்படுத்துகிறோம் என வரையறுத்துள்ளோம். இது கையொப்பமிடப்படாத வகை என்றும் அது எதிர்மறையாக இருக்க முடியாது என்றும் விளக்கினோம். 'size_t' ஐப் பயன்படுத்திய C++ நிரலாக்கத்தின் குறியீடுகளை நாங்கள் நிரூபித்தோம், அதன் பின் அதன் விளைவுகளை இந்தக் கட்டுரையில் வழங்கினோம்.