מבוא לשפות תכנות באמצעות שפת C פרק 7 – אופרטורים Operators

אופרטורים בשפות תכנות הם סמלים כמו "=" או "+", שאומרים למהדר לבצע פעולה מתמטית ספציפית, השוואתית, או לוגית ולספק תוצאה. 

אופרטורים אריתמטיים

תוכנות מחשב משתמשות לא מעט בחישובים מתמטיים. אמנם אין צורך לדעת מתמטיקה ברמה גבוהה כדי ללמוד שפות תכנות, אך יש צורך בהבנה בסיסית לפחות. אנו יכולים לכתוב תוכנית שתחשב לנו חישוב פשוט כמו 5+5, ואנו יכולים גם לכתוב תכניות שיחשבו לנו חישובים מורכבים יותר כמו P(x) = x⁴ + 7x³ – 5x + 9. בחישוב הראשון שהזכרנו(5+5), גם אם אין לנו הבנה גדולה במתמטיקה, אנו יכולים לראות כי סמל הפלוס הוא האופרטור שיאמר למהדר לבצע את החישוב. שימו לב לשני הדוגמאות הבאות:

5+5

P(x) = x4 + 7x3 – 5x + 9

שני המשפטים האלה נקראים בשפות תכנות ביטויים אריתמטיים, כאשר הפלוס והמינוס נקראים בשפות תכנות אופרטורים אריתמטיים והערכים כמו 5,x ו-7 נקראים בשפות תכנות אופרנדים. חישובים כאלו מפיקים בדרך כלל תוצאות נומריות.

בדומה, בשפות תכנות יש מבחר של אופרטורים אריתמטיים. בטבלה הבאה מנינו חלק מהאופרטורים הכי חשובים שקיימים בשפת C. נניח שיש לנו משתנה בשם A המכיל ערך של 10, ומשתנה בשם B המכיל ערך של 20:

לפניכם דוגמה של תוכנית בשפת C אשר משתמשת במגוון האופרטורים לפי הטבלה שמעל.

#include
int main() {
int a, b, c;
a = 10;
b = 20;
c = a + b;
printf( "Value of c = %dn", c);
c = a - b;
printf( "Value of c = %dn", c);
c = a * b;
printf( "Value of c = %dn", c);
c = b / a;
printf( "Value of c = %dn", c);
c = b % a;
printf( "Value of c = %dn", c);
}

וכאשר נריץ תוכנית זו, נקבל את התוצאה הבאה:

אופרטורים השוואתיים

תארו לכם סיטואציה שבה אנו יוצרים שני משתנים, A ו-B ומזינים להם ערכים שונים, כאשר במשתנה A הזנו את הערך 10 ובמשתנה B הזנו את הערך 20, כפי שניתן לראות בדוגמה הבאה:

A = 10
B = 20

ברור לנו שהערך של משתנה A הוא גדול יותר מהערך של משתנה B. אנו נאלץ להיעזר באופרטורים על מנת לערוך השוואה כזו בשפת תכנות. אם נרצה לעשות זאת בשפת C זה ייראה בדיוק כך:

(A>B)

בדוגמה זו השתמשנו באופרטור < שהוא נחשב כאופרטור השוואתי, כאשר לרוב התוצאה שיפיק תהייה בוליאנית, כלומר true – נכון או false – לא נכון.

בשפות תכנות יש מגוון של אופרטורים השוואתיים. בטבלה הבאה מנינו חלק מהאופרטורים ההשוואתיים הכי חשובים שקיימים בשפת C. נניח שיש לנו משתנה בשם A המכיל ערך של 10, ומשתנה בשם B המכיל ערך של 20:

בתכנית הבאה אשר נכתבה בשפת C יש משפט תנאי if, אשר נסביר לגביו בהרחבה בפרק אחר, אך לעת עתה נסביר בקצרה שמשפט תנאי if נועד לבדוק אם התוצאה של ההשוואה נכונה. אם כן, אז התוכנית מוציאה לפועל את הפקודות שנכתבו בתוכן של המשפט תנאי if, אם התוצאה של ההשוואה לא נכונה, התכנית תתעלם מהתוכן של המשפט תנאי if.

