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

Java וגם ++C תומכות בסוגים שונים של אופרטורים אריתמטיים על מספרים מטיפוס integer ו‑floating point.

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

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

הטבלה הבאה מביאה רשימה של אופרטורים אריתמטיים בינאריים הנתמכים הן ב‑Java והן ב‑++C.

אופרטור תיאור

+                                  חיבור האופרנדים

-                                   החסרת האופרנד הימני מן האופרנד השמאלי

*                                   כפל האופרנדים

/                                   חלוקת האופרנד השמאלי באופרנד הימני

%                                 השארית בחלוקת האופרנד השמאלי באופרנד הימני

חיבור מחרוזות

כזכור, אופרטור החיבור (+) משמש גם לחיבור בין מחרוזות, כפי שניתן לראות בקטע הקוד הבא:

"MyVariable has a value of  " 
                      + MyVariable + " in this program."

אילוץ

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

חיבור מחרוזות ב‑++C

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

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

הן Java והן ++C תומכות באופרטורים האונאריים הבאים.

אופרטור תיאור

+                      לציון ערך חיובי

-                       שלילה, או היפוך הסימן האלגברי

++                    הוספת 1 לאופרנד (תחילי וסופי)

- -                     החסרת 1 מן האופרנד (תחילי וסופי)

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

אופרטורים של יחס ואופרטורים של תנאי (אופרטורים לוגיים)

אופרטור-יחס בינארי

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

אופרטור-יחס ב‑Java מחזיר ערך "אמת" או "שקר" בתור טיפוס boolean.

אופרטור-יחס ב‑++C מחזיר ערך integer, כאשר אפס נחשב כ"שקר" וכל ערך שונה מאפס נחשב כ"אמת".

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

אופרטור מחזיר ערך "אמת" כאשר...

<                      האופרנד השמאלי גדול מן הימני

=<                    האופרנד השמאלי גדול או שווה לימני

>                      האופרנד השמאלי קטן מן הימני

=>                    האופרנד השמאלי קטן או שווה לימני

==                    האופרנד השמאלי שווה לימני

=!                     האופרנד השמאלי שונה מן הימני

ביטויי תנאי

אופרטורים של יחס משמשים לעתים קרובות בביטויי תנאי של הוראות בקרה, כמו:

if(LeftVariable <= RightVariable). . .

המחשה של אופרטור-יחס

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

המחשה של אופרטור-יחס.

/*File relat01.java Copyright 1997, R.G.Baldwin
Illustrates relational operators.

Output is

The relational 6<5 is false
The relational 6>5 is true

*********************************************************/
class relat01 { //define the controlling class
  public static void main(String[] args){ //main method
    System.out.println("The relational 6<5 is " 
      +(6<5));
    System.out.println("The relational 6>5 is " 
      +(6>5));
  }//end main
}//End relat01 class.

/*File relat01.cpp Copyright 1997, R.G.Baldwin
Illustrates the use of relational operators.

The output from this program is:

The relational 6<5 is 0
The relational 6>5 is 1

*******************************************************/

#include<iostream.h>

class relat01 {
public:
  static void classMain(){
    cout << "The relational 6<5 is " << (6<5) << endl;
    cout << "The relational 6>5 is " << (6>5) << endl;
  }//end classMain
};//End relat01 class definition.
//=====================================================//

void main()
{
  //call the class method named classMain
  relat01::classMain();
}//end main

התוכנית הבאה היא תוכנית ++C, המחקה את תוכנית ה‑Java שלמעלה. שים לב שבמקרה זה, במקום להציג true ו‑false, התוכנית מציגה 1 ו‑0. ב‑++C ניתן לסמוך על כך שערך "שקר" יהיה מיוצג תמיד כ‑0, אך לא כן לגבי ערך "אמת", שאינו מיוצג תמיד כ‑1.
התנאי היחיד ב‑++C הוא שערך "אמת" יהיה מיוצג על-ידי מספר שאינו אפס.

אופרטור-תנאי

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

Java וגם ++C תומכות בשלושה אופרטורים כאלה, כפי שניתן לראות בטבלה הבאה.

Operator  Typical Use            Returns true if     
   &&     Left && Right     Left and Right are both true
   ||     Left || Right     Either Left or Right is true
   !      ! Right           Right is false

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

טיפוסי האופרנדים של אופרטור-תנאי

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

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

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

