אופרטורים

מבוא

סטודנטים בקורס הקדמה לתכנות Java אחראים לידיעת והבנת כל החומר בשעור זה

 (חוץ מנושאים ספציפיים ב – C++).

הנושאים הספציפיים ב – C++ מוצעים כחומר משלים לטובת אלו שמכירים כבר C++
ומבצעים הסבה ל – Java.

הקדמה

הצעד הראשון

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

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

אופרטורים

אופרטורים אונאריים ובינאריים

Java ו‑++C מספקות אוסף של אופרטורים, המשמשים לביצוע פעולה על אופרנד אחד או שני אופרנדים. אופרטור המופעל על אופרנד אחד נקרא אופרטור אונארי,
ואילו אופרטור המופעל על שני אופרנדים נקרא אופרטור בינארי.

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

הימני שלו.

אופרטורים מועמסים

נוסף על השימוש ה"רגיל" באופרטורים, ++C מאפשרת גם "להעמיס" אופרטורים.
המשמעות של זה היא, שהמתכנת יוכל להגדיר מחדש את התנהגותו של אופרטור ביחס לאובייקטים מטיפוס חדש ואשר מוגדרים על-ידי התוכנית. Java, לעומת זה, אינה תומכת בהעמסת אופרטורים.

אופרטורים מתוכניות קודמות

הפקודות הבאות ממחישות את השימוש שנעשה בתוכנית Java קודמת בכמה אופרטורים.

int ch1, ch2 = '0';
while( (ch1 = System.in.read() ) != '#') ch2 = ch1;
System.out.println("The char before the # was " 
                                        + (char)ch2);

אופרטורים אלה הם:

=  !=  +  (char)

אופרטור סימן החיבור

מבין האופרטורים הנ"ל יש חשיבות מיוחדת לסימן החיבור (+) ולאופרטור המרת-טיפוס (char). ב‑Java סימן החיבור משמש לביצוע חיבור אריתמטי.

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

אופרטור המרת-טיפוס

אופרטור המרת-טיפוס משמש במקרה זה על מנת להמיר את ערך ה‑integer המאוחסן
במשתנה ch2 מטיפוסint  לטיפוס  character, שיוכל להתחבר עם המחרוזת מצידו השמאלי
של סימן החיבור.

אלמלא זאת, Java היתה ממירה את הערך של משתנה ה‑int לסדרת ספרות המייצגות את הערך המספרי של התו, וזאת משום שהתו מאוחסן במשתנה מטיפוס int.

אופרטורים של ++C מתוכניות קודמות

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

void simple1::classMain(){
  //input and save bytes
  while( (ch1 = getchar()) != '#')
    ch2 = ch1;

השורה הראשונה מכילה את האופרטור scope resolution של ++C (::).
השורה השנייה מכילה מספר אופרטורים של הַשָׂמָה (=) ואופרטור "אינו שווה" לוגי (=!).

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

ישנם אופרטורים רבים המופיעים בתוכניות Java ו‑++C כאחד, ומשתמשים בסימן זהה לשם ביצוע פעולה זהה.

ישנם גם אופרטורים אחרים, כגון האופרטורים scope resolution או insertion
ו‑extraction ב‑++C, אשר אינם חופפים בין שתי השפות.

סימן משותף, פעולה שונה

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

לדוגמה, הסימן + אינו מועמס אוטומטית על מנת לבצע חיבור מחרוזות ב‑++C
(אך ניתן להעמיס אותו במתכוון).

המשותף עם האופרטורים של Pascal

כפי שניתן לשער, אופרטורים רבים ב‑Java משמשים גם ב‑Pascal לביצוע אותן פעולות תוך שימוש בסימן זהה.

אופרטור increment

אופרטור אונארי חשוב ביותר, הקיים הן ב‑Java והן ב‑++C (אך אינו קיים ב‑Pascal),
הוא אופרטור increment (++).

אופרטור זה משמש בסימון תחילי וסופי כאחד. אופרטור increment גורם להגדלת ערך האופרנד ב‑1.

פעולת increment על משתני-מחוון ב‑++C

אופרטור increment מתנהג באופן שונה כאשר הוא מופעל של משתני-מחוון ב‑++C.
מכיוון ש‑Java אינה תומכת במשתני-מחוון, ההבדל אינו רלוואנטי כאן.

אופרטור increment תחילי וסופי

בגירסת התחילית, האופרנד מופיע מימין לאופרטור (X++), ואילו בגירסת הסופית, האופרנד מופיע משמאל לאופרטור (++X).

מה ההבדל בין אופרטור תחילי לסופי?

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

ההתנהגות בגירסת התחילית

בגירסת התחילית של האופרטור, הפעולה מתבצעת על המשתנה לפני שהוא משתתף כערך בביטוי הגדול יותר.

ההתנהגות בגירסת הסופית

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

המחשה של התנהגות האופרטור התחילי והסופי

השימוש בשתי הגירסאות, התחילית והסופית, של אופרטור increment מומחש בתוכנית Java הבאה.

המחשה של השימוש באופרטור increment תחילי וסופי.

/*File incr01.java Copyright 1997, n
Illustrates the use of the prefix and the postfix increment
operator.

The output from the program follows:

a = 5
b = 5
a + b++ = 10
b = 6

c = 5
d = 5
c + ++d = 11
d = 6

*********************************************************/
class incr01 { //define the controlling class
  public static void main(String[] args){ //main method
    int a = 5, b = 5, c = 5, d = 5;
    System.out.println("a = " + a );
    System.out.println("b = " + b );
    System.out.println("a + b++ = " + (a + b++) );
    System.out.println("b = " + b );
    System.out.println();

    System.out.println("c = " + c );
    System.out.println("d = " + d );
    System.out.println("c + ++d = " + (c + ++d) );
    System.out.println("d = " + d );    
  }//end main
}//End incr01 class.  

השוואה של אופרטור increment בין Java ל‑++C

למעשה, אין כל הבדל בהתנהגותו של האופרטור increment בין Java ל‑++C, ועל כן לא מובאת תוכנית ++C להמחשה.

אופרטורים בינאריים וסימון תוֹכִי

אופרטורים בינאריים משתמשים בסימון תוֹכִי, ופירוש הדבר הוא שהאופרטור מופיע בין שני האופרנדים שלו.

התנהגותו הכללית של אופרטור

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

המשמעות של "מוערך כערך" היא שלאחר ביצוע הפעולה, האופרטור והאופרנדים שלו בביטוי מוחלפים בערך המוחזר.

העמסת אופרטורים ב‑++C

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

קטגוריות של אופרטורים

כמה מחברים מחלקים את האופרטורים ב‑Java לקטגוריות הבאות:

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

·       אופרטור-יחס ואופרטור-תנאי (שב‑++C מקובל לכנותם אופרטור-יחס ואופרטור לוגי)

·       אופרטור-השמה