C++ இல் Unary ஆபரேட்டர்

C++ பல unary ஆபரேட்டர்களை ஆதரிக்கிறது, ஒவ்வொன்றும் மாறிகளைக் கையாள்வதில் ஒரு தனித்துவமான நோக்கத்தை வழங்குகிறது. லூப்கள் மற்றும் பல்வேறு வழிமுறைகளில் பொதுவாகப் பயன்படுத்தப்படும் அதிகரிப்பு மற்றும் குறைப்பு ஆபரேட்டர்களுடன் ஆரம்பிக்கலாம்.

எடுத்துக்காட்டு 1: அதிகரிப்பு (++) மற்றும் குறைப்பு (-) ஆபரேட்டர்கள்

அதிகரிப்பு (++) மற்றும் குறைப்பு (–) unary ஆபரேட்டர்கள் என்பது C++ இல் உள்ள அடிப்படை கருவிகளாகும், அவை ஒரு மாறியின் மதிப்பை முறையே 1 ஆல் கூட்டி அல்லது குறைத்து மாற்றியமைக்கும். அதிகரிப்பு ஆபரேட்டர் (++) மாறியின் மதிப்பில் 1 ஐ சேர்க்கிறது, அதே சமயம் குறைப்பு ஆபரேட்டர் (-) 1 ஐக் கழிக்கிறது. இந்த ஆபரேட்டர்கள் முழு எண், மிதக்கும் புள்ளி மற்றும் சுட்டிக்காட்டி மாறிகளுக்குப் பயன்படுத்தப்படலாம், அவற்றின் பயன்பாட்டில் நெகிழ்வுத்தன்மையை வழங்குகிறது.

ஒரு நடைமுறை உதாரணம் மூலம் இந்த ஆபரேட்டர்களை ஆராய்வோம்:

இந்த எளிய C++ நிரல் '#include ' உடன் தேவையான உள்ளீடு/வெளியீட்டு ஸ்ட்ரீம் நூலகத்தை உள்ளடக்கியது. “main()” செயல்பாட்டிற்குள், “counter” எனப்படும் ஒரு முழு எண் மாறியை உடனடியாக உருவாக்கி, அதை 0 இன் ஆரம்ப மதிப்புடன் ஒதுக்குவோம். “cout” அறிக்கையைப் பயன்படுத்தி, “counter” இன் ஆரம்ப மதிப்பை கன்சோலில் அச்சிடுகிறோம். எங்கள் ஆர்ப்பாட்டத்திற்கான அடிப்படை. முன்னோக்கி நகரும் போது, ​​'கவுண்டர்' மாறி மதிப்பை 1 ஆல் உயர்த்த, அதிகரிப்பு ஆபரேட்டர் (கவுண்டர்++) பயன்படுத்தப்படுகிறது.

இந்த செயல்பாட்டிற்குப் பிறகு, 'எதிர்' இன் புதுப்பிக்கப்பட்ட மதிப்பு மற்றொரு 'கவுட்' அறிக்கையைப் பயன்படுத்தி காட்டப்படும். பின்னர், 'கவுண்டரின்' மதிப்பை 1 ஆல் குறைக்க, decrement operator (counter-) ஐப் பயன்படுத்துகிறோம். அதன் விளைவு கன்சோலில் காட்டப்படும். இறுதியில், நிரல் 'திரும்ப 0;' உடன் முடிவடைகிறது; வெற்றிகரமாக செயல்படுத்தப்பட்டதைக் குறிக்கும் அறிக்கை.

வெளியீட்டுப் படம் ஆரம்ப மதிப்பு, அதிகரிப்புக்குப் பின் மதிப்பு மற்றும் குறைக்கப்பட்ட மதிப்பைக் காட்டுகிறது.

எடுத்துக்காட்டு 2: நேர்மறை (+) மற்றும் எதிர்மறை (-) ஆபரேட்டர்கள்

நேர்மறை யூனரி ஆபரேட்டர் அரிதாகவே பயன்படுத்தப்படுகிறது, எதிர்மறை ஆபரேட்டர் ஒரு மாறியின் அடையாளத்தை மாற்றுவதற்கான அடிப்படையாகும்.

