இந்தக் கட்டுரை C++ இல் உள்ள சுட்டி எண்கணிதத்தைப் பற்றியது. சுட்டிகள் என்பது தரவுகளின் நினைவக முகவரியைச் சேமிக்கும் மாறிகள். சுட்டி எண்கணிதம் என்பது C++ நிரலாக்க மொழி உலகில் ஒரு சக்திவாய்ந்த அடையாளமாகும், இது வெவ்வேறு எண்கணித செயல்பாடுகளைச் சமாளிக்க அனுமதிக்கிறது, இதில் கூட்டல், பெருக்கல், வகுத்தல், அதிகரிப்பு, குறைப்பு மற்றும் கழித்தல் ஆகியவை நமது நினைவக இடையகங்களில் புதிய நினைவக முகவரியை உருவாக்க ஒரு சுட்டிக்காட்டியை உள்ளடக்கியது. . ஒரு சுட்டி எண்கணிதம் டைனமிக் நினைவக ஒதுக்கீட்டை எளிதாக உருவாக்குகிறது. இந்த C++ கட்டுரையில், சுட்டிகளின் உதவியுடன் வெவ்வேறு வழிகளில் நினைவக முகவரியை எவ்வாறு கையாள்வது மற்றும் சரியான வழிகாட்டுதல்கள் மற்றும் எடுத்துக்காட்டுகளை வழங்குவது எப்படி என்பதைக் கற்றுக்கொள்வோம்.
காட்சி 1: சுட்டி அதிகரிப்பு மற்றும் குறைப்பு செயல்பாடுகளை செய்கிறது
இங்கே, வெவ்வேறு நோக்கங்களைக் கொண்ட வெவ்வேறு நினைவக முகவரிகளை உருவாக்க சுட்டிக்காட்டி கையாளுதல் பற்றி அறிந்துகொள்வோம். அதிகரிக்கும் மற்றும் குறைக்கும் சுட்டிகள், அவை சுட்டிக்காட்டும் தரவு வகையின் அளவைக் கொண்டு பெருக்கப்படும் ஒரு காரணி மூலம் முகவரியை அதிகரிக்க அல்லது குறைக்கும் அந்நிய சுட்டிகள் எண்கணிதமாகும். இந்த சூழ்நிலையுடன் தொடர்புடைய குறியீடு துணுக்கு பின்வருவனவற்றில் இணைக்கப்பட்டுள்ளது:
# அடங்கும்
பெயர்வெளி std ஐப் பயன்படுத்துதல்;
const int Arr_Max = 5 ;
முழு எண்ணாக ( ) {
int எங்கே [ Arr_Max ] = { இருபது , 150 , 270 } ;
முழு எண்ணாக * ptr; // அறிவிக்கின்றன சுட்டி
ptr = var;
க்கான ( int i = 0 ; நான் < Arr_Max; நான்++ ) {
std::cout << 'உறுப்பின் நினைவக முகவரி : [' << நான் << '] = ' ;
std::cout << ptr << endl;
கூட் << 'முகவரிக்கு எதிரான மதிப்பு [' << நான் << '] = ' ;
கூட் << * ptr << endl;
std::cout << 'சுட்டி வெற்றிகரமாக அதிகரிக்கப்பட்டது' << endl;
ptr++;
}
std::cout << 'குறைவதற்கு முன் சுட்டி முகவரி' << ptr << endl;
ptr--;
std::cout << 'குறைவுக்குப் பிறகு சுட்டி முகவரி' << ptr << endl;
திரும்ப 0 ;
}
இங்கே, தொடக்கத்திலேயே குறியீட்டில் தேவையான நூலகத்தை வரையறுக்கிறோம்: “
முகவரியை அணுக வரிசையை சுட்டிக்காட்டிக்கு அனுப்புகிறோம். நாம் அனைவரும் அறிந்தபடி, வரிசைகள் எப்போதும் வெவ்வேறு இடங்களில் பல பொருட்களைக் கொண்டிருக்கும். எனவே, ஒரு வரிசையின் ஒவ்வொரு உறுப்பையும் அணுக, “உதவி” சுட்டியுடன் கூடிய லூப் தேவை. ஒவ்வொரு முறையும் லூப் இயங்கும் போது, இந்த முகவரிக்கு எதிரான நினைவக முகவரி மற்றும் மதிப்புகளை சுட்டிக்காட்டி எண்கணித “ptr++” இன்கிரிமென்ட் ஆபரேட்டரின் உதவியுடன் பெறுவோம், இது நினைவக முகவரியை அடுத்த நினைவக முகவரிக்கு மாற்றுகிறது. லூப் எக்ஸிகியூஷன் சுழற்சி ஒரு வரிசையின் அளவைப் பொறுத்தது. லூப்பிற்கு வெளியே, 'ptr- -' குறைப்பு சுட்டியைப் பயன்படுத்தி சுட்டியை முந்தைய நினைவக முகவரிக்கு திரும்பப் பெற விரும்புகிறோம்.
Execute>Compile & Run விருப்பத்தை கிளிக் செய்வதன் மூலம் இந்த குறியீட்டை இயக்கவும், பின்வரும் வெளியீட்டைப் பெறுவீர்கள்:
இந்த வெளியீடு புரிந்து கொள்ள எளிதானது என்று நம்புகிறோம். நினைவக முகவரி மற்றும் மதிப்பு மாற்றப்பட்டது. ஒரு இடத்திலிருந்து சுட்டியை மாற்றுவது C++ இல் உள்ள அதிகரிப்பு சுட்டிக்காட்டி எண்கணிதத்திலிருந்து மட்டுமே சாத்தியமாகும்.
காட்சி 2: C++ இல் இரண்டு சுட்டிகளைக் கழித்தல்
இந்தச் சூழ்நிலையில், C++ இல் இரண்டு அல்லது அதற்கு மேற்பட்ட சுட்டிகளைக் கழிப்பது எப்படி என்பதைக் கற்றுக்கொள்வோம். கழித்தல் வரும் அனைத்து எண்கணித செயல்பாடுகளும் முக்கியமான செயல்முறைகளாகும், ஏனெனில் ஒரே தரவு வகை இருந்தால் மட்டுமே இரண்டு சுட்டிகளை ஒரே நேரத்தில் கழிக்க முடியும்.
கூட்டல், பெருக்கல் மற்றும் வகுத்தல் போன்ற பிற செயல்பாடுகள் சுட்டியில் சாத்தியமில்லை, ஏனெனில் அவை நினைவக முகவரியில் எந்த அர்த்தமும் இல்லை. குறியீடு துணுக்கு பின்வருவனவற்றில் இணைக்கப்பட்டுள்ளது:
#முழு எண்ணாக ( ) {
அவர் அழைக்கிறார் [ ] = { 23 , 36 , 42 , 51 , 62 , 77 , 89 , 96 , 100 } ;
முழு எண்ணாக * ptrr1 = & அதற்கு [ 3 ] ; // மூன்றாவது உறுப்புக்கான சுட்டி ( 42 )
முழு எண்ணாக * ptrr2 = & அதற்கு [ 6 ] ; // ஆறாவது உறுப்புக்கு சுட்டி ( 89 )
ptrdiff_t ptrs கழித்தல் = ptrr2 - ptrr1;
std::cout << 'இந்த முகவரிகளுக்கு இடையே உள்ள வேறுபாடு:' << ptrs கழித்தல் << 'உறுப்புகள்' << std::endl;
திரும்ப 0 ;
}
கழித்தல் செயல்பாடு C++ இல் உள்ள நினைவக முகவரிக்கு இடையே உள்ள வேறுபாட்டைக் கண்டறிகிறது. முக்கிய செயல்பாட்டில், வெவ்வேறு குறியீடுகளில் வெவ்வேறு மதிப்புகளைக் கொண்ட ஒரு வரிசையை எடுத்துக்கொள்கிறோம். ஒரு வரிசையில், ஒவ்வொரு அட்டவணைக்கும் வெவ்வேறு நினைவக இருப்பிடம் உள்ளது. ஒரு சுட்டி எண்கணிதத்தின் உதவியுடன் இரண்டு சுட்டிகளுக்கு இடையிலான வித்தியாசத்தை மட்டுமே நாம் கண்டுபிடிக்க முடியும். இங்கே, C++ இல் இரண்டு அல்லது அதற்கு மேற்பட்ட சுட்டிகளுக்கு இடையே உள்ள வேறுபாடுகளைக் கண்டறிய 'ptrdiff_t' என்ற சிறப்பு சுட்டி வகையைப் பயன்படுத்துகிறோம்.
இந்த குறியீட்டின் வெளியீடு பின்வருவனவற்றில் இணைக்கப்பட்டுள்ளது:
இந்த முகவரிகளுக்கு இடையே உள்ள வேறுபாடு உறுப்பு வைஸ் 3 ஆகும்.
காட்சி 3: C++ இல் இரண்டு அல்லது அதற்கு மேற்பட்ட சுட்டிகளை ஒப்பிடுக
இந்தச் சூழ்நிலையில், “==”, “<=”, “>=”, “<”, ”>” போன்ற பல்வேறு தொடர்புடைய ஆபரேட்டர்களைப் பயன்படுத்தி C++ இல் உள்ள வெவ்வேறு சுட்டிகளை எவ்வாறு ஒப்பிடுவது என்பதைக் கற்றுக்கொள்வோம். ஒரே அணிவரிசையின் உறுப்புகளின் முகவரியை சுட்டிக்காட்டினால் மட்டுமே நாம் சுட்டிகளை ஒப்பிட முடியும். இரண்டு சுட்டிகளை வெவ்வேறு வகைகளுடன் ஒப்பிடுவது வரையறுக்கப்படாத நடத்தையை ஏற்படுத்தும் என்பதை நினைவில் கொள்ளுங்கள். சுட்டிக்காட்டி ஒப்பிடுதலுடன் தொடர்புடைய குறியீடு துணுக்கு பின்வருவனவற்றில் குறிப்பிடப்பட்டுள்ளது:
#பெயர்வெளி std ஐப் பயன்படுத்துதல்;
முழு எண்ணாக ( )
{
int arr1 [ 10 ] = { 4 , 7 , 9 , பதினொரு , 14 , 16 , 18 , இருபது , 22 , 25 } ;
முழு எண்ணாக * ptr1 = & arr1 [ 3 ] ;
முழு எண்ணாக * ptr2 = & arr1 [ 6 ] ;
முழு எண்ணாக * ptr3 = & arr1 [ 8 ] ;
முழு எண்ணாக * ptr4 = & arr1 [ 9 ] ;
என்றால் ( ptr1 ==ptr2 )
{
std::cout << 'சுட்டிகள் சமம்' << endl;
}
வேறு என்றால் ( ptr3 < =ptr4 )
{
std::cout << 'ptr3 என்பது ptr4 ஐ விட குறைவாகவோ அல்லது சமமாகவோ உள்ளது' << endl ;;
}
வேறு
{
std::cout << 'சுட்டிகள் எந்த நிலையிலும் ஒப்பிடப்படவில்லை' << endl;
}
திரும்ப 0 ;
}
இங்கே, நாம் 10 உறுப்புகள் கொண்ட ஒரு வரிசையை எடுத்துக்கொள்கிறோம். வரிசையின் வெவ்வேறு குறியீட்டை சுட்டிக்காட்டும் நான்கு சுட்டிகளை நாங்கள் அறிவிக்கிறோம். அதன் பிறகு, கொடுக்கப்பட்ட குறியீட்டில் காணப்படுவது போல் இந்த நான்கு சுட்டிகளையும் வெவ்வேறு நிலைகளில் ஒப்பிடுகிறோம். 'if' நிலையில், 'ptr1' சுட்டிக்காட்டி 'ptr2' சுட்டிக்காட்டிக்கு சமமாக உள்ளதா எனச் சரிபார்த்து, பின்னர் 'சுட்டிகள் சமம்' என்பதை அச்சிடவும். 'ptr3' சுட்டியானது 'ptr4' சுட்டிக்காட்டிக்கு சமமாக உள்ளதா என்பதைச் சரிபார்க்க, 'else if' நிபந்தனையைப் பயன்படுத்தும் பல நிபந்தனைகள் எங்களிடம் இருக்கும்போது. அனைத்து பிறகு, கிளிக் செய்யவும் இயக்கவும் > தொகுத்து இயக்கவும் விருப்பம்.
இந்த குறியீட்டின் வெளியீடு பின்வருவனவற்றில் இணைக்கப்பட்டுள்ளது:
இது கன்சோல் திரையில் சரியான நிலையைக் காட்டுகிறது மற்றும் தொகுப்பிலிருந்து வெளியேறுகிறது. 'ptr3' சுட்டியானது 'ptr4' சுட்டிக்காட்டி மதிப்பை விட குறைவான அல்லது சமமான மதிப்பைக் கொண்டுள்ளது.
காட்சி 4: பாயிண்டர் எண்கணிதத்துடன் ஒற்றைப்படை எண்ணைக் காட்டவும்
ஒரு முழு எண்ணின் வரிசைக்கு நினைவகத்தை எவ்வாறு மாறும் வகையில் ஒதுக்குவது என்பதை இங்கே பார்ப்போம். இந்த வழக்கு தொடர்பான குறியீடு துணுக்கு பின்வருவனவற்றில் கொடுக்கப்பட்டுள்ளது:
#முழு எண்ணாக ( ) {
முழு எண்ணாக எண்கள் [ ] = { 1 , 12 , 33 , 24 , பதினைந்து , 776 , 71 , 18 , 29 , ஐம்பது } ;
முழு எண்ணாக * ptrr = எண்கள்;
std::cout << 'வரிசைகளில் ஒற்றைப்படை எண்கள்:' ;
க்கான ( int i = 0 ; நான் < 10 ; ++i ) {
என்றால் ( * ptrr % 2 ! = 0 ) {
std::cout << * ptrr << '' ;
}
ptrr++;
}
std::cout << std::endl;
திரும்ப 0 ;
}
முக்கிய செயல்பாட்டில், 10 கூறுகளைக் கொண்ட ஒரு வரிசையை எடுத்துக்கொள்கிறோம். வரிசையில் உள்ள ஒற்றைப்படை எண்ணைச் சரிபார்க்க, வரிசையில் உள்ள அனைத்து உறுப்புகளையும் சுட்டிக்காட்டும் ஒரு சுட்டிக்காட்டி நமக்குத் தேவை. 'for' லூப்பில், வரிசையின் தற்போதைய உறுப்பைப் பிரிப்பதன் மூலம் ஒற்றைப்படை எண்ணைச் சரிபார்க்கவும். வரிசையின் ஒரு உறுப்பைச் சரிபார்த்த பிறகு சுட்டிக்காட்டி கவுண்டர் அதிகரிக்கப்படுகிறது.
குறியீட்டை இயக்கிய பின், பின்வருவனவற்றில் கொடுக்கப்பட்டுள்ள கன்சோல் திரையில் வெளியீடு காட்டப்படும்:
இந்த வழியில், கன்சோல் திரையில் சுட்டிக்காட்டி எண்கணிதத்தைப் பயன்படுத்தி ஒற்றைப்படை எண்களைக் காட்டலாம்.
முடிவுரை
C++ இல் வெவ்வேறு செயல்பாடுகளைச் செய்யும் சுட்டி எண்கணிதம் மிகவும் பயனுள்ள கருவி என்று நாங்கள் இங்கே முடிவு செய்கிறோம். ஒரே தரவு வகையைக் கொண்ட அணிவரிசையின் மதிப்பை சுட்டிக்காட்டி அதிகரிக்கிறதா அல்லது குறைக்கிறதா என்பதை உறுதிசெய்யவும். C++ நிரலாக்க மொழியில் சுட்டிக்காட்டி எண்கணிதத்தின் உதவியுடன் ஒரு அணிவரிசையின் மதிப்புகளை அவற்றின் நினைவக முகவரிகள் மூலம் ஒப்பிடலாம். சுட்டிக்காட்டி எண்கணிதத்தின் உதவியுடன் நாம் வரிசையைக் கடந்து நினைவகத்தை எளிதாக நிர்வகிக்கலாம்.