במדריך מפורט זה, נדון באופרטורים בתכנות C ובסוגיהם.
מפעילים וסוגיהם בתכנות C
מפעילים הם הסמלים, המשמשים לביצוע משימות מתמטיות ספציפיות. הם משמשים כדי לתפעל את הנתונים והמשתנים. להלן סוגי האופרטורים השונים בתכנות C:
- אופרטורים אריתמטיים
- Unary Operators
- מפעילי משימה
- אופרטורים לוגיים או בוליאניים
- מפעילים יחסיים
- מפעילים מותנים
- מפעילי Bitwise
1: אופרטורים אריתמטיים
אלו הם האופרטורים המשמשים לביצוע פונקציות מתמטיות בסיסיות כמו חיבור, חיסור או כפל. אתה יכול להשתמש באופרטורים האלה כמעט בכל סוגי הנתונים המובנים של תכנות C. להלן האופרטורים האריתמטיים המשמשים בתכנות C:
| מפעילים | פונקציות |
| + | הוסף 2 אופרנדים |
| – | הורידו 2 אופרנדים |
| * | הכפל 2 אופרנדים |
| / | מחלקים 2 אופרנדים |
| % | אופרטור המודולוס נותן את שאר החלוקה |
דוגמא
בדוגמה למטה, ביצענו את פעולות החשבון הנ'ל על המשתנה X ועל המשתנה Y. המשתנה X מחזיק את הערך 20 ו-Y מחזיק את הערך 5:
#include
int רָאשִׁי ( )
{
int איקס = עשרים ;
int ו = 5 ;
int תוֹצָאָה ;
תוֹצָאָה = איקס + ו ;
printf ( 'הוספה של X ו-Y היא: %d \n ' , תוֹצָאָה ) ;
תוֹצָאָה = איקס - ו ;
printf ( 'חיסור של X ו-Y הוא: %d \n ' , תוֹצָאָה ) ;
תוֹצָאָה = איקס * ו ;
printf ( 'הכפל של X ו-Y הוא: %d \n ' , תוֹצָאָה ) ;
תוֹצָאָה = איקס / ו ;
printf ( 'חלוקה של X ו-Y היא: %d \n ' , תוֹצָאָה ) ;
תוֹצָאָה = איקס % ו ;
printf ( 'חלוקת המודולים של X ו-Y היא: %d \n ' , תוֹצָאָה ) ;
לַחֲזוֹר 0 ;
}
2: מפעילי Unary
ישנם שני אופרטורים אונריים ייחודיים הנתמכים רק על ידי שפת C, הגדלה ++ והקטנת - אופרטורים. אופרטור ההגדלה מוסיף 1 לאופרנד, ואופרטור ההקטנה מפחית 1 מהאופרנד.
אופרטור ההגדלה נכתב כך:
++ א או א ++
אופרטור ההפחתה הוא:
-- א או א --אם נשתמש באופרטור הגדלה והקטנה כתחילית זה קודם מוסיף או מוריד את ערך המשתנה ואז התוצאה מוקצית למשתנה משמאל. אם האופרטורים מתווספים לפני, זה מחזיר תחילה את הערך המקורי ואז האופרנד מתווסף או מופחת ב-1.
דוגמא
להלן הקצינו ערכים לשני משתנים a ו-b והחלנו עליהם אופרטורים של תוספת והפחתה:
#includeint רָאשִׁי ( )
{
int א = חֲמֵשׁ עֶשׂרֵה , ב = 10 ;
printf ( '++a = %d \n ' , ++ א ) ;
printf ( 'a++ = %d \n ' , א ++ ) ;
לַחֲזוֹר 0 ;
}
3: מפעיל משימה
א מפעיל משימה (=) משמש להקצאת הערך למשתנה בתוכנית. להלן מפעילי ההקצאות שהוזכרו:
| מפעילים | פוּנקצִיָה |
| = | הקצה את הערכים לאופרנד |
| += | הוסף את הערך של האופרנד הקיים מימין לאופרנד השמאלי |
| -= | הפחת את הערך של האופרנד הימני מהאופרנד השמאלי |
| *= | הכפל את הערך של האופרנד הימני לאופרנד השמאלי |
| /= | מחלקים את הערך של האופרנד הימני לאופרנד השמאלי |
| %= | קח את המודולוס של שני ערכים והקצה את הערך לאופרנד השמאלי |
דוגמא
הדגמנו את פעולתם של אופרטורי ההקצאה על שני האופרנדים X ו-Y בדוגמה הבאה:
#includeint רָאשִׁי ( )
{
int איקס = 10 ;
int תוֹצָאָה ;
תוֹצָאָה = איקס ;
printf ( 'ערך התוצאה = %d \n ' , תוֹצָאָה ) ;
תוֹצָאָה += איקס ;
printf ( 'ערך התוצאה = %d \n ' , תוֹצָאָה ) ;
תוֹצָאָה -= איקס ;
printf ( 'ערך התוצאה = %d \n ' , תוֹצָאָה ) ;
תוֹצָאָה *= איקס ;
printf ( 'ערך התוצאה = %d \n ' , תוֹצָאָה ) ;
תוֹצָאָה /= איקס ;
printf ( 'ערך התוצאה = %d \n ' , תוֹצָאָה ) ;
לַחֲזוֹר 0 ;
}
4: מפעילים יחסיים
האופרטורים היחסיים משמשים בתכנות C כדי לבדוק את הקשר בין שני משתנים. ניתן להשתמש בו כדי להשוות את המחירים של הפריטים או את גילם של שני אנשים. להלן האופרטורים היחסיים המשמשים בתכנות C:
| מפעילים | פונקציות |
| == | שווה ל |
| > | גדול מ |
| < | פחות מ |
| >= | גדול משווה ל |
| <= | פחות משתווה ל |
| != | לא שווה ל |
דוגמא
הדוגמה להלן מראה את פעולתם של האופרטורים היחסים בתכנות C:
#includeint רָאשִׁי ( )
{
int א = 9 ;
int ב = 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: אופרטורים לוגיים
ישנם ארבעה אופרטורים לוגיים הנתמכים על ידי שפת C:
| מפעילים | פוּנקצִיָה |
| הגיוני AND (&&) | נכון רק אם כל התנאים מתקיימים |
| OR לוגי (||) | אם רק תנאי אחד מקיים התוצאה נכונה |
| הגיוני לא(!) | אם אופרנד הוא 0 התוצאה נכונה |
| לא (~). | הופך את כל הסיביות של האופרנד |
דוגמא
הקוד לדוגמה שלהלן מסביר את פעולתם של האופרטורים הלוגיים ב-C:
#includeint רָאשִׁי ( )
{
int איקס = 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: ביטוי שמוערך אם התנאי נכון.
- הצהרה 2: ביטוי שמוערך אם התנאי הוא שקרי.
דוגמא
בדוגמה שלמטה, הקציתי את הערך למספר ואז החלתי את התנאי, אם התנאי הוא אמת אז משפט 1 יהיה הפלט ואם התנאי הוא שקר אז משפט שני יהיה הפלט:
#includeint רָאשִׁי ( )
{
int מספר = 10 ;
( מספר < עשרים ) ? ( printf ( 'זה פחות ממספר 20!' ) ) : ( printf ( 'זה יותר ממספר 20!' ) ) ;
לַחֲזוֹר 0 ;
}
7: מפעילי Bitwise
מפעילי Bitwise ב-C לתפעל נתונים ברמת הסיביות, כלומר הם פועלים על ביטים בודדים בתוך סוגי נתונים כמו מספרים שלמים. לא ניתן להחיל אותם על הכפול והצף והם משמשים לבדיקת הביטים והסטתם ימינה או שמאלה.
אופרטורים סיביים בתכנות C ניתנים בטבלה שלהלן:
| מפעילים | פוּנקצִיָה |
| & | Bitwise AND |
| | | Bitwise OR |
| ^ | Bitwise בלעדי OR |
| << | העבר שמאלה |
| >> | העבר ימינה |
| ~ | השלמה של אחד |
דוגמא
הדוגמה הבאה מציגה תוכנית C שמשתמשת באופרטורים סיביים:
#includeint רָאשִׁי ( ) {
int א = 13 ; // בינארי 1101
int ב = 7 ; // בינארי 0111
int תוֹצָאָה ;
// Bitwise AND
תוֹצָאָה = א & ב ; // 1101 & 0111 = 0101 (עשרוני 5)
printf ( 'a & b = %u \n ' , תוֹצָאָה ) ;
// Bitwise OR
תוֹצָאָה = א | ב ; // 1101 | 0111 = 1111 (עשרוני 15)
printf ( 'a | b = %u \n ' , תוֹצָאָה ) ;
// Bitwise 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 ' , תוֹצָאָה ) ;
// Bitwise NOT
תוֹצָאָה = ~א ; // ~1101 = 0010 (ייצוג משלים של 2 עשרוני של -14)
printf ( '~a = %d \n ' , תוֹצָאָה ) ;
לַחֲזוֹר 0 ;
}
הערה: אופרטורים של Bitwise משמשים לביצוע משימות ברמת הסיביות, כלומר הם פועלים על ביטים בודדים בתוך מספר בינארי. אופרטורים בוליאניים, לעומת זאת, משמשים לביצוע פעולות על ערכים לוגיים. הם פועלים על פי ערכים בוליאניים (נכון/לא נכון או 1/0) ומשמשים בדרך כלל בתהליכי קבלת החלטות או בהצהרות מותנות.
שורה תחתונה
אופרטור הוא סמל המורה למהדר לבצע פונקציות מסוימות. לשפת C יש מספר אופרטורים מובנים כולל אריתמטי, unary, assignment, logical, relational, conditioned, Boolean ו-bitwise. דנו בהם בפירוט והדגמנו אותם עם הפלט לדוגמה. קרא את החלק שלמעלה במדריך כדי לקבל מידע מפורט על מפעילים אלה.