இந்த விரிவான வழிகாட்டியில், சி நிரலாக்கத்தில் உள்ள ஆபரேட்டர்கள் மற்றும் அவற்றின் வகைகளைப் பற்றி விவாதிப்போம்.
சி புரோகிராமிங்கில் ஆபரேட்டர்கள் மற்றும் அவற்றின் வகைகள்
ஆபரேட்டர்கள் என்பது குறிப்பிட்ட கணிதப் பணிகளைச் செய்யப் பயன்படும் குறியீடுகள். தரவு மற்றும் மாறிகளை கையாள அவை பயன்படுத்தப்படுகின்றன. சி நிரலாக்கத்தில் பின்வரும் பல்வேறு வகையான ஆபரேட்டர்கள் உள்ளன:
- எண்கணித ஆபரேட்டர்கள்
- யூனரி ஆபரேட்டர்கள்
- பணி ஆபரேட்டர்கள்
- தருக்க அல்லது பூலியன் ஆபரேட்டர்கள்
- தொடர்புடைய ஆபரேட்டர்கள்
- நிபந்தனை ஆபரேட்டர்கள்
- பிட்வைஸ் ஆபரேட்டர்கள்
1: எண்கணித ஆபரேட்டர்கள்
கூட்டல், கழித்தல் அல்லது பெருக்கல் போன்ற அடிப்படைக் கணிதச் செயல்பாடுகளைச் செய்யப் பயன்படுத்தப்படும் ஆபரேட்டர்கள் இவை. சி நிரலாக்கத்தின் கிட்டத்தட்ட அனைத்து உள்ளமைக்கப்பட்ட தரவு வகைகளிலும் இந்த ஆபரேட்டர்களைப் பயன்படுத்தலாம். சி நிரலாக்கத்தில் பயன்படுத்தப்படும் எண்கணித ஆபரேட்டர்கள் பின்வருமாறு:
| ஆபரேட்டர்கள் | செயல்பாடுகள் |
| + | 2 செயல்பாடுகளைச் சேர்க்கவும் |
| – | 2 செயல்களை கழிக்கவும் |
| * | 2 செயல்களை பெருக்கவும் |
| / | 2 செயல்களை வகுக்கவும் |
| % | மாடுலஸ் ஆபரேட்டர் பிரிவின் மீதமுள்ள பகுதியை வழங்குகிறது |
உதாரணமாக
கீழே உள்ள எடுத்துக்காட்டில், மேலே குறிப்பிட்டுள்ள எண்கணித செயல்பாடுகளை X மற்றும் மாறி Y ஆகியவற்றில் செய்துள்ளோம். X மாறி 20ஐயும், Y மதிப்பு 5ஐயும் கொண்டுள்ளது:
#
முழு எண்ணாக முக்கிய ( )
{
முழு எண்ணாக எக்ஸ் = இருபது ;
முழு எண்ணாக மற்றும் = 5 ;
முழு எண்ணாக விளைவாக ;
விளைவாக = எக்ஸ் + மற்றும் ;
printf ( 'எக்ஸ் மற்றும் ஒய் கூட்டல்: %d \n ' , விளைவாக ) ;
விளைவாக = எக்ஸ் - மற்றும் ;
printf ( 'எக்ஸ் மற்றும் ஒய் கழித்தல்: %d \n ' , விளைவாக ) ;
விளைவாக = எக்ஸ் * மற்றும் ;
printf ( 'X மற்றும் Y இன் பெருக்கல்: %d \n ' , விளைவாக ) ;
விளைவாக = எக்ஸ் / மற்றும் ;
printf ( 'X மற்றும் Y இன் பிரிவு: %d \n ' , விளைவாக ) ;
விளைவாக = எக்ஸ் % மற்றும் ;
printf ( 'X மற்றும் Y இன் மாடுலஸ் பிரிவு: %d \n ' , விளைவாக ) ;
திரும்ப 0 ;
}
2: யூனரி ஆபரேட்டர்கள்
C மொழியால் மட்டுமே ஆதரிக்கப்படும் இரண்டு தனித்துவமான unary ஆபரேட்டர்கள் உள்ளன, அதிகரிப்பு ++ மற்றும் decrement — ஆபரேட்டர்கள். இன்க்ரிமென்ட் ஆபரேட்டர் 1ஐ ஓபராண்டில் சேர்க்கிறது, மேலும் குறைப்பு ஆபரேட்டர் ஓபராண்டில் இருந்து 1ஐக் கழிக்கிறார்.
அதிகரிப்பு ஆபரேட்டர் இவ்வாறு எழுதப்பட்டுள்ளது:
++ a அல்லது a ++
குறைப்பு ஆபரேட்டர்:
-- a அல்லது a --நாம் அதிகரிப்பு மற்றும் குறைப்பு ஆபரேட்டரை ஒரு முன்னொட்டாகப் பயன்படுத்தினால், அது முதலில் மாறி மதிப்பைக் கூட்டுகிறது அல்லது கழிக்கிறது, அதன் விளைவாக இடதுபுறத்தில் உள்ள மாறிக்கு ஒதுக்கப்படும். ஆபரேட்டர்கள் முன்பு சேர்க்கப்பட்டால், அது முதலில் அசல் மதிப்பைத் தருகிறது, பின்னர் இயக்கமானது 1 ஆல் சேர்க்கப்படும் அல்லது கழிக்கப்படும்.
உதாரணமாக
கீழே a மற்றும் b ஆகிய இரண்டு மாறிகளுக்கு மதிப்புகளை ஒதுக்கியுள்ளோம், மேலும் அவற்றில் அதிகரிப்பு மற்றும் குறைப்பு ஆபரேட்டர்களைப் பயன்படுத்துகிறோம்:
#முழு எண்ணாக முக்கிய ( )
{
முழு எண்ணாக அ = பதினைந்து , பி = 10 ;
printf ( '++a = %d \n ' , ++ அ ) ;
printf ( 'a++ = %d \n ' , அ ++ ) ;
திரும்ப 0 ;
}
3: அசைன்மென்ட் ஆபரேட்டர்
ஒரு பணி ஆபரேட்டர் (=) நிரலில் உள்ள மாறிக்கு மதிப்பை ஒதுக்க பயன்படுகிறது. கீழே குறிப்பிடப்பட்டுள்ள பணி ஆபரேட்டர்கள்:
| ஆபரேட்டர்கள் | செயல்பாடு |
| = | செயல்பாட்டிற்கு மதிப்புகளை ஒதுக்கவும் |
| += | வலதுபுறத்தில் உள்ள ஓபராண்டின் மதிப்பை இடது ஓபராண்டில் சேர்க்கவும் |
| -= | வலது ஓபராண்டின் மதிப்பை இடது ஓபராண்டில் இருந்து கழிக்கவும் |
| *= | வலது ஓபராண்டின் மதிப்பை இடது ஓபராண்டில் பெருக்கவும் |
| /= | வலது ஓபராண்டின் மதிப்பை இடது ஓபராண்டிற்குப் பிரிக்கவும் |
| %= | இரண்டு மதிப்புகளின் மாடுலஸை எடுத்து, இடது செயலிக்கு மதிப்பை ஒதுக்கவும் |
உதாரணமாக
கீழேயுள்ள எடுத்துக்காட்டில் X மற்றும் Y ஆகிய இரண்டு ஆபரேட்டர்களில் அசைன்மென்ட் ஆபரேட்டர்களின் செயல்பாட்டை நாங்கள் நிரூபித்துள்ளோம்:
#முழு எண்ணாக முக்கிய ( )
{
முழு எண்ணாக எக்ஸ் = 10 ;
முழு எண்ணாக விளைவாக ;
விளைவாக = எக்ஸ் ;
printf ( 'முடிவின் மதிப்பு = %d \n ' , விளைவாக ) ;
விளைவாக += எக்ஸ் ;
printf ( 'முடிவின் மதிப்பு = %d \n ' , விளைவாக ) ;
விளைவாக -= எக்ஸ் ;
printf ( 'முடிவின் மதிப்பு = %d \n ' , விளைவாக ) ;
விளைவாக *= எக்ஸ் ;
printf ( 'முடிவின் மதிப்பு = %d \n ' , விளைவாக ) ;
விளைவாக /= எக்ஸ் ;
printf ( 'முடிவின் மதிப்பு = %d \n ' , விளைவாக ) ;
திரும்ப 0 ;
}
4: தொடர்புடைய ஆபரேட்டர்கள்
சி நிரலாக்கத்தில் இரண்டு மாறிகளுக்கு இடையிலான உறவைச் சரிபார்க்க தொடர்புடைய ஆபரேட்டர்கள் பயன்படுத்தப்படுகின்றன. பொருட்களின் விலையை அல்லது இரண்டு நபர்களின் வயதை ஒப்பிட்டுப் பார்க்க இது பயன்படுத்தப்படலாம் C நிரலாக்கத்தில் பயன்படுத்தப்படும் தொடர்புடைய ஆபரேட்டர்கள் பின்வருமாறு:
| ஆபரேட்டர்கள் | செயல்பாடுகள் |
| == | சமமாக |
| > | விட பெரியது |
| < | விட குறைவாக |
| >= | சமமானதை விட பெரியது |
| <= | சமமானதை விட குறைவாக |
| != | சமமாக இல்லை |
உதாரணமாக
கீழே உள்ள எடுத்துக்காட்டு C நிரலாக்கத்தில் தொடர்புடைய ஆபரேட்டர்களின் செயல்பாட்டைக் காட்டுகிறது:
#முழு எண்ணாக முக்கிய ( )
{
முழு எண்ணாக அ = 9 ;
முழு எண்ணாக பி = 10 ;
printf ( '%d == %d என்பது %d \n ' , அ , பி , அ == பி ) ;
printf ( '%d > %d என்பது %d \n ' , அ , பி , அ > பி ) ;
printf ( '%d < %d என்பது %d \n ' , அ , பி , அ < பி ) ;
printf ( '%d != %d என்பது %d \n ' , அ , பி , அ != பி ) ;
printf ( '%d >= %d என்பது %d \n ' , அ , பி , அ >= பி ) ;
printf ( '%d <= %d என்பது %d \n ' , அ , பி , அ <= பி ) ;
திரும்ப 0 ;
}
5: லாஜிக்கல் ஆபரேட்டர்கள்
சி மொழியால் ஆதரிக்கப்படும் நான்கு தருக்க ஆபரேட்டர்கள் உள்ளன:
| ஆபரேட்டர்கள் | செயல்பாடு |
| தருக்க மற்றும் (&&) | எல்லா நிபந்தனைகளும் பூர்த்தி செய்யப்பட்டால் மட்டுமே உண்மை |
| தருக்க அல்லது (||) | ஒரே ஒரு நிபந்தனை பூர்த்தி செய்தால், முடிவு உண்மையாக இருக்கும் |
| தர்க்கம் இல்லை(!) | Operand 0 எனில் முடிவு உண்மையாக இருக்கும் |
| பிட்வைஸ் இல்லை (~). | செயல்பாட்டின் அனைத்து பிட்களையும் தலைகீழாக மாற்றுகிறது |
உதாரணமாக
கீழே உள்ள எடுத்துக்காட்டு குறியீடு C இல் தருக்க ஆபரேட்டர்களின் செயல்பாட்டை விளக்குகிறது:
#முழு எண்ணாக முக்கிய ( )
{
முழு எண்ணாக எக்ஸ் = 10 , மற்றும் = 4 , உடன் = 10 , விளைவாக ;
விளைவாக = ( எக்ஸ் == மற்றும் ) && ( உடன் > மற்றும் ) ;
printf ( '(X == Y) && (Z > Y) என்பது %d \n ' , விளைவாக ) ;
விளைவாக = ( எக்ஸ் == மற்றும் ) && ( உடன் < மற்றும் ) ;
printf ( '(X == Y) && (Z < Y) என்பது %d \n ' , விளைவாக ) ;
விளைவாக = ( எக்ஸ் == மற்றும் ) || ( உடன் < மற்றும் ) ;
printf ( '(X == Y) || (Z < Y) என்பது %d \n ' , விளைவாக ) ;
விளைவாக = ( எக்ஸ் != மற்றும் ) || ( உடன் < மற்றும் ) ;
printf ( '(X != Y) || (Z < Y) என்பது %d \n ' , விளைவாக ) ;
விளைவாக = ! ( எக்ஸ் != மற்றும் ) ;
printf ( '!(X != Y) என்பது %d \n ' , விளைவாக ) ;
விளைவாக = ! ( எக்ஸ் == மற்றும் ) ;
printf ( '!(X == Y) என்பது %d \n ' , விளைவாக ) ;
விளைவாக = ! ( எக்ஸ் > மற்றும் ) ;
printf ( '!(X > Y) என்பது %d \n ' , விளைவாக ) ;
திரும்ப 0 ;
}
6: நிபந்தனை ஆபரேட்டர்கள்
C இல் உள்ள நிபந்தனை ஆபரேட்டர் என்றும் அழைக்கப்படுகிறது மும்மை இயக்குபவர் ஏனெனில் இது நிபந்தனை, கூற்று 1 மற்றும் கூற்று 2 ஆகிய மூன்று செயல்களை எடுக்கும்
நிலை ? அறிக்கை 1 : அறிக்கை 2- நிலை: பூலியன் வெளிப்பாடு உண்மையா அல்லது பொய்யா என்பதைச் சரிபார்க்கும்.
- அறிக்கை 1: நிபந்தனை உண்மையாக இருந்தால் மதிப்பீடு செய்யப்படும் வெளிப்பாடு.
- அறிக்கை 2: நிபந்தனை தவறாக இருந்தால் மதிப்பீடு செய்யப்படும் வெளிப்பாடு.
உதாரணமாக
கீழே உள்ள எடுத்துக்காட்டில், நான் எண்ணுக்கு மதிப்பை ஒதுக்கியுள்ளேன், பின்னர் நிபந்தனையைப் பயன்படுத்தினேன், நிபந்தனை உண்மையாக இருந்தால், அறிக்கை 1 வெளியீடாகவும், நிபந்தனை தவறானதாக இருந்தால், அறிக்கை இரண்டு வெளியீடாகவும் இருக்கும்:
#முழு எண்ணாக முக்கிய ( )
{
முழு எண்ணாக எண் = 10 ;
( எண் < இருபது ) ? ( printf ( 'இது எண் 20 ஐ விடக் குறைவு!' ) ) : ( printf ( 'இது எண் 20 ஐ விட பெரியது!' ) ) ;
திரும்ப 0 ;
}
7: பிட்வைஸ் ஆபரேட்டர்கள்
பிட்வைஸ் ஆபரேட்டர்கள் C இல் பிட் மட்டத்தில் தரவை கையாளவும், அதாவது முழு எண்கள் போன்ற தரவு வகைகளுக்குள் தனிப்பட்ட பிட்களில் அவை செயல்படுகின்றன. இரட்டை மற்றும் மிதவைக்கு அவற்றைப் பயன்படுத்த முடியாது மற்றும் பிட்களைச் சோதித்து அவற்றை வலது அல்லது இடதுபுறமாக மாற்றுவதற்குப் பயன்படுத்தப்படுகின்றன.
C நிரலாக்கத்தில் பிட்வைஸ் ஆபரேட்டர்கள் கீழே உள்ள அட்டவணையில் கொடுக்கப்பட்டுள்ளன:
| ஆபரேட்டர்கள் | செயல்பாடு |
| & | பிட்வைஸ் மற்றும் |
| | | பிட்வைஸ் அல்லது |
| ^ | பிட்வைஸ் பிரத்தியேக OR |
| << | ஷிப்ட் விட்டு |
| >> | வலதுபுறமாக மாற்றவும் |
| ~ | ஒருவரின் நிரப்பு |
உதாரணமாக
பின்வரும் எடுத்துக்காட்டு பிட்வைஸ் ஆபரேட்டர்களைப் பயன்படுத்தும் சி நிரலைக் காட்டுகிறது:
#முழு எண்ணாக முக்கிய ( ) {
முழு எண்ணாக அ = 13 ; // பைனரி 1101
முழு எண்ணாக பி = 7 ; // பைனரி 0111
முழு எண்ணாக விளைவாக ;
// பிட்வைஸ் மற்றும்
விளைவாக = அ & பி ; // 1101 & 0111 = 0101 (தசமம் 5)
printf ( 'a & b = %u \n ' , விளைவாக ) ;
// பிட்வைஸ் அல்லது
விளைவாக = அ | பி ; // 1101 | 0111 = 1111 (தசமம் 15)
printf ( 'a | b = %u \n ' , விளைவாக ) ;
// பிட்வைஸ் XOR
விளைவாக = அ ^ பி ; // 1101 ^ 0111 = 1010 (தசமம் 10)
printf ( 'a ^ b = %u \n ' , விளைவாக ) ;
// பிட்வைஸ் இடது ஷிஃப்ட்
விளைவாக = அ << 2 ; // 1101 << 2 = 110100 (தசமம் 52)
printf ( 'a << 2 = %u \n ' , விளைவாக ) ;
// பிட்வைஸ் ரைட் ஷிப்ட்
விளைவாக = அ >> 2 ; // 1101 >> 2 = 0011 (தசமம் 3)
printf ( 'a >> 2 = %u \n ' , விளைவாக ) ;
// பிட்வைஸ் இல்லை
விளைவாக = ~a ; // ~1101 = 0010 (தசம 2 இன் நிரப்பு பிரதிநிதித்துவம் -14)
printf ( '~a = %d \n ' , விளைவாக ) ;
திரும்ப 0 ;
}
குறிப்பு: பிட்வைஸ் ஆபரேட்டர்கள் பிட் மட்டத்தில் பணிகளைச் செய்யப் பயன்படுத்தப்படுகின்றன, அதாவது அவை பைனரி எண்ணுக்குள் தனிப்பட்ட பிட்களில் செயல்படுகின்றன. பூலியன் ஆபரேட்டர்கள், மறுபுறம், தருக்க மதிப்புகளில் செயல்பாடுகளைச் செய்யப் பயன்படுத்தப்படுகின்றன. அவை பூலியன் மதிப்புகளில் (உண்மை/தவறு அல்லது 1/0) செயல்படுகின்றன மற்றும் பொதுவாக முடிவெடுக்கும் செயல்முறைகள் அல்லது நிபந்தனை அறிக்கைகளில் பயன்படுத்தப்படுகின்றன.
பாட்டம் லைன்
ஒரு ஆபரேட்டர் என்பது சில செயல்பாடுகளைச் செய்ய கம்பைலருக்கு அறிவுறுத்தும் ஒரு சின்னமாகும். சி மொழியில் எண்கணிதம், யூனரி, அசைன்மென்ட், லாஜிக்கல், ரிலேஷனல், கண்டிஷனல், பூலியன் மற்றும் பிட்வைஸ் உள்ளிட்ட பல உள்ளமைக்கப்பட்ட ஆபரேட்டர்கள் உள்ளன. நாங்கள் அவற்றை விரிவாக விவாதித்தோம் மற்றும் எடுத்துக்காட்டு வெளியீடு மூலம் அவற்றை நிரூபித்துள்ளோம். இந்த ஆபரேட்டர்களைப் பற்றிய விரிவான தகவல்களைப் பெற, வழிகாட்டியின் மேலே உள்ள பகுதியைப் படிக்கவும்.