எங்கள் விவாதத்தின் தலைப்பு ஷிப்ட் ஆபரேட்டர்களைப் பற்றியது. பிட்வைஸ் லெப்ட் ஷிப்ட் ஆபரேட்டர் (<<) பற்றி விரிவாக விளக்கப்படும். ஷிப்ட் ஆபரேட்டர், பெயர் குறிப்பிடுவது போல, பிட்டை குறிப்பிட்ட நிலையில் இருந்து இடது அல்லது வலது பக்கம் மாற்றுகிறது. பிட்வைஸ் லெப்ட் ஷிப்ட் ஆபரேட்டரை (<<) பயன்படுத்தும் போது குறிப்பிட்ட எண்ணிக்கையிலான பிட்களால் மதிப்பு இடது பக்கம் நகர்த்தப்படுகிறது. இடது ஷிப்ட் ஆபரேட்டர்கள் உள்ளீட்டை முழு எண் (முழு எண்), uint (கையொப்பமிடப்படாத முழு எண்), நீண்ட (நீண்ட முழு எண்) மற்றும் உலாங் (கையொப்பமிடப்படாத நீண்ட முழு எண்) ஆகியவற்றில் மட்டுமே எடுக்கிறார்கள். இடது ஓபராண்ட் வேறு வகையைச் சேர்ந்தால், அது முழு எண் வகையாக மாற்றப்படும். விளைவான மதிப்பின் தரவு வகை 32 பிட்களின் வரம்பைத் தக்க வைத்துக் கொள்ளும்; வெளியீடு அதை விட பெரியதாக இருக்க முடியாது. பிட்வைஸ் ஆபரேட்டர்கள் குறியீட்டை திறமையாகவும் வேகமாகவும் ஆக்குகிறார்கள். மேலும், அவை அதிக துல்லியம் மற்றும் துல்லியத்தை வழங்குகின்றன.
தொடரியல்:
இயக்கம்_1 << இயக்கம்_2
முதல் 'Operand_1' என்பது இடதுபுறத்தில் இருந்து 'Operand_2' உள்ள மாற்றங்களின் எண்ணிக்கைக்கு மாற்றப்பட்ட மதிப்பாகும். << இடதுபுறம் உள்ள சின்னம் “Operand_1” ஐ மாற்றுகிறது.
எடுத்துக்காட்டு 1:
பிட்வைஸ் லெப்ட் ஷிப்ட் ஆபரேட்டர் (<<) இந்த நிரலில் உள்ள முழு எண் மதிப்புகளுக்குப் பயன்படுத்தப்படுகிறது.
கணினியைப் பயன்படுத்துதல்;
வகுப்பு திட்டம்_1
{
நிலையான வெற்றிட முதன்மை ( ) {
முழு மதிப்பு_0 = 3. 4 ;
முழு மதிப்பு_1 = 65 ;
முழு எண்ணாக ரெஸ் = மதிப்பு_0 << மதிப்பு_1;
கன்சோல்.எழுது ( 'இடது ஷிப்ட் என்பது ' ) ;
கன்சோல்.எழுது ( ரெஸ் ) ;
}
}
முதல் அறிக்கையில் இரண்டு முழு எண் வகை மாறிகளின் அறிவிப்பு மற்றும் துவக்கம் உள்ளது. முதல் மாறி 'Value_0' மற்றும் இரண்டாவது மாறி 'Value_1' ஆகும். அவற்றில் சேமிக்கப்படும் மதிப்புகள் '34' மற்றும் '65' ஆகும். இடது ஷிப்ட் ஆபரேட்டரை (<<) பயன்படுத்தி 34 மதிப்பை மாற்றினோம். பின்னர், முடிவைச் சேமிக்க முழு எண் தரவு வகையைக் கொண்ட மற்றொரு மாறியை அறிவிக்கிறோம். இங்கே, இடது ஷிப்ட் ஆபரேட்டரை (<<) Value_0 << Value_1 ஆகப் பயன்படுத்துகிறோம். இந்த ஆபரேட்டர் லெஃப்ட் ஓபராண்டின் இடது மதிப்பை இரண்டாவது ஓபராண்டில் கொடுக்கப்பட்ட மதிப்பால் மாற்றுகிறது. 'res' ஆனது ஷிப்ட் ஆபரேட்டரின் வெளியீட்டை சேமிக்கிறது. இதற்குப் பிறகு, 'இடது ஷிப்ட் ஆகும்' என்ற உரையை அச்சிடுவதற்கு Console.Write() முறையை அழைக்கிறோம் மற்றும் டெர்மினலில் 'res' இல் சேமிக்கப்படும் மதிப்பு.
எடுத்துக்காட்டு 2:
கையொப்பமிடப்படாத முழு எண் மதிப்புகளில் இடது ஷிப்ட் ஆபரேட்டரைப் பயன்படுத்துவோம், மேலும் அவை எவ்வாறு வெளியீட்டை உருவாக்குகின்றன என்பதைப் பார்ப்போம்.
கணினியைப் பயன்படுத்துதல்;
வகுப்பு திட்டம்_2
{
நிலையான வெற்றிட முதன்மை ( ) {
uint Val_0 = 4435 ;
int Val_1 = 64 ;
uint விளைவாக = Val_0 << Val_1;
கன்சோல்.எழுது ( 'இடது பெயர்ச்சி' ) ;
கன்சோல்.எழுது ( விளைவாக ) ;
}
}
இங்கே, கையொப்பமிடப்படாத முழு எண் வகை மதிப்பில் இடது ஷிப்ட் ஆபரேட்டரைப் பயன்படுத்துகிறோம். நீங்கள் கவனிக்க வேண்டிய ஒரு விஷயம் என்னவென்றால், இரண்டாவது ஓபராண்ட் ஒரு முழு எண் வகை மதிப்பாக இருக்க வேண்டும், ஏனெனில் கம்பைலர் மாற்றுவதற்கு முழு எண் மதிப்பை மட்டுமே எடுக்கும்.
நிலையான வெற்றிடமான Main() செயல்பாட்டை அழைத்த பிறகு, நாம் இரண்டு மாறிகளை அறிவிக்கிறோம் - அதில் ஒன்று கையொப்பமிடப்படாத முழு எண் மதிப்பு 'Val_0' மற்றும் மற்றொன்று 'Val_1' என்ற முழு எண். பின்னர், கையொப்பமிடாத முழு எண்ணை இடதுபுறமாக மாற்றிய பிறகு, அதன் விளைவாக வரும் மதிப்பை வைத்திருக்க 'முடிவு' என்று மற்றொரு கையொப்பமிடப்படாத முழு எண் மாறியை வரையறுக்கிறோம். ஒரு முழு எண் வகை மாறியில் முடிவைச் சேமிக்க முடியாது, ஏனெனில் இடது மாற்றத்திற்குப் பிறகு, முடிவு கையொப்பமிடப்படாத மதிப்பாகும். இடதுபுறத்தில் உள்ள “Val_0 << Val_1” அறிக்கையானது கையொப்பமிடப்படாத முழு எண் மதிப்பான இடது இயக்கத்தை மாற்றுகிறது. இது கையொப்பமிடப்படாத முழு எண் மதிப்பை உருவாக்குகிறது. முடிவில், Console.Write() முறையைப் பயன்படுத்தி 'The left shift is' என்ற உரையுடன் வெளியீட்டுத் திரையில் முடிவைக் காட்டுங்கள்:
எடுத்துக்காட்டு 3:
இந்த நிகழ்வில், நீண்ட முழு எண் மதிப்புகளில் பிட்வைஸ் லெப்ட் ஷிப்ட் ஆபரேட்டரை (<<) பயன்படுத்தும் வெவ்வேறு முறைகளைப் பற்றி பேசுவோம்.
கணினியைப் பயன்படுத்துதல்;வகுப்பு திட்டம்_3
{
நிலையான வெற்றிட முதன்மை ( ) {
நீண்ட எண்_0 = நான்கு. ஐந்து ;
நீண்ட எண்_1 = 5 ;
கன்சோல்.எழுது ( 'நீண்ட இடது பெயர்ச்சி' ) ;
கன்சோல்.WriteLine ( எண்_0 << 3 ) ;
கன்சோல்.எழுது ( 'நீண்ட இடது பெயர்ச்சி' ) ;
கன்சோல்.எழுது ( எண்_0 << Convert.ToInt16 ( இலக்கம் 1 ) ) ;
}
}
'எண்_0' மற்றும் 'எண்_1' ஆகிய இரண்டு நீண்ட முழு எண் வகை மாறிகளின் துவக்கம் முதல் கூற்றில் செய்யப்படுகிறது. 'The left shift of long is' என்ற செய்தியையும் முனையத்தில் உள்ள முடிவையும் குறிக்க Console.Write() செயல்பாட்டைப் பயன்படுத்தவும். இங்கே, இடது ஷிப்ட் ஆபரேட்டரை (<<) பயன்படுத்துகிறோம், அதாவது முதல் இயக்கத்தை முதல் மாறியாகவும், இரண்டாவது செயலியை முழு எண்ணாகவும் வைக்கிறோம். கம்பைலர் இடதுபுறத்தில் உள்ள முதல் இயக்கத்தை “எண்_0” ஆக 3 ஆல் மாற்றி, முடிவைக் காட்டுகிறது. அடுத்த அறிக்கையில், Console.Write() முறையைப் பயன்படுத்தி மற்றொரு செய்தியை திரையில் அச்சிடவும். இங்கே, நாம் முதல் மாறி, “number_0” ஐ முதல் operand ஆகவும், இரண்டாவது மாறி, “number_1” ஐ இரண்டாவது operand ஆகவும் பயன்படுத்துகிறோம். இரண்டாவது செயல்பாடானது முழு எண் வகை மதிப்பாக இருக்க வேண்டும். Convert.ToInt16() செயல்பாட்டைப் பயன்படுத்தி இரண்டாவது மாறி “number_1” ஐ முழு எண் வகைக்கு தட்டச்சு செய்கிறோம். பின்னர், கன்சோலில் முடிவைக் காட்டவும்:
எடுத்துக்காட்டு 4:
கையொப்பமிடாத நீண்ட ஆபரேட்டரில் இடது ஷிப்ட்டைச் செய்த பிறகு, ஒரு முழு எண்ணுக்கு மதிப்புகளை எவ்வாறு ஒதுக்கலாம் என்பதை இந்தக் குறியீடு காட்டுகிறது.
கணினியைப் பயன்படுத்துதல்;வகுப்பு நிரல்_4
{
நிலையான வெற்றிட முதன்மை ( ) {
தலை எண்_0 = 445 ;
கன்சோல்.எழுது ( 'உலாங்கின் இடது பெயர்ச்சி' ) ;
கன்சோல்.WriteLine ( எண்_0 << 8 ) ;
கன்சோல்.எழுது ( 'உலாங்கின் இடது பெயர்ச்சி' ) ;
கன்சோல்.WriteLine ( எண்_0 << 16 ) ;
கன்சோல்.எழுது ( 'உலாங்கின் இடது பெயர்ச்சி' ) ;
கன்சோல்.WriteLine ( எண்_0 << 32 ) ;
}
}
முதலில், ஒரு கையொப்பமிடப்படாத நீண்ட முழு எண் வகை மாறியை அறிவிக்கவும், அது “எண்_0” ஆகும். அடுத்து, Console.Write() முறையை அழைப்பதன் மூலம் டெர்மினலில் 'The left shift of Ulong is' என்ற உரையைக் காட்டவும். 'எண்_0' இன் இடதுபுற மாற்றத்தை 8 இன் முழு எண் மூலம் கண்டுபிடிப்போம், மேலும் முடிவை எங்கும் சேமிக்க வேண்டியதில்லை. Console.WriteLine() செயல்பாடு கன்சோலில் முடிவை அச்சிடுகிறது. இந்த செயல்முறையை இரண்டு முறை செய்யவும் மற்றும் இரண்டாவது செயலியின் மதிப்புகளை மாற்றவும். இதைச் செய்வதன் மூலம், நீண்ட கையொப்பமிடப்படாத முழு எண் வகை மதிப்பின் இடது மாற்றத்தைக் கண்டறியலாம். ஆனால் அதன் விளைவாக வரும் மதிப்பை ஒரு மாறியில் சேமிக்க விரும்பினால், முடிவு முதல் ஓபராண்ட் போலவே இருக்கும் என்ற எண்ணத்தில் இருக்க வேண்டும். Console.Write() மற்றும் Console.WriteLine() ஆகியவற்றுக்கு இடையே உள்ள ஒரே வித்தியாசம் என்னவென்றால், இரண்டாவது செயல்பாடு முடிவை அச்சிட்டு அடுத்த வரிக்கு கர்சரை அனுப்புகிறது. வெளியீட்டைக் காட்டுகிறது.
முடிவுரை
C# இல் உள்ள பிட்வைஸ் ஆபரேட்டர்கள், அவற்றின் வகைகள் மற்றும் செயல்பாடுகளை ஆராய்ந்தோம். இடது ஷிப்ட் (<<) ஆபரேட்டர் எண் அல்லது மதிப்பை குறிப்பிட்ட எண்ணிக்கையிலான பிட்களால் இடதுபுறமாக மாற்ற பயன்படுத்தப்படுகிறது. பிட்வைஸ் ஆபரேட்டர்கள் குறியீட்டின் செயல்திறனை மேம்படுத்துகிறது மற்றும் அவர்கள் இலகுரக ஆபரேட்டர்கள் என்பதால் இது கணினிக்கு சுமையாக இருக்காது. நாம் எந்த எண்கணித செயல்பாடுகளையும் செய்யும் போதெல்லாம், எங்கள் CPU (கணினி செயலாக்க அலகு) பிட்வைஸ் மட்டத்தில் வேலை செய்கிறது. சுருக்கமாக, பிட்வைஸ் ஆபரேட்டர்கள் புரோகிராமிங்கில் முக்கியமானவர்கள் மற்றும் இடது ஷிப்ட் ஆபரேட்டர் (<<) ஒன்று இருக்கும் அனைத்து பிட்வைஸ் ஆபரேட்டர்களையும் C# ஆதரிக்கிறது.