'நேர்மறை மதிப்பு' மற்றும் 'எதிர்மறை மதிப்பு' ஆகிய இரண்டு முழு எண் மாறிகளை இந்த எடுத்துக்காட்டு குறியீட்டிற்கு துவக்குகிறோம். 'நேர்மறை மதிப்பு' என்பது 10 இன் மதிப்புடன் ஒதுக்கப்படுகிறது. பின்னர், 'எதிர்மறை மதிப்பை' அறிவித்து, 'பாசிட்டிவ் வேல்யூ' என்ற மறுப்புடன் யூனரி மைனஸ் ஆபரேட்டரைப் பயன்படுத்தி ஒதுக்குவோம். இந்த ஆபரேட்டர் அசல் மதிப்பின் அடையாளத்தை திறம்பட மாற்றுகிறது. கன்சோலில் நேர்மறை மற்றும் எதிர்மறை வெளியீடு இரண்டையும் காட்ட 'cout' அறிக்கையைப் பயன்படுத்துகிறோம். இறுதியாக, நிரல் 0 ஐ வழங்குகிறது, இது முக்கிய செயல்பாடு வெற்றிகரமாக முடிவடைந்ததைக் குறிக்கிறது.

செயல்படுத்தப்படும் போது, ​​​​இந்த நிரல் நேர்மறை மற்றும் எதிர்மறை மதிப்புகளை வெளியிடுகிறது.

எடுத்துக்காட்டு 3: லாஜிக்கல் அல்ல (!) ஆபரேட்டர்

C++ இல் உள்ள unary operator, “!” ஆல் குறிக்கப்படுகிறது. குறியீடு, தருக்க NOT ஆபரேட்டர் என அறியப்படுகிறது. கொடுக்கப்பட்ட வெளிப்பாட்டின் உண்மை மதிப்பைத் தலைகீழாக மாற்றும் வகையில் இது வடிவமைக்கப்பட்டுள்ளது. இது பொதுவாக ஒரு தர்க்க வெளிப்பாடு அல்லது நிபந்தனையாக இருக்கும் ஒற்றை இயக்கத்தில் செயல்படுகிறது. தர்க்கரீதியான NOT செயல்பாடு, செயல்பாடானது 'தவறானதாக' இருக்கும் போது 'உண்மையான' விளைவை அளிக்கிறது மற்றும் செயல்பாடானது 'உண்மையாக' இருக்கும்போது 'தவறான' விளைவை அளிக்கிறது.

தருக்க NOT ஆபரேட்டரின் பயன்பாட்டை நிரூபிக்கும் எளிய எடுத்துக்காட்டு இங்கே:

இந்த எடுத்துக்காட்டில், இரண்டு பூலியன் மாறிகள், 'isTrue' மற்றும் 'isFalse' என்று அறிவிக்கிறோம். ஒவ்வொரு மாறிக்கும் தருக்க NOT ஆபரேட்டரைப் பயன்படுத்துகிறோம், முடிவுகளை முறையே 'resultNotTrue' மற்றும் 'resultNotFalse' இல் சேமிக்கிறோம். நிரல் பின்னர் அசல் மதிப்புகள் மற்றும் இரண்டு மாறிகளுக்கும் தருக்க NOT செயல்பாட்டின் முடிவுகளை அச்சிடுகிறது.

இந்த நிரலை இயக்கும் போது, ​​லாஜிக்கல் NOT ஆபரேட்டர் 'isTrue' (ஆரம்பத்தில் உண்மையாக அமைக்கப்பட்டது) இன் உண்மை மதிப்பை மாற்றியமைப்பதை நாம் கவனிப்போம், அதை பொய்யாக மாற்றுகிறது. இதேபோல், இது 'isFalse' (முதலில் பொய்) இன் உண்மை மதிப்பைத் தலைகீழாக மாற்றுகிறது, இது உண்மையாகிறது.

லாஜிக்கல் NOT ஆபரேட்டரால் அடையப்படும் உண்மை மதிப்புகளின் தலைகீழ் மாற்றத்தை வெளியீடு தெளிவாக விளக்குகிறது.

எடுத்துக்காட்டு 4: பிட்வைஸ் அல்ல (~) ஆபரேட்டர்

C++ இல் உள்ள பிட்வைஸ் NOT ஆபரேட்டர் (~) என்பது அதன் செயல்பாட்டின் ஒவ்வொரு பிட்டிற்கும் பிட்வைஸ் மறுப்பைச் செய்யும் ஒரு unary operator ஆகும். இது அடிப்படை தரவு வகைகளுடன் செயல்படுகிறது, குறிப்பாக முழு எண்கள் போன்ற ஒருங்கிணைந்தவை. ஓபராண்டில் உள்ள ஒவ்வொரு பிட்டையும் தலைகீழாக மாற்றி, 0களை 1 வியாகவும், 1 வி முதல் 0 வியாகவும் மாற்றுவதன் மூலம் விளைவு அடையப்படுகிறது.

அதன் பயன்பாட்டை விளக்க, பின்வரும் குறியீடு துணுக்கைக் கவனியுங்கள்:

