פעולות אריתמטיות קרן כליף.

מצגת בנושא: "פעולות אריתמטיות קרן כליף."— תמליל מצגת:

1 פעולות אריתמטיות קרן כליף

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

3 פעולות חשבוניות ניתן לחשב ביטויים בעזרת הפעולות הבאות: חיבור + חיסור -
חיבור + חיסור - כפל * חילוק / שימו לב: חלוקה ששני מרכיביה שלמים מחזירה את תוצאת השלם של החלוקה 13 / 5 = 2 13.0 / 5 = 2.6 אסור לחלק ב- 0! מודולו % (מחזירה את תוצאת השארית של החלוקה) 13 % 5 = 3 המחלק והמחולק חייבים להיות שלמים 13 % 5.2 לא יתקמפל

4 שימוש בפעולות חשבוניות
שימוש ב- 2% כדי לבדוק האם מספר הוא זוגי 23%2 =1 24%2 =0 25%2 =1 26%2=0 שימוש ב- 10% כדי לקבל את הספרה הימנית של מספר 8%10=8 95%10=5 357%10=7 שימוש ב- 10/ כדי לקצץ אתהספרה הימנית של מספר 8/10=0 95/10=9 357/10=35

5 דוגמא יש לקלוט מהמשתמש מספר המייצג שעה
למשל 1245 מייצג את השעה 12 ו- 45 דקות יש להציג הודעה ברורה מהי השעה לקבלת הדקות: 1245%100 = 45 לקבלת השעות: 1245/100 = 12

6 קדימויות הפעולות כמו בחשבון, קודם מבצעים חישוב שנמצא בסוגריים
אח"כ כפל, חילוק ומודולו ולבסוף חיבור וחיסור במידה ויש כמה פעולות באותה רמת עדיפות החישוב יבוצע משמאל לימין דוגמאות: 1+(4+5)*(2/3)%5 1+(4+5)*(3/2)%5 1+4+5*3/2%5 = 1 = 5 = 7 6 © Keren Kalif

7 ביטוי חשבוני - שימוש ניתן להשתמש בביטוי החשבוני ישירות בתוכנית, או לאחר שמירתו בתוך משתנה #include <iostream> using namespace std; void main() { int n1, n2, sum; cout << "Please enter 2 numbers: "; cin >> n1 >> n2; cout << "The sum is " << n1+n2 << endl; sum = n1 + n2; cout << "The sum is " << sum << endl; } שימוש ישיר בביטוי שימוש בביטוי לאחר שמירתו במשתנה 7 © Keren Kalif

8 הגדלה/הקטנה ב- 1 כדי להגדיל/להקטין משתנה ב- 1: x = x – 1; x = x + 1;
יש לנו סינטקס מיוחד עבור מקרה זה: ++ עבור הגדלת משתנה ב- 1: ++x או x++ -- עבור הקטנת משתנה ב- 1: --x או x-- כלומר: x=x+1; ≡ x++; ≡ x; x=x-1; ≡ x--; ≡ x;

9 הגדלה/הקטנה ב- 1 (2) אבל כאשר משתמשים באופרטור ++ לצורך השמה למשתנה אחר יש הבדלים בין תוצאות הביטויים: y = x+1; ערכו של x לא משתנה בעקבות פקודה זו, y משתנה y = x++; y =++x; אם האופרטור ++ מופיע מימין למשתנה )למשל x++) אז לתוך y נכנס הערך המקורי של x ורק אז ערכו של x גדל: int x = 4; int y = x++; // y=4, x=5 אם האופרטור ++ מופיע משמאל למשתנה )למשל ++x) אז קודם ערכו של x גדל ואז ערכו החדש נכנס לתוך y: int y = ++x; // y=5, x=5 ערכו של x גדל ב-1 בעקבות פקודה זו , y משתנה עבור -- החוקים זהים 9 © Keren Kalif

10 ביטויים מקוצרים כדי להוסיף ערך כלשהו למשתנה ניתן להשתמש בכתיב מקוצר:
y = y+3; ≡ y += 3; ניתן להשתמש בכתיבה מקוצרת זו עבור כל האופרטורים שלמדנו (+ - * / %) דוגמא: x = x*(y+1); x *= y+1; x = x*y+1; ≡ ≠

