Sa detalyadong gabay na ito, tatalakayin natin ang mga operator sa C programming at ang kanilang mga uri.
Mga Operator at Kanilang Mga Uri Sa C Programming
Ang mga operator ay ang mga simbolo, na ginagamit upang isagawa ang mga tiyak na gawaing pangmatematika. Ginagamit ang mga ito upang manipulahin ang data at mga variable. Ang mga sumusunod ay ang iba't ibang uri ng mga operator sa C programming:
- Mga Operator ng Arithmetic
- Unary Operator
- Mga Operator ng Pagtatalaga
- Lohikal o Boolean Operator
- Mga Relasyonal na Operator
- Mga Kondisyon na Operator
- Mga Operator ng Bitwise
1: Mga Operator ng Arithmetic
Ito ang mga operator na ginagamit upang magsagawa ng mga pangunahing mathematical function tulad ng Addition, Subtraction, o Multiplication. Maaari mong gamitin ang mga operator na ito sa halos lahat ng mga built-in na uri ng data ng C programming. Ang mga sumusunod ay ang mga Arithmetic operator na ginagamit sa C programming:
| Mga operator | Mga pag-andar |
| + | Magdagdag ng 2 operand |
| – | Magbawas ng 2 operand |
| * | I-multiply ang 2 operand |
| / | Hatiin ang 2 operand |
| % | Ang modulus operator ay nagbibigay ng natitirang bahagi ng dibisyon |
Halimbawa
Sa halimbawa sa ibaba, isinagawa namin ang nabanggit na mga operasyon ng arithmetic sa variable X at variable Y. Ang variable na X ay may hawak na value na 20 at Y ang may hawak ng value na 5:
#include
int pangunahing ( )
{
int X = dalawampu ;
int AT = 5 ;
int resulta ;
resulta = X + AT ;
printf ( 'Ang pagdaragdag ng X at Y ay: %d \n ' , resulta ) ;
resulta = X - AT ;
printf ( 'Ang pagbabawas ng X at Y ay: %d \n ' , resulta ) ;
resulta = X * AT ;
printf ( 'Ang pagpaparami ng X at Y ay: %d \n ' , resulta ) ;
resulta = X / AT ;
printf ( 'Ang dibisyon ng X at Y ay: %d \n ' , resulta ) ;
resulta = X % AT ;
printf ( 'Ang Modulus Division ng X at Y ay: %d \n ' , resulta ) ;
bumalik 0 ;
}
2: Unary Operator
Mayroong dalawang natatanging unary operator na sinusuportahan lamang ng C language, increment ++ at decrement — mga operator. Ang increment operator ay nagdaragdag ng 1 sa operand, at ang decrement operator ay nagbabawas ng 1 mula sa operand.
Ang increment operator ay nakasulat bilang:
++ a o a ++
Ang operator ng pagbabawas ay:
-- a o a --Kung gagamitin natin ang increment at decrement operator bilang prefix, idinaragdag o ibinabawas muna nito ang variable value at pagkatapos ay itatalaga ang resulta sa variable sa kaliwa. Kung ang mga operator ay idinagdag bago, ibinabalik muna nito ang orihinal na halaga at pagkatapos ay ang operand ay idinagdag o binabawasan ng 1.
Halimbawa
Sa ibaba ay nagtalaga kami ng mga halaga sa dalawang variable a at b at inilapat ang mga operator ng pagtaas at pagbaba sa mga ito:
#includeint pangunahing ( )
{
int a = labinlima , b = 10 ;
printf ( '++a = %d \n ' , ++ a ) ;
printf ( 'a++ = %d \n ' , a ++ ) ;
bumalik 0 ;
}
3: Operator ng Pagtatalaga
Isang assignment operator (=) ay ginagamit para sa pagtatalaga ng halaga sa variable sa programa. Nasa ibaba ang nabanggit na mga operator ng pagtatalaga:
| Mga operator | Function |
| = | Italaga ang mga halaga sa operand |
| += | Idagdag ang halaga ng operand na nasa kanan sa kaliwang operand |
| -= | Ibawas ang halaga ng kanang operand mula sa kaliwang operand |
| *= | I-multiply ang halaga ng kanang operand sa kaliwang operand |
| /= | Hatiin ang halaga ng kanang operand sa kaliwang operand |
| %= | Kunin ang modulus ng dalawang halaga at italaga ang halaga sa kaliwang operand |
Halimbawa
Ipinakita namin ang pagtatrabaho ng mga operator ng pagtatalaga sa dalawang operand X at Y sa halimbawa sa ibaba:
#includeint pangunahing ( )
{
int X = 10 ;
int resulta ;
resulta = X ;
printf ( 'Halaga ng resulta = %d \n ' , resulta ) ;
resulta += X ;
printf ( 'Halaga ng resulta = %d \n ' , resulta ) ;
resulta -= X ;
printf ( 'Halaga ng resulta = %d \n ' , resulta ) ;
resulta *= X ;
printf ( 'Halaga ng resulta = %d \n ' , resulta ) ;
resulta /= X ;
printf ( 'Halaga ng resulta = %d \n ' , resulta ) ;
bumalik 0 ;
}
4: Mga Relational Operator
Ang mga relational operator ay ginagamit sa C programming upang suriin ang relasyon sa pagitan ng dalawang variable. Maaari itong magamit upang ihambing ang mga presyo ng mga item o ang edad ng dalawang tao Ang mga sumusunod ay ang mga relational operator na ginagamit sa C programming:
| Mga operator | Mga pag-andar |
| == | Katumbas ng |
| > | Mahigit sa |
| < | Mas mababa sa |
| >= | Higit sa katumbas ng |
| <= | Mas mababa sa katumbas ng |
| != | Hindi kapareho ng |
Halimbawa
Ang halimbawa sa ibaba ay nagpapakita ng pagtatrabaho ng mga relational operator sa C programming:
#includeint pangunahing ( )
{
int a = 9 ;
int b = 10 ;
printf ( '%d == %d ay %d \n ' , a , b , a == b ) ;
printf ( '%d > %d ay %d \n ' , a , b , a > b ) ;
printf ( '%d < %d ay %d \n ' , a , b , a < b ) ;
printf ( '%d != %d ay %d \n ' , a , b , a != b ) ;
printf ( '%d >= %d ay %d \n ' , a , b , a >= b ) ;
printf ( '%d <= %d ay %d \n ' , a , b , a <= b ) ;
bumalik 0 ;
}
5: Mga Lohikal na Operator
Mayroong apat na lohikal na operator na sinusuportahan ng wikang C:
| Mga operator | Function |
| Lohikal AT (&&) | Tama lamang kung ang lahat ng kundisyon ay natutugunan |
| Lohikal O (||) | Kung isang kundisyon lamang ang nakakatugon sa resulta ay totoo |
| Lohikal HINDI(!) | Kung ang Operand ay 0 ang resulta ay totoo |
| Bitwise HINDI (~). | Binabaligtad ang lahat ng mga bit ng operand |
Halimbawa
Ipinapaliwanag ng halimbawang code sa ibaba ang pagtatrabaho ng mga lohikal na operator sa C:
#includeint pangunahing ( )
{
int X = 10 , AT = 4 , SA = 10 , resulta ;
resulta = ( X == AT ) && ( SA > AT ) ;
printf ( '(X == Y) && (Z > Y) ay %d \n ' , resulta ) ;
resulta = ( X == AT ) && ( SA < AT ) ;
printf ( '(X == Y) && (Z < Y) ay %d \n ' , resulta ) ;
resulta = ( X == AT ) || ( SA < AT ) ;
printf ( '(X == Y) || (Z < Y) ay %d \n ' , resulta ) ;
resulta = ( X != AT ) || ( SA < AT ) ;
printf ( '(X != Y) || (Z < Y) ay %d \n ' , resulta ) ;
resulta = ! ( X != AT ) ;
printf ( '!(X != Y) ay %d \n ' , resulta ) ;
resulta = ! ( X == AT ) ;
printf ( '!(X == Y) ay %d \n ' , resulta ) ;
resulta = ! ( X > AT ) ;
printf ( '!(X > Y) ay %d \n ' , resulta ) ;
bumalik 0 ;
}
6: Mga Kondisyon na Operator
Ang conditional operator sa C ay kilala rin bilang ang operator ng ternary dahil nangangailangan ito ng tatlong operand – ang kundisyon, pahayag 1, at pahayag 2. Sinusuri nito ang kundisyon at ibinabalik ang alinman sa pahayag 1 o pahayag 2, depende sa resulta ng isang ibinigay na kundisyon na maaaring tama o mali
Kundisyon ? Pahayag 1 : Pahayag 2- Kundisyon: Isang Boolean na expression na nagsusuri kung totoo o mali.
- Pahayag 1: Isang expression na sinusuri kung totoo ang kundisyon.
- Pahayag 2: Isang expression na sinusuri kung mali ang kundisyon.
Halimbawa
Sa halimbawa sa ibaba, itinalaga ko ang halaga sa numero at pagkatapos ay inilapat ang kundisyon, kung totoo ang kundisyon, ang statement 1 ang magiging output at kung mali ang kundisyon, ang statement na dalawa ang magiging output:
#includeint pangunahing ( )
{
int numero = 10 ;
( numero < dalawampu ) ? ( printf ( 'Ito ay mas mababa sa numero 20!' ) ) : ( printf ( 'Ito ay mas malaki kaysa sa numero 20!' ) ) ;
bumalik 0 ;
}
7: Mga Bitwise Operator
Mga operator ng bitwise sa C manipulahin ang data sa antas ng bit, ibig sabihin, gumagana ang mga ito sa mga indibidwal na bit sa loob ng mga uri ng data tulad ng mga integer. Ang mga ito ay hindi mailalapat sa double at float at ginagamit para sa pagsubok ng mga bit at paglilipat ng mga ito pakanan o pakaliwa.
Ang mga bitwise operator sa C programming ay ibinibigay sa talahanayan sa ibaba:
| Mga operator | Function |
| at | Bitwise AT |
| | | Bitwise O |
| ^ | Bitwise Exclusive O |
| << | Lumipat pakaliwa |
| >> | Lumipat Pakanan |
| ~ | Komplemento ng isa |
Halimbawa
Ang sumusunod na halimbawa ay nagpapakita ng isang C program na gumagamit ng mga bitwise operator:
#includeint pangunahing ( ) {
int a = 13 ; // binary 1101
int b = 7 ; // binary 0111
int resulta ;
// Bitwise AT
resulta = a at b ; // 1101 & 0111 = 0101 (decimal 5)
printf ( 'a & b = %u \n ' , resulta ) ;
// Bitwise O
resulta = a | b ; // 1101 | 0111 = 1111 (decimal 15)
printf ( 'a | b = %u \n ' , resulta ) ;
// Bitwise XOR
resulta = a ^ b ; // 1101 ^ 0111 = 1010 (decimal 10)
printf ( 'a ^ b = %u \n ' , resulta ) ;
// Bitwise left shift
resulta = a << 2 ; // 1101 << 2 = 110100 (decimal 52)
printf ( 'a << 2 = %u \n ' , resulta ) ;
// Bitwise right shift
resulta = a >> 2 ; // 1101 >> 2 = 0011 (decimal 3)
printf ( 'a >> 2 = %u \n ' , resulta ) ;
// Bitwise HINDI
resulta = ~a ; // ~1101 = 0010 (decimal 2's complement representation ng -14)
printf ( '~a = %d \n ' , resulta ) ;
bumalik 0 ;
}
Tandaan: Ang mga bitwise operator ay ginagamit upang magsagawa ng mga gawain sa antas ng bit, ibig sabihin, gumagana ang mga ito sa mga indibidwal na bit sa loob ng isang binary na numero. Ang mga operator ng Boolean, sa kabilang banda, ay ginagamit upang magsagawa ng mga operasyon sa mga lohikal na halaga. Gumagana ang mga ito sa mga halaga ng Boolean (true/false o 1/0) at karaniwang ginagamit sa mga proseso ng paggawa ng desisyon o conditional statement.
Bottom Line
Ang operator ay isang simbolo na nagtuturo sa compiler na magsagawa ng ilang mga function. Ang wikang C ay may ilang built-in na operator kabilang ang arithmetic, unary, assignment, logical, relational, conditional, Boolean, at bitwise. Napag-usapan namin ang mga ito nang detalyado at ipinakita ang mga ito sa halimbawang output. Basahin ang seksyon sa itaas ng gabay upang makakuha ng detalyadong impormasyon tungkol sa mga operator na ito.