Ang artikulong ito ay nagbibigay ng isang komprehensibong tutorial upang tulungan ka sa pag-aaral tungkol sa pagkakaugnay at pag-uuna sa operator sa C.
Pangunahing Operator sa C
Pangunahing operator inilalarawan ang pagkakasunud-sunod kung saan sinusuri ang ilang operator habang sinusuri ang mga expression. Halimbawa, kung ang isang expression ay may parehong karagdagan at multiplikasyon operator, alin ang dapat na masuri muna? Ang sagot ay simple, ang C ay sumusunod sa ilang mga patakaran upang malutas ang naturang kalabuan, karaniwang kilala bilang nangunguna sa operator . Sa C, nangunguna sa operator ay inuri sa 17 antas, mula sa unary operator hanggang sa ternary conditional operator. Karamihan sa mga ginagamit na operator tulad ng arithmetic operator, relational operator, logical operator, at bitwise operator ay sumusunod sa C standard nangunguna sa operator protocol.
Karapatan sa pangunguna idinidikta ng mga panuntunan kung aling mga operator ang may mas mataas na priyoridad kaysa sa iba kapag sinusuri ang mga expression. Ang ilang uri ng mga operator sa C programming language ay may iba't ibang antas ng karapatan sa pangunguna . Halimbawa, ang unary operator ay may higit na priyoridad kaysa binary operator. Ang sumusunod ay isang listahan ng mga operator na pinagsunod-sunod sa pataas na pagkakasunud-sunod ng karapatan sa pangunguna :
| Operator | Kahulugan ng Operator | Pagkakaisa |
| () [] -> . |
Functional na tawag Sanggunian ng elemento ng array Hindi direktang pagpili ng miyembro Direktang pagpili ng miyembro |
Kaliwa pakanan |
| ! ~ + – ++ — at * sukat ng (uri) |
Lohikal na negasyon Bitwise (1's) complement Unary plus Unary minus Pagtaas Pagbawas Dereference (Address) Sanggunian ng pointer Ibinabalik ang laki ng isang bagay Typecast (conversion) |
Kanan pakaliwa |
| * / % |
Paramihin hatiin Natitira |
Kaliwa pakanan |
| + – |
Binary plus(Addition) Binary minus(pagbabawas) |
Kaliwa pakanan |
| << >> |
Kaliwa shift Tamang shift |
Kaliwa pakanan |
| < <= > >= |
Mas mababa sa Mas mababa sa o katumbas Mahigit sa Higit sa o katumbas |
Kaliwa pakanan |
| == != |
Katumbas ng Hindi kapareho ng |
Kaliwa pakanan |
| at | Bitwise AT | Kaliwa pakanan |
| ^ | Bitwise eksklusibo O | Kaliwa pakanan |
| | | Bitwise O | Kaliwa pakanan |
| && | Lohikal AT | Kaliwa pakanan |
| || | Lohikal O | Kaliwa pakanan |
| ?: | Kondisyon Operator | Kanan pakaliwa |
| = *= /= %= += -= &= ^= |= <<= >>= |
Simpleng assignment Magtalaga ng produkto Magtalaga ng quotient Magtalaga ng natitira Magtalaga ng kabuuan Magtalaga ng pagkakaiba Magtalaga ng bitwise AT Magtalaga ng bitwise XOR Magtalaga ng bitwise O Magtalaga ng kaliwang shift Magtalaga ng tamang shift |
Kanan pakaliwa |
| , | Separator ng mga expression | Kaliwa pakanan |
Ginagabayan ng mga panuntunang ito ang compiler kung paano suriin ang mga expression na may maraming operator sa parehong expression. Ang multiplication operator, halimbawa, ay mas nauuna kaysa sa karagdagan operator sa equation na A + B * C, alinsunod sa karapatan sa pangunguna mga tuntunin. Samakatuwid, susuriin muna ng compiler ang expression na B * C bago idagdag ang A sa resulta.
Tingnan natin ang isang halimbawa ng nangunguna sa operator sa pamamagitan ng code.
#includeint pangunahing ( ) {
int a = 43 , b = labing-isa , c = 16 , d = 31 ;
int resulta = ++ a * b -- + c / -- d ;
printf ( 'a = %d \n ' , a ) ;
printf ( 'b = %d \n ' , b ) ;
printf ( 'c = %d \n ' , c ) ;
printf ( 'd = %d \n ' , d ) ;
printf ( 'resulta = %d \n ' , resulta ) ;
bumalik 0 ;
}
Ang apat na variable na a, b, c, at d, ay idineklara sa itaas na code, at ang kanilang mga inisyal na halaga ay 43, 11, 16, at 31 nang naaayon. Pagkatapos, inilalapat nito ang iba't ibang mga operator ng aritmetika at pagtatalaga sa mga variable na ito sa isang expression. Pinapataas ng expression ang value ng a sa pamamagitan ng paggamit ng pre-increment operator na ++a, pinaparami ang resulta sa post-decrement operator b–, at pagkatapos ay idinaragdag ang resulta sa dividing c ng pre-decremented value ng d. (gamit ang pre-decrement operator –d). Ang variable na resulta ay ginamit upang hawakan ang kabuuang kinalabasan ng expression na ito.
Output
Pagkakaisa sa C
Pagkakaisa ay tumutukoy sa pagkakasunud-sunod kung saan ang mga operator ay sinusuri sa panahon ng isang expression na may parehong precedence. Kaliwa sa kanan at kanan sa kaliwa pakikisama ay ang dalawang anyo ng associativity sa C. Kung ang dalawang operator ay may pareho karapatan sa pangunguna , ang mga ito ay tinasa mula kaliwa hanggang kanan ayon sa konsepto ng kaliwa-pakanan pakikisama . Gayunpaman, kung ang parehong precedence ay sinusunod, ang mga operator ay sinusuri mula kanan hanggang kaliwa ayon sa kanan-papuntang-kaliwa. pakikisama .
Halimbawa, ang ++ increment operator ay may right-to-left pakikisama , na nangangahulugang ang pagtaas operator ay sinusuri pagkatapos ng variable. Samantalang ang lohikal na AT operator ay may kaliwa-papuntang-kanan pakikisama , na nangangahulugang sinusuri ang operator mula kaliwa hanggang kanan.
#includeint main() {
int a = 6 , b = 3 , c = 2 ;
int resulta = a * b / c;
printf( 'resulta = %d \n ' , resulta);
bumalik 0 ;
}
Ang tatlong variable na a, b, at c ay idineklara sa code na ito, at ang mga ito ay sinisimulan sa 6, 3, at 2 ayon sa pagkakabanggit. Pagkatapos, inilalapat nito ang pagpaparami at paghahati sa mga variable na ito sa isang expression. Ang pagpaparami at paghahati ay niraranggo mula kaliwa hanggang kanan sa C batay sa kanilang pakikisama dahil pareho sila ng antas ng precedence. Ito ay nagpapahiwatig na ang operasyon ng paghahati ay nauuna, na sinusundan ng pagpaparami ng pagpaparami kapag sinusuri ang expression, a * b / c.
Output
Konklusyon
Pangunahing operator at pakikisama ay mga mahahalagang konsepto sa C programming na tumutulong na matukoy ang pagkakasunud-sunod ng pagpapatupad ng mga expression. Mga operator na may pinakamataas karapatan sa pangunguna antas ay sinusuri muna at pakikisama nakakatulong ang mga panuntunan na matukoy ang pagkakasunud-sunod kapag ginamit ang maraming operator na may parehong precedence. Pag-unawa nangunguna sa operator at pakikisama ay mahalaga kapag nagdidisenyo ng mga kumplikadong programa, at nakakatulong ito sa paggawa ng mas malinis at mas mahusay na code na may mas kaunting mga error.