#include
int main() {
int a, b;
a = 10;
b = 20;
/*בשורה זו נבדוק אם הערך של a שווה ל-10 */
if( a == 10 ) {
/*אם כן, אז שורה זו תצא לפועל*/
printf( "a is equal to 10n");
}
/* בשורה זו נבדוק אם הערך של b שווה ל-10 */
if( b == 10 ) {
/*אם כן, אז שורה זו תצא לפועל*/
printf( "b is equal to 10n");
}
/* בשורה זו נבדוק אם הערך של a קטן מ-b */
if( a < b ) {
/*אם כן, אז שורה זו תצא לפועל*/
printf( "a is less than bn");
}
/* בשורה זו נבדוק אם הערכים של a ו-b אינם שווים */
if( a != b ) {
/*אם כן, אז שורה זו תצא לפועל*/
printf( "a is not equal to bn");
}
}

לאחר שנריץ את התכנית תתקבל התוצאה הבאה:

כפי שניתן לראות התכנית ביצעה רק את תוכן משפטי ה-if רק כאשר תוצאות ההתניה היו נכונות, כלומר שהתוכנית התעלמה מהתוכן של משפטי ה-if שתוצאת ההתניה שלהם לא היתה נכונה, כפי שניתן לראות במשפט התנאי if שנמצא בשורה 17 בתוכנית שכתבנו.

אופרטורים לוגיים

אופרטורים לוגיים הם אופרטורים חשובים ביותר בשפות תכנות והם עוזרים לנו לקבל החלטות שמבוססות על תנאים מסוימים. נניח וברצוננו לשלב תוצאות של שני תנאים, אנו נאלץ להשתמש באופרטורים לוגיים על מנת שנוכל לעשות זאת.

בטבלה הבאה מנינו את כל האופרטורים  הלוגיים שקיימים בשפת C. נניח שיש לנו משתנה בשם A המכיל ערך של 1, ומשתנה בשם B המכיל ערך של 0:

נסו להריץ את התכנית הבאה על מנת שתוכלו להבין יותר טוב את נושא האופרטורים הלוגיים:

#include <stdio.h>
int main() {
   int a = 1;
   int b = 0;
   if ( a && b ) {
      printf("This will never be printed because condition is falsen" );
   }
   if ( a || b ) {
      printf("This will be printed because condition is truen" );
   }
   if ( !(a && b) ) {
      printf("This will be printed because condition is truen" );
   }
}

כפי שניתן לראות, התוכנית מדלגת מעל תוכנו של משפט ההתניה הראשון שנמצא בשורה 7 משום שהתוצאה שתתקבל ממנו היא false, ולכן יתקבל הפלט הבא:

אופרטורים בשפת Java

זוהי אותה התוכנית שבדקנו באמצעותה את האופרטורים בשפת C, רק שבדוגמה זו התאמנו את התוכנית לשפת Java:

public class Main {
   public static void main(String []args) {
      int a, b, c;
      a = 10;
      b = 20;
      c = a + b;   
      System.out.println("Value of c = " + c );
      c = a - b;
      System.out.println("Value of c = " + c );
      c = a * b;   
      System.out.println("Value of c = " + c );
      c = b / a;   
      System.out.println("Value of c = " + c );
      c = b % a;   
      System.out.println("Value of c = " + c );
      if( a == 10 ) {
         System.out.println("a is equal to 10" );
      }
   }
}

על מנת שנקבל את התוצאה הבאה:

אופרטורים בשפת Python

זוהי אותה התוכנית שבדקנו באמצעותה את האופרטורים בשפת C, רק שבדוגמה זו התאמנו את התוכנית לשפת Python, שימו לב שאנו יוצרים את המשתנים ומזינים להם את הערכים באותה השורה:

a = 10
b = 20
c = a + b   
print ("Value of c = ", c)
c = a - b   
print ("Value of c = ", c)
c = a * b   
print ("Value of c = ", c)
c = a / b   
print ("Value of c = ", c)
c = a % b   
print ("Value of c = ", c)
if( a == 10 ):
   print ("a is equal to 10")

ואז נקבל את הפלט הבא: