אופרטורים וסדר פעולות

סגור באמצעות טופס זה תוכלו לספר ולהמליץ לחבריכם..
שם השולח:
כתובת דוא"ל של השולח:
שם המקבל:
שלח לכתובת דוא"ל:
הוסף הערה:
תהליך העיבוד הנו סדרה של ביטויים (Expressions) מתמטיים (או לוגיים, אבל זה כבר במאמר נפרד). ביטוי מורכב מאופרנדים (אחד או יותר) ואופרטורים (אחד או יותר).



אופרטורים וסדר פעולות אופרטורים 

 
מאת: ארז קלר
 

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

 
sum = num1 + num2;
sub = num1 – num2;
mul = num1 * num2;
div = num1 / num2;

+, -, /, *, = הם אופרטורים.
num1, num2 ו-sum הם אופרנדים.
ישנן כמה משפחות של אופרטורים, במאמר זה נסקור רק שתי משפחות, הראשונה הם האופרטורים המתמטיים, השנייה הם אופרטורי ההשמה.

אופרטורים אריתמטיים – Arithmetic operators

 
אופרטור                  פעולה                 .
+ חיבור  - Addition
- חיסור - Subtraction
* כפל - Multiplication
/ חילוק - Division
% שארית - Modulus
++ קידום באחד מוקדם או מאוחר – Pre or Post Increment
-- חיסור באחד מוקדם או מאוחר – Pre or post Decrement
 
 
את ארבעת האופרטורים הראשונים אתם מכירים מכיתה א, הם אינם דורשים כל הסבר, גם סדר הקדימות ברור ומובן , לא יהיה נועז מדי לקבוע שגם היכולת המופלאה של הסוגריים להתערב ולשנות את סדר הקדימות מוכרת kbuמצוין.
האופרטור החמישי (%) מחשב ומחזיר את השארית של חלוקת מספר שלם במספר שלם אחר.
לדוגמא:
int mod = 27/5;
המשתנה mod יהיה שווה 2.
כל האופרטורים מבצעים את הפעולה (+, -, /, *, %) ורק לאחר מכן את ההשמה (=).
כל חמשת האופרטורים הללו נקראים
אופרטורים בינאריים משום שהם דורשים שני אופרנדים.
דוגמת קוד OperatorSample01:
 1  : class Program 
 2  : { 
 3  :     static void Main(string[] args) 
 4  :     { 
 5  :         int num1 = 120; 
 6  :         int num2 = 30; 
 7  :         int num3 = 17; 
 8  :         int result = (num1 + num2) / num3; 
 9  :         Console.WriteLine("result = " + result); 
 10 :         result = num1 % num3; 
 11 :         Console.WriteLine("modulo = " + result); 
 12 :     } 
 13 : } 

פלט:
פלט התוכנית OperatorSample01

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

 
int num = 10
num++;
 
האופרטור ++
 
 
 
לאחר ביצוע הפעולה ערכו של num יהיה 11 ,
האופרטור ++ הוא שווה ערך לביצוע:  num = num + 1 .

האופרטור --
 
int num = 10;
num--;
 
 
 לאחר ביצוע הפעולה ערכו של num יהיה 9 ,
האופרטור -- הוא שווה ערך לביצוע: num = num - 1 .
 
כל אחד משני האופרטורים ++ ו- -- יכולים להופיע בשתי צורות שימוש:
  1. הראשונה נקראת Post (Post Increment ו- Post Decrement).
  2. השנייה נקראת Pre – (Pre Increment ו- Pre Decrement)
ניתן לרשום את כל אחד משני האופרטורים הללו לפני המשתנה או אחרי המשתנה,
יש לכך משמעות כאשר מתבצעת פעולת השמה.

 
Post Increment ו- Post Decrement
השיטה הזו של הצבת האופרטורים לאחר המשתנה נקראת Post Increment (++) או Post Decrement (--)
Post – מלשון מאוחר.
המשמעות היא, שבניגוד לאופן פעולת האופרטורים כפי שראינו עד כה, קודם תתבצע ההשמה (=) ורק לאחר מכן תתבצע פעולת ההעלאה ב-1 (++) או ההפחתה ב-1 (--).
קוד דוגמה: OpratorSample02

 1  : class Program 
 2  : { 
 3  :     static void Main(string[] args) 
 4  :     { 
 5  :         int num1 = 10; 
 6  :         int num2 = num1++; 
 7  :         Console.WriteLine("num1 = " + num1); 
 8  :         Console.WriteLine("num2 = " + num2); 
 9  :  
 10 :         Console.WriteLine("num2 = " + num2--); 
 11 :         Console.WriteLine("num2 = " + num2); 
 12 :     } 
 13 : } 
בשורה 6 המשתנה num2 יהיה שווה 10, משום שקודם כל התבצעה פעולת ההשמה (הערך 10) ורק לאחר מכן התבצעה פעולת העלאה ב-1 (++).
בשורה 10 יודפס 10, כי קודם כל התבצעה פעולת ההשמה (העברת הערך למתודה במקרה זה) ורק לאחר מכן פעולת ההפחתה (--).