இந்த எடுத்துக்காட்டில், “5” மதிப்புடன் “அசல் மதிப்பு” முழு எண் மாறியை அறிவிக்கிறோம். அடுத்து, இந்த மாறியில் பிட்வைஸ் NOT ஆபரேட்டரை (~) பயன்படுத்துகிறோம். இந்த மாறியின் முடிவு “resultBitwiseNot” இல் சேமிக்கப்படுகிறது. நிரல் அசல் மதிப்பையும் பிட்வைஸ் NOT செயல்பாட்டிற்குப் பிறகு முடிவையும் அச்சிடுகிறது.

இந்த நிரலை இயக்கும் போது, ​​பிட்வைஸ் NOT ஆபரேட்டர் ஒவ்வொரு பிட்டையும் 'ஒரிஜினல் வேல்யூ' இன் பைனரி பிரதிநிதித்துவத்தின் தலைகீழாக மாற்றுவதைக் காண்போம், இதன் விளைவாக ஒரு புதிய மதிப்பு கிடைக்கும்.

எடுத்துக்காட்டு 5: முகவரி மற்றும் மறைமுக ஆபரேட்டர்கள்

'&' குறியீட்டால் குறிக்கப்படும் ஆபரேட்டரின் முகவரி, மாறியின் நினைவக இருப்பிடத்தை மீட்டெடுக்கும் நோக்கத்திற்காக உதவுகிறது. இது மாறிக்கு ஒரு சுட்டியை வழங்குகிறது, இது அதன் மதிப்பை மறைமுகமாக அணுக உதவுகிறது. ஒரு சுட்டியால் குறிப்பிடப்பட்ட நினைவக இடத்தில் சேமிக்கப்படும் மதிப்பை மறைமுகம் அல்லது dereference ஆபரேட்டர் (*) பெறுகிறது. மறைமுகமாக ஒரு சுட்டி மூலம் உண்மையான தரவுகளுடன் வேலை செய்வதற்கான வழியை இது வழங்குகிறது.

ஒரு உதாரணத்துடன் கருத்தைப் புரிந்துகொள்வோம்:

இந்த குறியீடு முகவரி மற்றும் மறைமுக ஆபரேட்டர்களின் பயன்பாட்டை எடுத்துக்காட்டுகிறது. முதலில், 'மதிப்பு' என பெயரிடப்பட்ட ஒரு முழு எண் மாறி 99 இன் மதிப்புடன் துவக்கப்படுகிறது. 'மதிப்பு' இன் அசல் மதிப்பு பின்னர் கன்சோலில் வெளியிடப்படும். பின்னர், ஒரு “ptr” சுட்டி மாறி அறிவிக்கப்பட்டது, மேலும் “மதிப்பு” நினைவக முகவரியை “ptr” க்கு ஒதுக்க ஆபரேட்டரின் முகவரி (&) பயன்படுத்தப்படுகிறது. நிரல் இந்த நினைவக முகவரியை வெளியிடுகிறது, 'முகவரி' ஆபரேட்டரின் அடிப்படை செயல்பாட்டைக் காட்டுகிறது.

அதன் பிறகு, 'retrievedValue' என்ற புதிய முழு எண் மாறி அறிவிக்கப்பட்டது, மேலும் 'ptr' சுட்டிக்காட்டிய நினைவக முகவரியில் சேமிக்கப்பட்ட மதிப்பை மீட்டெடுக்க மறைமுக ஆபரேட்டர் (*) பயன்படுத்தப்படுகிறது. மீட்டெடுக்கப்பட்ட மதிப்பு பின்னர் கன்சோலுக்கு வெளியிடப்படும்.

முடிவுரை

இந்தக் கட்டுரை C++ இல் உள்ள unary operators பற்றிய விரிவான ஆய்வை வழங்கியது. எண்கணிதம், லாஜிக்கல், பிட்வைஸ் மற்றும் முகவரி மற்றும் மறைமுகம் தொடர்பான பல்வேறு வகைகளில் unary ஆபரேட்டர்களை வகைப்படுத்துவதன் மூலம் தொடங்கினோம். இந்த ஆபரேட்டர்களின் பயனுள்ள பயன்பாட்டை நிரூபிக்க நிஜ-உலக சூழ்நிலைகள் எடுத்துக்காட்டுகின்றன. இந்த ஆபரேட்டர்கள் C++ நிரலாக்கத்தில் முக்கிய பங்கு வகிக்கின்றனர், இது டெவலப்பர்களை சுட்டிகளுடன் திறமையாக வேலை செய்யவும் நினைவகத்தை நிர்வகிக்கவும் அனுமதிக்கிறது.