Slide 1

מבוא למדעי המחשב תירגול 7: פונקציות 1

מה היה שבוע שעבר? לולאות מערכים מערכים דו-ממדיים 2

תוכנייה )call by value( פונקציות העברת פרמטרים ע"י ערך תחום הגדרה של משתנה מחסנית הקריאות 3

פונקציות 4

הגדרה של פונקציה המבנה של פונקציה: בסוגריים: רשימת הפרמטרים )מופרדים בפסיקים ביניהם(. גוף הפונקציה שם הפונקציה הטיפוס המוחזר ע"י הפונקציה מופיע לפני שמה. float delta(float a, float b) { float result = a b; if (result < 0) result = -result; return result; ההוראת return משמשת לקביעת הערך המוחזר על-ידי הפונקציה. משתנה מקומי: קיים רק בתוך הפונקציה, בזמן שהפונקציה פועלת. "נשכח" לאחר סיום פעולת הפונקציה. 5

פקודת return פעולת return מסיימת את הרצת הפונקציה הנוכחית. ההרצה נמשכת מהמקום בו קראנו לפונקציה. הערך שהועבר ל- return הוא הערך שיוחזר לקורא. הפקודה תמיד מחזירה עותק של הערך, אפילו אם נכתוב שם של משתנה. כאשר הפונקציה לא מחזירה ערך )"טיפוס" מוחזר,)void return לא מקבלת ערך )וגם לא הכרחית לכתיבה(. אם בתוך לולאה או מבנה switch מתבצעת פעולת return במקום,break הרצת הפונקציה נגמרת )ולא רק של המבנה!(. 6

דוגמא בדיקת ראשוניות של ערכי ASCII תזכורת מהתרגול הקודם: for (c='a' ; c<='z' ; c++) { is_prime = 1; if (c%2 == 0) continue; for (i=3; i <= (int)sqrt(c); i+=2) { if (c%i == 0) { is_prime = 0; break; if (is_prime) printf("%c is prime\n", c); ASCII בדיקת ראשוניות של מספרים נשים לב שבדיקת הראשוניות אינה ייחודית רק לתווי וניתן להוציאו לפונקציה נפרדת שתפשט את הקוד 7

דוגמא בדיקת ראשוניות של ערכי ASCII for (c='a' ; c<='z' ; c++) { if (isprime(c)) printf("%c is prime\n", c); הקוד החדש: הקוד יותר בקלות. bool isprime(int num) { if (num%2 == 0) return false; for (i=3; i <= (int)sqrt(c); i+=2) { if (num%i == 0) { return false; אם היינו רוצים לבדוק שאלגוריתם הראשוניות עובד, צריך לבדוק רק את פונקציית isprime() return true; חלוקה טובה של הקוד לפי פונקציונאליות עוזרת לקריאות הקוד ומאפשרת בדיקה של 8

הפונקציה main פונקציית ה-() main היא נקודת ההתחלה של כל תוכנית, והיא נקראת ע"י מע' ההפעלה. חתימת הפונקציה: main(); int ביצוע return עם ערך כלשהו מתוך main() מסיים את ריצת התוכנית ומחזיר את אותו ערך למע' ההפעלה. בד"כ נהוג: החזרת 0 בסיום תקין כל ערך אחר בשגיאה 9

הפקודה exit() פקודת exit() מסיימת את ריצת התוכנית מכל נקודה בקוד, גם מחוץ לפונקציה.main() חתימת הפונקציה: exit_code); void exit(int הפקודה מחזירה למע' ההפעלה את המספר שקיבלה )כמו return מתוך )main() שימוש ב-() exit שלא לצורך נחשב כתכנות רע! רצוי לסיים את ריצת התוכנית בצורה מסודרת, מתוך main ע"י.return 10

קריאה לפונקציה על מנת לקרוא לפונקציה, יש לשערך את ערכי הפרמטרים תחילה. ניתן, אך לא הכרחי, להשתמש בערך המוחזר. לדוגמה: ערכי הפרמטרים result = delta(c/2.0,d) * 50; הערך המוחזר 11

חישוב פרמטרים בקריאה לפונקציה delta(tan(cos(0.2)), sin(1.3)) 12

חישוב פרמטרים בקריאה לפונקציה delta(tan(cos(0.2)), sin(1.3)) cos(0.2) 13

חישוב פרמטרים בקריאה לפונקציה delta(tan(cos(0.2)), sin(1.3)) cos(0.2) 0.98 14

חישוב פרמטרים בקריאה לפונקציה delta(tan(0.98), sin(1.3)) 15

חישוב פרמטרים בקריאה לפונקציה delta(tan(0.98), sin(1.3)) tan(0.98) 16

חישוב פרמטרים בקריאה לפונקציה delta(tan(0.98), sin(1.3)) tan(0.98) 1.49 17

חישוב פרמטרים בקריאה לפונקציה delta(1.49, sin(1.3)) sin(1.3) 18

חישוב פרמטרים בקריאה לפונקציה delta(1.49, sin(1.3)) sin(1.3) 0.96 19

חישוב פרמטרים בקריאה לפונקציה delta(1.49,0.96) 20

חישוב פרמטרים בקריאה לפונקציה delta(1.49,0.96) 0.53 21

פרמטרים וערך מוחזר מהם הפרמטרים והערך המוחזר? int gcd(int n, int m); float sin(float number); void print_account(int id, float cash); float get_time(void); void print_table(); ניתן לכתוב גם : float get_time(); int get_temperature(today); 23

סדר חישוב פרמטרים בשפת C לא מוגדר סדר חישוב הפרמטרים לעתים נחשב את הפרמטרים מימין לשמאל ולעתים הפוך מה ידפיס הקוד הבא? int i = 1; int num = max(i++,i--); printf( %d,num); 24

מהן שגיאות הקומפילציה? int min(int a, int b) { if (a > b) return b; void print_value(int m) { printf( Value=%d\n, m); return m; 25

קריאה נכונה לפונקציה איזו מן הקריאות לא חוקיות? מדוע? int gcd(int n, int m); void print_value(int num); int dist(float, float); char get_letter(); הצהרת הפונקציות: j = gcd(j, j); result = print_value(i+1); dist(2.2, 1.5); printf( input: %c\n, get_letter(k)); get_letter; הסוגריים הן אופרטור הפעלת הפונקציה. בלעדיהן זהו שם של משתנה. 26

מהלך ריצה של תוכנית #include <stdio.h> float delta(float a, float b) { float result = a b; if (result < 0) result = -result; return result; int main() { float x, y, d; scanf( %f,&x); scanf( %f,&y); d = delta(x, y); printf( The difference is %f\n, d); return 0; מתחילים את ההרצה מפונקצית main().1 27

מהלך ריצה של תוכנית #include <stdio.h> float delta(float a, float b) { float result = a b; if (result < 0) result = -result; return result; int main() { float x, y, d; scanf( %f,&x); scanf( %f,&y); d = delta(x, y); printf( The difference is %f\n, d); return 0; 1. מתחילים את ההרצה מפונקצית main().2 קריאה לפונקציית,scanf() אשר דואגת להכניס את הערך 2.1 במשתנה x 28

מהלך ריצה של תוכנית #include <stdio.h> float delta(float a, float b) { float result = a b; if (result < 0) result = -result; return result; int main() { float x, y, d; scanf( %f,&x); scanf( %f,&y); d = delta(x, y); printf( The difference is %f\n, d); return 0; 1. מתחילים את ההרצה מפונקצית main().2 קריאה לפונקציית,scanf() אשר דואגת להכניס את הערך 2.1 במשתנה x.3 קריאה נוספת לפונקציית,scanf() אשר מכניסה את הערך 1.5 במשתנה y 29

מהלך ריצה של תוכנית #include <stdio.h> float delta(float a, float b) { float result = a b; if (result < 0) result = -result; return result; int main() { float x, y, d; scanf( %f,&x); scanf( %f,&y); d = delta(x, y); printf( The difference is %f\n, d); return 0;.4 קריאה לפונקציה delta עם 2.1=x ו- y=1.5 30

מהלך ריצה של תוכנית #include <stdio.h> float delta(float a, float b) { float result = a b; if (result < 0) result = -result; return result; int main() { float x, y, d; scanf( %f,&x); scanf( %f,&y); d = delta(x, y); printf( The difference is %f\n, d); return 0;.5 מתחילים את delta() עם 2.1=a ו- b=1.5.4 קריאה לפונקציה delta עם 2.1=x ו- y=1.5 31

מהלך ריצה של תוכנית #include <stdio.h> float delta(float a, float b) { float result = a b; if (result < 0) result = -result; return result; int main() { float x, y, d; scanf( %f,&x); scanf( %f,&y); d = delta(x, y); printf( The difference is %f\n, d); return 0;.5 מתחילים את delta() עם 2.1=a ו- b=1.5.6 הגדרת משתנה מקומי result שמאותחל ל- 0.6.4 קריאה לפונקציה delta עם 2.1=x ו- y=1.5 32

מהלך ריצה של תוכנית #include <stdio.h> float delta(float a, float b) { float result = a b; if (result < 0) result = -result; return result; int main() { float x, y, d; scanf( %f,&x); scanf( %f,&y); d = delta(x, y); printf( The difference is %f\n, d); return 0;.5 מתחילים את delta() עם 2.1=a ו- b=1.5.6 הגדרת משתנה מקומי result שמאותחל ל- 0.6.4 קריאה לפונקציה delta עם 2.1=x ו- y=1.5 33

מהלך ריצה של תוכנית #include <stdio.h> float delta(float a, float b) { float result = a b; if (result < 0) result = -result; return result; int main() { float x, y, d; scanf( %f,&x); scanf( %f,&y); d = delta(x, y); printf( The difference is %f\n, d); return 0;.5 מתחילים את delta() עם 2.1=a ו- b=1.5.6 הגדרת משתנה מקומי result שמאותחל ל- 0.6.7 הפונקציה מסתיימת ומחזירה את ערכו של המשתנה result.4 קריאה לפונקציה delta עם 2.1=x ו- y=1.5 34

מהלך ריצה של תוכנית #include <stdio.h> float delta(float a, float b) { float result = a b; if (result < 0) result = -result; return result; int main() { float x, y, d; scanf( %f,&x); scanf( %f,&y); d = delta(x, y); printf( The difference is %f\n, d); return 0;.5 מתחילים את delta() עם 2.1=a ו- b=1.5.6 הגדרת משתנה מקומי result שמאותחל ל- 0.6.7 הפונקציה מסתיימת ומחזירה את ערכו של המשתנה result.8 ערך החזרה של הפונקציה מוחזר לנקודה ממנה נקראה והוא נשמר במשתנה d 35

מהלך ריצה של תוכנית #include <stdio.h> float delta(float a, float b) { float result = a b; if (result < 0) result = -result; return result; int main() { float x, y, d; scanf( %f,&x); scanf( %f,&y); d = delta(x, y); printf( The difference is %f\n, d); return 0; 9. ערכו של d מודפס למסך 36

מהלך ריצה של תוכנית #include <stdio.h> float delta(float a, float b) { float result = a b; if (result < 0) result = -result; return result; int main() { float x, y, d; scanf( %f,&x); scanf( %f,&y); d = delta(x, y); printf( The difference is %f\n, d); return 0; הפונקציה Main() מחזירה את הערך 0 למערכת ההפעלה 37.10

הצהרת פונקציות בעיה הקומפיילר קורא את הקוד מההתחלה לסוף ומנסה להבין היכן מתבצעת על קריאה לפונקציה: ()f הוגדרה אחרי ()g למרות שנעשה בה שימוש ב-() f נקבל שגיאה האומרת ש-() g בקריאה מ-() f 38 int f(int x) { return g(x) + 1; int g(x) { return x * -1; אינה מוכרת error: implicit declaration of function 'g'

הצהרת פונקציות פתרון א' נהפוך את סדר כתיבת הפונקציות הפונקציה הנקראת תיכתב לפני הפונקציה הקוראת האם הפתרון יעבוד תמיד? int g(x) { return x * -1; int f(int x) { return g(x) + 1; 39

הצהרת פונקציות בעיה לא ניתן ליישם את הפתרון עבור פונקציות עם קריאה מעגלית int g(x) { if (x <= 0) x = f(x); return x * -1; int f(int x) { return g(x) + 1; 40

הצהרת פונקציות פתרון ב' נצהיר על הפונקציות לפני מימושן. חייבים ";" בסוף השורה ההצהרה מדווחת לקומפיילר על קיומן של הפונקציות לפני המימוש. לעיתים אף מייצאים את ההצהרות לקובץ header אין צורך לרשום את שמות המשתנים. נפרד int g(int x); int f(int); int g(int x) { if (x <= 0) x = f(x); return x * -1; int f(int x) { return g(x) + 1; 41

העברת פרמטרים ע"י ערך )call by value( 42

פונקציות עם פרמטרים פרמטרים הם משתנים: המוגדרים בתחילת הפונקציה ומשתחררים בסופה הם מקבלים את ערכיהם בהתאם לערכים שאיתם הפונקציה נקראת שינוי ערכיהם של הפרמטרים אינו משפיע על משתנים מחוץ לפונקציה אלו הם עותקים של הערכים איתם נקראה הפונקציה 43

חישוב הפרמטרים בקריאה לפונקציה מה קרה בעצם כאשר חישבנו?delta(x,y) x y d 2.1 1.5 0.6? d d = d = delta(2.1, 0.6; = delta(x, 1.5); y); בשפת C, מעבירים ערכים לפרמטרים ולא את המשתנים עצמם! 44

פרמטרים וערכים מהם ערכי המשתנים לאחר קריאה ל- max? פונקצית :max int max(int a, int b) { int res; if (a > b) { res = a; a = b; else { res = b; b = a; return res; קריאה ל- max מפונקצית :main פרמטרים הערכים שבתוך המשתנים מועברים לפונקציה int x = 7, y = 8, d; d = max(x, y); int a = 7, y = 8, d; d = max(a, y); int a = 7, b = 8, d; d = max(a, b); int a = 7, b = 8, res; res = max(a, b); 45

תחום הגדרה של משתנה 46

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

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

חלוקת קוד עם בלוקים - דוגמא void do_something(char ch) { printf( What should I do with %c?\n, ch); int main() { char ch; while(ch=getchar()!= EOF) { if((ch >= a ) && (ch <= z )) { do_something(ch); { printf( This is just a silly block ); return 0; 49

משתנים מקומיים משתנים מקומיים הם משתנים: החיים מרגע הגדרתם ועד סוף הבלוק בהם הוגדרו נגישים בבלוק בהם הוגדרו ובכל בלוק פנימי למעשה כל המשתנים שראינו עד כה הם משתנים מקומיים: משתנים שהוגדרו ב-() main משתני אטרציה שהוגדרו בלולאות for פרמטרים של פונקציות או בכל פונקציה אחרת 50

משתנים מקומיים מה תדפיס התוכנית הבאה? #include <stdio.h> int main() { int a; for (int i = 0; i < 10; i++) { int temp = 0; temp++; a = temp; printf( %d, a); return 0; 51

הסתרה של משתנים מה תדפיס התוכנית הבאה? #include <stdio.h> int main() { int a = 10; if (a > 0) { int a = 0; printf( %d\n, a); printf( %d, a); return 0; 52

הסתרה של משתנים משתנה מבלוק פנימי מסתיר משתנה מבלוק חיצוני אם הם בעלי אותו שם. int main() { int a = 10; if (a > 0) { float a = 0.0; printf( %f\n, a); printf( %d, a); return 0; ההסתרה אינה תלויה בטיפוס, רק בשם. קוד המשתמש בהסתרה עשוי להיות מבלבל. לכן, מומלץ להימנע מכך! 53

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

דוגמה - מה תדפיס התוכנית? void ring() { static int count; count++; for (int i = 0; i < count; i++) printf( dring ); printf( \n ); int main() { for (int i = 0; i < 3; i++) ring(); return 0; dring dring dring dring dring dring 56

משתנים גלובאליים משתנים גלובאליים הם משתנים החיים מרגע תחילת התוכנית ועד סופה נגישים מכל נקודה בתוכנית, החל מנקודת הגדרתם. מוגדרים מחוץ לכל בלוק. בפרט, מחוץ ל-() main. void g() { int x = 3; int f() { int main() { משתנה גלובאלי המשתנה x איננו מוכר כאן המשתנה x מוכר בכל הפונקציות שבחלק הזה 57

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

דוגמה: שימוש במשתנים גלובליים #include <stdio.h> int lights_on = 0; /* Global variable */ void flip_lights() { lights_on =!lights_on; void print_light_status() { if (lights_on) printf( Lights are on. ); else printf ( Lights are off. ); מה תדפיס התוכנית הבאה? int main() { int lights_on = 1; /* Local variable */ flip_lights(); print_light_status(); return 0; 59

סיכום: השוואה בין משתנים סוג משתנה מקומי סטטי גלובאלי טווח הכרה זמן חיים אתחול מהגדרתו עד סוף הבלוק בו הוגדר מהגדרתו עד סוף הבלוק בו הוגדר מהגדרתו בכל הפונקציות בתוכנית מהגדרתו עד סוף הבלוק בו הוגדר מתחילת התוכנית ועד סופה מתחילת התוכנית ועד סופה בהגעה להגדרתו בתחילת התוכנית בתחילת התוכנית 60

מחסנית הקריאות 61

דע מאין באת ולאן אתה הולך התוכנית מתחילה בפונקציה.main() ()f. מפעילה פונקציה אחרת, נניח main ()g. מפעילה פונקציה אחרת, נניח ()f וכן הלאה... כיצד יודעת התוכנית לאן לחזור כשכל פונקציה מסתיימת? למשל, כש- g מסתיימת, כיצד יודעת התוכנית לחזור ל- f ולא ל- main? 62

דע מאין באת ולאן אתה הולך למשל, הנה קטע תוכנית: int delta_age; int delta_height; delta_age = delta(age1, age2); delta_height = delta(height1, height2); הפונקציה delta נקראת כאן פעמיים. בכל פעם, לאחר שהפונקציה מסתיימת, התוכנית ממשיכה ממקום אחר. איך זה קורה? 63

מחסנית הקריאות במהלך ריצת התוכנית, המערכת מנהלת מחסנית של קריאות. המחסנית מנוהלת בשיטת Last-In-First-Out )ומכאן שמה(. על המחסנית נשמרים הנתונים הבאים: לאן לחזור לאחר סיום הפונקציה. ערכי הפרמטרים שהועברו לפונקציה. משתנים לוקאליים של הפונקציה. 64

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

int sum; מחסנית הקריאות: דוגמה int readnum() { int num; static int total; if (scanf("%d",&num) < 1) return -1; total++; sum += num; return total; Globals Stack int main() { int status = 0; do { status = readnum(); while(status < 2 && status!= -1); printf("sum = %d\n", sum); return 0; 66

int sum; מחסנית הקריאות: דוגמה int readnum() { int num; static int total; if (scanf("%d",&num) < 1) return -1; total++; sum += num; return total; Globals total=0 sum=0 Stack int main() { int status = 0; do { status = readnum(); while(status < 2 && status!= -1); printf("sum = %d\n", sum); return 0; status=0 67

int sum; מחסנית הקריאות: דוגמה int readnum() { int num; static int total; if (scanf("%d",&num) < 1) return -1; total++; sum += num; return total; Globals total=0 sum=0 Stack int main() { int status = 0; do { status = readnum(); while(status < 2 && status!= -1); printf("sum = %d\n", sum); return 0; num=? כתובת חזרה מ- readnum() status=0 69

int sum; מחסנית הקריאות: דוגמה int readnum() { int num; static int total; if (scanf("%d",&num) < 1) return -1; total++; sum += num; return total; Globals total=0 sum=0 Stack int main() { int status = 0; do { status = readnum(); while(status < 2 && status!= -1); printf("sum = %d\n", sum); return 0; num=5 כתובת חזרה מ- readnum() status=0 70

int sum; מחסנית הקריאות: דוגמה int readnum() { int num; static int total; if (scanf("%d",&num) < 1) return -1; total++; sum += num; return total; Globals total=1 sum=5 Stack int main() { int status = 0; do { status = readnum(); while(status < 2 && status!= -1); printf("sum = %d\n", sum); return 0; כתובת חזרה מ- readnum() status=0 74

int sum; מחסנית הקריאות: דוגמה int readnum() { int num; static int total; if (scanf("%d",&num) < 1) return -1; total++; sum += num; return total; Globals total=1 sum=5 Stack int main() { int status = 0; do { status = readnum(); while(status < 2 && status!= -1); printf("sum = %d\n", sum); return 0; num=? כתובת חזרה מ- readnum() status=1 77

int sum; מחסנית הקריאות: דוגמה int readnum() { int num; static int total; if (scanf("%d",&num) < 1) return -1; total++; sum += num; return total; Globals total=2 sum=12 Stack int main() { int status = 0; do { status = readnum(); while(status < 2 && status!= -1); printf("sum = %d\n", sum); return 0; כתובת חזרה מ- readnum() status=2 82

int sum; מחסנית הקריאות: דוגמה int readnum() { int num; static int total; if (scanf("%d",&num) < 1) return -1; total++; sum += num; return total; Globals Stack int main() { int status = 0; do { status = readnum(); while(status < 2 && status!= -1); printf("sum = %d\n", sum); return 0; 86