11 ביטויים מקוצרים - דוגמא
void main() { int n1, n2, n3, n4; n1 = 2; n2 = ++n1; n2 *= n1--; n3 = --n1 * n2--; n3 = (n1 * n2)--; n3 = n4 = n1 - 1; n4 = n1++ + n2++; n3 = (n1++) + (n2++); } int: n1 1 1000 int: n2 8 1004 int: n3 1008 int: n4 1012 int: n1 3 1000 int: n2 10 1004 int: n3 11 1008 int: n4 9 1012 int: n1 2 1000 int: n2 9 1004 int: n3 1008 int: n4 1012 int: n1 1 1000 int: n2 8 1004 int: n3 9 1008 int: n4 ??? 1012 int: n1 ??? 1000 int: n2 1004 int: n3 1008 int: n4 1012 int: n1 2 1000 int: n2 9 1004 int: n3 ??? 1008 int: n4 1012 int: n1 2 1000 int: n2 ??? 1004 int: n3 1008 int: n4 1012 int: n1 3 1000 int: n2 1004 int: n3 ??? 1008 int: n4 1012 //  n2 = n2*n1-- //  doesn’t compile, since -- requires l-value האופרטור ++ מימין תמיד פועל בסוף, אפילו אם הוא בסוגריים!!

12 המרות בין טיפוסים (casting)
יתכן ונרצה לחשב ביטוי המכיל משתנים מטיפוסים שונים, ולכן צריך לדעת איך להתייחס לפעולות על טיפוסים שונים קיימת היררכיה של המרות כך שמשתנים מטיפוסים בעלי עדיפות נמוכה יותר בביטוי מומרים לטיפוס בעל העדיפות הגבוהה ביותר: double float long int char ההיררכיה היא לפי גודל הטיפוס, כך שלא נאבד מידע

13 המרות בין טיפוסים (casting) (2)
ניתן לכתוב ביטוי המכיל טיפוסים שונים, למשל: double res, d1=5.2; int n1=4; res = n1 + d1; נשים לב כי n1 בזיכרון אינו הופך ל- double, שכן ההמרה נעשית באופן זמני בלבד לצורך הערכת הביטוי בדוגמא זו המחשב ממיר את המשתנה n1 ל- double, ואז מבוצעות פעולות החיבור וההשמה 13 © Keren Kalif

14 המרות בין טיפוסים – דוגמא 1
void main() { int n1=5, n2=8; double d0, d1=7; d0 = d1 + n1 / n2; } ראשית מחושב הביטוי n1/n2. מאחר ושני מרכיביו הם int לא מתבצעת המרה. תוצאת ביטוי זה היא 0. הביטוי המחושב כעת הוא חיבור בין double ל- int ולכן ה- int מומר ל- double (0.0) והתוצאה היא 7.0 //  d1 is actually 7.0

15 המרות בין טיפוסים – דוגמא 2
void main() { int n1=5; double d0, d1=7, d2=8.0; d0 = d1 + n1 / d2; } ראשית מחושב הביטוי n1/d2. הפעם n1 מומר ל- double וחלוקת שני ה- double מחזירה הביטוי המחושב כעת הוא חיבור בין double ל- double ולכן אין המרות נוספות והתוצאה היא 7.625

16 המרות בין טיפוסים – דוגמא 3
void main() { int n0; double d1=9, d2=2.0; n0 = d1 / d2 + 5; } ראשית מחושב הביטוי d1/d2 שתוצאתו 4.5 הביטוי הבא המחושב הוא חיבור בין double ל- int שתוצאתו היא 9.5 ערך הביטוי מושם לתוך int ולכן יש המרה מ- double ל- int והתוצאה תהייה 9 חוק ההמרות: נחשב את הביטוי בצד ימין ע"י המרת כל המשתנים לטיפוס הגדול ביותר, ולבסוף נבצע המרת התוצאה לטיפוס שמשמאל

17 המרות בין טיפוסים – דוגמא 4
void main() { int x; char ch = ‘a’; x = ch+3; } מתבצעת המרה מ- char ל- int ולכן תוצאת הביטוי היא ערכו ה- ASCII של ‘a’ (97) + 3  100

18 המרות בין טיפוסים – דוגמא 5
void main() { char ch = ‘a’; int n1=5, n2=7; double d1=2.5; n1 = ch++ + 2; ch = n1+2; n1 = (n1-’a’+3) * d1; n2 *= d1; } //  n1=99, ch=‘b’ //  ch=‘e’ // n1=( )*2.5 = 12 //  n2 = 7*2.5 = 17

19 המרה מכוונת זוהי המרה מכוונת בין הטיפוסים השונים:
(type)<expression> דוגמאות: (int)(2.5+3)  5 (double)(3+2)  5.0 לאופרטור casting יש את הקדימות הגבוהה ביותר לאחר סוגריים (double)x/y עושים המרה של x ל- double ורק אז מבצעים את החילוק