פלט:
פלט תוכנית הדוגמה OperatorSample02

Pre Increment ו- Pre Decrement
הצבת האופרטור ++ לפני המשתנה מכונה  Pre Increment,
הצבת האופרטור – לפני המשתנה מכונה Pre Decrement.
משמעותה היא, שבדיוק כמו פעולת האופרטורים הבינאריים, קודם תבוצע הפעולה (הגדלה או הפחתה ב-1) ורק לאחר מכן תבוצע ההשמה.
 
קוד דוגמה: OpratorSample03

 1  : class Program 
 2  : { 
 3  :     static void Main(string[] args) 
 4  :     { 
 5  :         int num1 = 10; 
 6  :         int num2 = ++num1; 
 7  :         Console.WriteLine("num1 = " + num1); 
 8  :         Console.WriteLine("num2 = " + num2); 
 9  :  
 10 :         Console.WriteLine("num2 = " + --num2); 
 11 :         Console.WriteLine("num2 = " + num2); 
 12 :     } 
 13 : } 
בשורה 6 המשתנה num2 יהיה שווה 11, משום שקודם כל התבצעה פעולת העלאה ב-1 (++)ורק לאחר מכן פעולת ההשמה (הערך 10).
בשורה 10 יודפס 10, כי קודם כל התבצעה פעולת ההפחתה (--) ורק לאחר מכן פעולת ההשמה (העברת הערך למתודה במקרה זה).

פלט:
פלט התוכנית Operatorsample03


אופרטורי השמה – Assignment operators
 
אופרטור                  פעולה                 .
+= כל האופרטורים המוצגים בטבלה זו הינם שילוב
של האופרטורים אשר נסקרו בסעיפים הקודמים,
בשילוב של אופרטור השמה.
בשלב ראשון האופרטורים הללו נראים קצת שונים ומוזרים
אולם עם הניסיון בכתיבת תוכניות ב- C# לא ניתן להבין כיצד ניתן בלעדיהם.
- =
*=
/=
%=
 
 
האופרטור +=  :  ערכו של המשתנה הנמצא משמאל לאופרטור  שווה לערכו המקורי + הערך של המשתנה הנמצא מימין לאופרטור.
האופרטור -=  :  ערכו של המשתנה הנמצא משמאל לאופרטור שווה לערכו המקורי - הערך של המשתנה הנמצא מימין לאופרטור.
האופרטור *=  :  ערכו של המשתנה הנמצא משמאל לאופרטור  שווה לערכו המקורי * הערך של המשתנה הנמצא מימין לאופרטור.
האופרטור /=  :  ערכו של המשתנה הנמצא משמאל לאופרטור שווה לערכו המקורי / הערך של המשתנה הנמצא מימין לאופרטור.
האופרטור %=  :  ערכו של המשתנה הנמצא משמאל לאופרטור שווה לתוצאת השארית של חלוקת ערכו המקורי של המשתנה חלקי הערך של המשתנה הנמצא מימין לאופרטור.
 
לדוגמא:

 
int num = 12;
num += 3;
בדוגמה ערכו num יהיה 15 , המשמעות של הביטוי היא num = num + 15 .

 
int num = 12;
num -= 3;
בדוגמה ערכו של המשתנה num יהיה 9 , המשמעות של הביטוי היא num = num - 3

 
int num = 12;
num *= 3;
בדוגמה ערכו של המשתנה num יהיה 36 , המשמעות של הביטוי היא num = num * 36

 
int num = 12;
num *= 3;
 בדוגמה ערכו של המשתנה num יהיה 4 , המשמעות של הביטוי היא num = num / 3

 
int num = 15;
num %= 4;
בדוגמה ערכו של המשתנה num יהיה 3 , המשמעות של הביטוי היא num = num % 4
  
דוגמת קוד: OperatorSample04

 1  : class Program 
 2  : { 
 3  :     static void Main(string[] args) 
 4  :     { 
 5  :         int num = 10; 
 6  :         num += 15; 
 7  :         Console.WriteLine("num = {0}", num); 
 8  :         num /= 5; 
 9  :         Console.WriteLine("num = {0}", num); 
 10 :         num -= 2; 
 11 :         Console.WriteLine("num = {0}", num); 
 12 :         num *= 10; 
 13 :         Console.WriteLine("num = {0}", num); 
 14 :         num %= 9; 
 15 :         Console.WriteLine("num = {0}", num); 
 16 :     } 
 17 : } 
פלט:
פלט התוכנית OperatorSample04



קיימים עוד משפחות חשובות של אופרטורים:
  • אופרטורים לוגיים (Conditional\Logical operators).
  • אופרטורי השוואה (Relational operators).
אופרטורים לעיבוד סיביות (Bitwise Operators).אבל עליהם נרחיב במאמר אחר.

 
 


 
 
אטארי - מי המלך?
שנות ה-70, מי היה המלך של השכונה? 
זה שאף אחד לא רוצה להרגיז.
הילד שהיה לו אטארי כמובן.
 
אטארי
 

   
 
 
 



 



כל הזכויות שמורות למחבר ©