if(PointerVariable) . . .;
else . . .;

הערכת ביטויים משמאל לימין

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

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

(a < b) || (c < d)

אין לבלבל בין & ו‑&&

כמוסבר למטה, האופרטור & ב‑Java הוא bitwise and, ואילו האופרטור | הינו bitwise or.

יש המציינים, שב‑Java ניתן להשתמש באופרטור & כחלופה ל‑&&, ובאופרטור | כחלופה ל‑||,
אם שני האופרנדים הם מטיפוס boolean.

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

שגיאת תכנות נפוצה

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

אופרטור bitwise

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

אחת הפעולות שנתמכת ב‑Java (<<<) אינה נתמכת ב‑++C, וגם ההתנהגות של חלק מן הפעולות אינה זהה בין שתי השפות.

האופרטורים הקיימים ב‑Java מובאים בטבלה הבאה.

Operator   Typical Use         Operation                  

 >>     OpLeft >> Dist      Shift bits of OpLeft right 
                            by Dist bits (signed)  
 <<     OpLeft << Dist      Shift bits of OpLeft left 
                            by Dist bits
 >>>    OpLeft >>> Dist     Shift bits of OpLeft right 
                            by Dist bits (unsigned)
 &      OpLeft & OpRight    Bitwise and of the 
                            two operands
 |      OpLeft | OpRight    Bitwise inclusive or of the 
                            two operands
 ^      OpLeft ^ OpRight    Bitwise exclusive or (xor) of 
                            the two operands
 ~      ~ OpRight           Bitwise complement of the right
                            operand (unary)

איכלוס סיביות שהתפנו בפעולות הזזה

ב‑Java הפעולה המסומנת של הזזה לימין מאכלסת את הסיבית שהתפנתה בסיבית סימן,
בעוד שהזזה לשמאל והזזה בלתי-מסומנת לימין מאכלסים את הסיביות שהתפנו באפסים.

הזזות מסומנות ב‑++C

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

מה קורה לסיביות שהוזזו אל מעבר לקצה?

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

הכלל עבור bitwise and

פעולת bitwise and מתבצעת בהתאם לכלל הקובע ש‑bitwise and של שתי סיביות 1 הוא סיבית 1. התוצאה שתתקבל מכל צירוף אחר של סיביות תהיה סיבית 0.

bitwise inclusive or

לגבי inclusive or, אם אחת משתי הסיביות היא 1, התוצאה תהיה 1. אחרת, התוצאה תהיה 0.

bitwise exclusive or

לגבי exclusive or, אם אחת משתי הסיביות היא 1, אך לא שתיהן, התוצאה תהיה 1.
אחרת, התוצאה תהיה 0. במילים אחרות ניתן לומר, שאם הסיביות שונות התוצאה תהיה 1,
בעוד שאם הן שוות התוצאה תהיה 0.

אופרטור complement

אופרטור complement הופך כל 1 ל‑0 וכל 0 ל‑1.

אופרטור-הַשָׂמָה

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

שימוש באופרטור-הַשָׂמָה עם משתני-הצבעה

עליך להיות זהיר מאוד בשימוש באופרטור-הַשָׂמָה עם משתני-הצבעה ב‑Java. כאשר נערכת הַשָׂמָה של משתנה-הצבעה אחד למשתנה-הצבעה אחר, התוצאה תהיה פשוט שני משתני-הצבעה שמצביעים על אותו האובייקט, ולא שני אובייקטים שונים.

מתודת clone()

אם ברצונך ליצור עותק של אובייקט, תוכל להשתמש לשם כך במתודת clone().

אופרטור-הַשָׂמָה מקוצר

בדומה ל‑++C, Java תומכת ברשימה הבאה של אופרטורֵי-הַשָׂמָה מקוצרים.
אופרטורים אלה מאפשרים לבצע הַשָׂמָה ופעולה נוספת באמצעות אופרטור יחיד.

+=  -=  *=  /=  %=  &=  |=  ^=  <<=  >>=  >>>=

לדוגמה, שתי ההוראות הבאות מבצעות פעולה זהה.

x += y;
x = x + y;

ההתנהגות של כל אופרטורֵי-ההַשָׂמָה המקוצרים הינה על פי אותו עקרון.

שים לב, ש‑++C אינה תומכת באופרטור =<<< משום שאינה תומכת באופרטור <<<.