20 המרה מכוונת - דוגמא void main() { int n1=5, n2=6; double d1;
d1 = n1/n2; d1= (double)n1/n2; d1= n1/(double)n2; d1= (double)(n1/n2); n1 = (int)(n2/4.23); } // d1=0 // d1= // d1= 0.0 // n1=1 ההמרה המכוונת אינה הכרחית בדוגמא זו כי בכל מקרה תהייה המרה ל-int, מאחר וזהו הטיפוס שמשמאל, אבל יעלם ה- warning

21 ביטויים לוגיים ביטוי לוגי הינו דרך לבטא יחס בין 2 ביטויים
דוגמאות ליחסים בין ביטויים: גדול, קטן שוויון תוצאת הביטוי היא true/false ניתן להכניס ערכו של ביטוי לוגי לתוך משתנה: אם הביטוי הלוגי החזיר true יוכנס 1 לתוך המשתנה אם הביטוי הלוגי החזיר false יוכנס 0 לתוך המשתנה

22 נשים לב שבבדיקת שוויון יש פעמיים את הסימן שווה (==), לעומת השמה (=)
אופרטורי יחס ושוויון int x=3, y=5, z=5; bool res; קטן מ- > res = x < y; קטן או שווה ל- => res = y <= z; ובאופן דומה פועלים האופרטורים < ו- =< שונה מ- =! res = x != y; res = y != z; שווה ל- == res = x == y; בניגוד להשמה מרובה res = x = y; // res is true // res is false // res is y (true) נשים לב שבבדיקת שוויון יש פעמיים את הסימן שווה (==), לעומת השמה (=)

23 אופרטורי יחס ושוויון (2)
מה תוצאת הביטוי 4 < x < 9 ? מאחר ויש יותר מאופרטור אחד, נעריך את הביטוי משמאל לימין תוצאת הביטוי הראשון תהיה או 0 או 1 (תלוי בערכו של x) כעת יוערך הביטוי השני, שתוצאתו תמיד תהייה 1 (כי 0 או 1 שניהם תמיד קטנים מ – 9) מה תוצאת הביטוי 4 < x < 1 ? תוצאת ביטוי זה אינה ידועה כי לא ידוע ערכו של x

24 אופרטורים לוגיים לפעמים נרצה שערכו של ביטוי יורכב מתוצאתם של כמה ביטויים למשל, כדי לדעת האם 4 < x < 9 צריך לבדוק האם 9>x וגם x>4 וגם &&: יחזיר 1 אם שני הביטויים המרכיבים אותו החזירו true, 0 אחרת או ||: יחזיר 1 אם לפחות אחד משני הביטויים המרכיבים אותו החזירו true, false אחרת דוגמאות: bool res; res = 4<7 && 7 < 9; res = 4<7 && 7 > 9; res = 4<7 || 7 < 9; res = 4<7 || 9 < 7; res = 7<4 || 9 < 7; // res is true // res is false

25 אופרטורים לוגיים (2) כאשר נרצה לקבל את שלילתו של ביטוי מסוים נשתמש באופרטור ! דוגמא: int x=4, y=5; bool res; res = x>y; res = !(x>y); //  res is false //  res is true

26 אופרטורים לוגיים (3) אופרטור בינארי: עובד על 2 ביטויים, יוצר ביטוי לוגי מורכב && || אופרטור אונארי: עובד על ביטוי אחד ! סיכום תוצאות הפעלת האופרטורים על ביטויים לוגיים: a b a&&b a||b !a 1

27 סיכום אופרטורים לוגיים

28 קדימויות אופרטורים - דוגמא
((0 && 1) || 1)  1 (0 && (1 || 1))  0 (0 && 1 || 1)  1 (0 || 1 && 1)  1 0 < 4 == 1 && 5 > 2  1 0 == 4 < 1 && 5 > 2  1 קדימויות האופרטורים ! < <= > >= == != && || ( ) ( ) ( ) ( ) ( ) ( )

29 אופטימיזציות בעת חישוב ביטוי לוגי המכיל אופרטור בינארי (short-circuit evaluation)
כאשר מחשבים ביטוי המכיל && ותוצאת הביטוי הראשון היא false הקומפיילר לא יטרח לבדוק גם את השני כאשר מחשבים ביטוי המכיל || ותוצאת הביטוי הראשון היא true הקומפיילר לא יטרח לבדוק גם את השני כדי להכריח את הקומפיילר לבדוק את כל הביטויים, ללא קשר לתוצאת נשתמש ב- & או ב- | עבור "וגם" או "או" בהתאמה

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