פונקציות - Functions (חלק 2)
if לא מוכר מחוץ ל-if, ומשתנה שנפתח במיין לא מוכר בפונקציה אחרת.num בשתי פונקציות שונות הם שני משתנים נפרדים, בלי שום קשר ביניהם.int times = 1. מי שקורא לפונקציה לא חייב לשלוח את הערך.times: 12. כך אפשר לדלג על פרמטר שיש לו ערך ברירת מחדל ולשלוח ערך לפרמטר מאוחר יותר.Main או אחריה, והמיקום לא משנה, כל עוד היא לא נכתבת בתוך פונקציה אחרת.פרקי ההרצאה: פונקציות - Functions (חלק 2)
תמלול ההרצאה: פונקציות - Functions (חלק 2)
הטקסט המלא של הדקות הראשונות בהרצאה «פונקציות - Functions (חלק 2)» בקורס הווידאו של PracticU – כתוביות בעברית עם זמן התחלה לכל פסקה. כך תוכלו לקרוא ולחפש את הנושאים לפני שמתחילים ללמוד.
בסרטון הקודם הכרנו את עולם הפונקציות, ראינו מה זה פונקציה, איך אנחנו יכולים לבנות פונקציה, לשלוח לה משתנים, לקבל ערך שהוא בדרך כלל יהיה תוצאת חישוב, ומה כל העולם של פונקציות נותן לנו.
בסרטון הזה אנחנו הולכים לראות עוד כמה דברים מעניינים בקשר לפונקציות. הדבר הראשון שאנחנו הולכים לראות נקרא טווח הכרה, או באנגלית סקופ.
טווח הכרה מדבר על אם אנחנו הגדרנו משתנה, היכן המשתנה מוכר. איפה אפשר להשתמש איתו? אז קודם כל יש לנו כאן את התוכנית שמתחילה מהמיין ואנחנו יודעים שאנחנו יכולים להגדיר משתנים במיין.
לדוגמה in X. איפה אני בדיוק יכול להשתמש ב-X? אז התשובה היא שמשתנה מוכר מהנקודה שבה הוא הוגדר ועד לסוף הבלוק שבו הוא הוגדר.
זאת אומרת אם אני נמצא בתוך המיין ואנחנו יודעים שהמיין מתחיל מכאן ומסתיים לכאן, פתיחת סוגריים מסולסלות וסגירה בעצם בלוק אז x מוכר מהנקודה הזאת ועד לסוף הבלוק הזה זה אומר שאני יכול פה להכניס לx ערך ואחר כך אני כמובן יכול להשתמש ולהדפיס אותו בואו נריץ ונראה שיש לנו פה את הערך המודפס האם אני יכול להשתמש עם x כאן תשובה לא כי אני נמצא לפני המקום שבו הוא הוגדר
אבל מה זאת אומרת בתוך הבלוק אז יש לנו אפשרות נניח לבצע דבר כזה אם אני נמצא כרגע באיזשהו תנאי אם x קטן שווה ל-1000 שהתשובה היא במקרה הזה כן אני רוצה להדפיס את הx האם מותר לי להשתמש בx בתוך הבלוק הזה והתשובה כן מפני שאני נמצא אחרי ההגדרה של x ואני נמצא בתוך הבלוק שבו x הוגדר x הוגדר בבלוק של המיין אני נמצא פה בתוך הבלוק של המיין ולכן מותר
לי אבל אם אני מגדיר כאן משתנה y אז כאן כמובן אני יכול להשתמש איתו כי אני נמצא בתוך בלוק שבו הגדרתי את y בואו נדפיס את y ונראה שכעת y מודפס אבל אם אני רוצה כאן להדפיס את y אני רואה שכבר המערכת לא מצליחה לאתר אותו בחלון ההצעות שנפתח חלון ההצעות נקרא IntelliSense ואני לא רואה אותו וכמובן שזאת שגיאה אנחנו יכולים לראות שקיבלנו על הדבר הזה שגיאה והוא כותב לנו
the name y does not exist in the current context כלומר בהקשר המקומי. אז למה אנחנו לא מצליחים להשתמש פה ב-y? מפני ש-y הוגדר בתוך הבלוק של ה-if ולכן הוא מוכר עד סוף הבלוק של ה-if כמובן מהנקודה שבה הוא הוגדר.
למה אני מזכיר את הדברים האלה בהקשר של פונקציות? קודם כל גם המיין זה פונקציה. פשוט היא הפונקציה מאוד מיוחדת היא הפונקציה הראשית שמתחילה את התוכנית ומסיימת את התוכנית.
אבל חוץ מהנקודה הזאת זאת פונקציה לכל דבר. עכשיו, אם אנחנו הולכים ומגדירים כאן פונקציה משלנו, נניח שיש לנו פה פונקציה שנקראת do something, ואנחנו עכשיו מגדירים בתוך הפונקציה do something איזשהו משתנה num, אז אנחנו יכולים להשתמש במשתנה num בתוך הפונקציה.
למה? מפני שהחוק אומר ניתן להשתמש במשתנה num מהנקודה שבה הוא הוגדר ועד לסוף הבלוק שבו הוא הוגדר.
אוקיי, אבל האם מותר לי להשתמש? כאן, התשובה כמובן לא. אני כבר רואה שאני לא מצליח לאתר אותו, מפני שאני לא נמצא בתוך הבלוק של הפונקציה.
אז הנושא הזה בעצם נקרא טווח הכרה של משתנים. אם הגדרתם משתנה, איפה הוא מוכר, מה טווח ההכרה שלו, איפה אפשר להשתמש איתו, והחוק תקף גם לפונקציות.
אז מה קורה אם אני מגדיר עכשיו משתנה, נניח בתוך המיין, ואני קורא לו אינקטנאם ובתוך הפונקציה אני מגדיר משתנה, ואני קורא לו int num.
האם מותר לי להפר דבר כזה? האם מותר להגדיר שני משתנים עם אותו השם אם הם נמצאים בשתי פונקציות? אז קודם כל ברור שאם אני מגדיר שני משתנים באותו השם באותו הבלוק, אז כמובן שיש לי פה שגיחה מפני שהמחשב לא יוכל לבצע הבדלה בשני המשתנים.
אבל אם שניהם נמצאים בפונקציות אחרות ופונקציות נפרדות, אז כמובן שאני יכול לבצע את זה. ומה שחשוב להבהיר זה שאלו שני משתנים שונים לגמרי.
המשתנה הזה שמוגדר בתוך הפונקציה do something זה משתנה שנקרא num וטווח ההכרה שלו זה רק בתוך הפונקציה do something אי אפשר להשתמש איתו מחוץ לפונקציה.
המשתנה num שהוגדר בתוך המיין שייך למיין, טווח ההכרה שלו זה רק המיין הוא לא המשתנה שהוגדר בתוך הפונקציה. בואו נראה דוגמה לסיפור הזה. נשים את כל הסיפור הזה בהערה, נשים פה את המשתנה num הזה, נכניס לנאם בתוך המיין אחד אחד, לנאם בתוך הפונקציה שתיים שתיים, נדפיס את נאם שנמצא בתוך המיין,
נקרא לפונקציה do something, נדפיס שוב פעם את נאם בתוך המיין, ובפונקציה נדפיס גם כן את נאם. מה אנחנו אמורים לראות על המסך? אוקיי, כאן אנחנו אמורים לראות כמובן אחד אחד, מפני שהנאם הזה שמודפס פה זה הנאם של המיין.
קראנו לפונקציה, בפונקציה פתחנו נאם חדש והדפסנו אותו, מודפס 22. לאחר מכן הדפסנו שוב פעם את ה-num של המיין והוא יהיה 11. אין שום קשר בין שני המשתנים אפילו ששניהם נקראים num צורך של number כמובן.
בואו נריץ ונראה 11, 22 ואנחנו שוב פעם רואים 11. אז אנחנו רואים שיש משהו שנקרא טווח הכרה או סקופ זה אומר מהו הטווח של המשתנה, איפה ניתן להשתמש איתו, ממתי הוא מוגדר ועד מתי.
כלומר איפה בדיוק אני יכול להשתמש עם המשתנה הזה. בואו נראה דוגמא נוספת, מה היה קורה אם היינו כותבים פה int num? זאת אומרת שעכשיו הפונקציה do something מצפה לקבל מספר.
קודם כל אנחנו רואים שכאן יש לנו טעות, מפני שבאותו טווח הכרה של הפונקציה, באותו הסקופ של הפונקציה, יש שני משתנים שנקראים num, וזה כמובן אסור. אז בואו ניפטר רגע מה-num שהוגדר בתוך הפונקציה, ויש לנו כרגע את ה-num שנמצא בסוגריים של הפונקציה.
זה אומר שאנחנו עכשיו רוצים לשלוח מידע לפונקציה. אז בואו נשלח את ה-num הזה. עכשיו, זאת דוגמה שיכולה לבלבל, מפני שכמובן קודם כל המיין מתחיל והוגדר משתנה בתוך המיין שנקרא num.
שלחנו אותו 1,1. שלחנו בתוכו 1,1. הדפסנו אותו, הוא הודפס פה 1,1. שלחנו את ה-1,1 הזה לתוך הפונקציה שמדפיסה 1,1.
אבל בואו נניח שמעבר לזה שהיא מדפיסה 1,1, או יותר נכון את num, אנחנו הולכים ומשנים את ערכו ל-2,2. אנחנו שוב פעם הולכים להדפיס אותו. האם המשתנה הזה הולך לשנות את המשתנה המקורי?
אז התשובה היא לא. כאן הולך להיות מודפס 1,1. שלחנו 1,1 לפונקציה, אז היא מדפיסה 1,1. אבל המשתנה שנפתח בתוך הפונקציה זה משתנה אחר שנקרא נע"מ, והוא רק מקבל את העותק של המשתנה המקורי, ולכן העותק של המשתנה המקורי, כלומר המספר 1,1, מועתק לעותק נפרד חדש ואחר לגמרי שנמצא בתוך
הפונקציה do something ומקבל את הערך 1-1 לכן כאשר אנחנו משנים אותו כאן אז מה שבעצם משתנה זה סך הכל העותק של המשתנה ופה באמת יודפס 2-2 כאשר אנחנו חוזרים בחזרה המשתנה המקורי לא שונה בכלל ולכן ערכו יהיה שוב פעם 1-1 בואו נסתכל על זה ונראה בדיוק שזה מה שקורה אנחנו רואים שההצגה הראשונה הייתה 1-1, ההצגה השנייה הייתה פה בפונקציה גם 1-1,
אנחנו יכולים לראות את זה כאן. לאחר מכן הפונקציה שינתה את העותק ל-2-2, אבל בגלל שזה עותק וזה שני משתנים שונים, המשתנה שהיה במיין לא שונה כלל וכלל וערכו נשאר 1-1.
אוקיי, אז זה בעצם הקונספט של טווח הכרה. איפה משתנה מוגדר ועד לאן הוא מוכר. וחשוב להבין שבכל אחת מהפונקציות יש משתנה אחר לגמרי שנקרא num, זה לא אותו משתנה.
זה היה אותו הדבר אם הייתי סתם קורא לו לדוגמה a. זה בדיוק אותו הדבר, אלו שני משתנים שונים לגמרי, אנחנו רואים את אותה התוצאה המוצגת על המסך, אין שום קשר ביניהם.
אבל לצורך הדוגמה נשאיר אותו כ-num. מבחינת מונחים, משתנה שמוגדר בתוך פונקציה, בין אם זה בצורה כזאת או בין אם זה בצורה בסוגריים, הוא נחשב משתנה שמוכר רק בתוך הפונקציה שבה הוא הוגדר ולכן הוא נחשב משתנה לוקאלי כלומר מקומי רק לפונקציה שלו אז אלו משתנים לוקאליים אגב גם מחוץ לפונקציה בתוך טווח ההכרה של
הקלאס בתוך הבלוק של הקלאס מותר לנו להגדיר משתנים אבל זה סיפור אחר וזה שייך לעולם האובג'קט אוריינטד אנחנו לא עושים את הדברים האלה בעולם האלגוריתמיקה הפשוטה, בעולם הפונקציות.
רק בעולם התכנות מונחה עצמים יש לזה משמעות, אבל זה לדוגמה כבר לא יהיה משתנה לוקאלי, הוא כבר לא לוקאלי לשום פונקציה. הוא אמור להיות מוכר בייסיקלי על ידי כל הפונקציות שאינן סטטיות.
על זה נדבר כבר במודול של Object Oriented. חזרה למונחים של המשתנים. אז משתנה שמוגדר בתוך פונקציה, בין אם זה בצורה הזאת או בין אם זה בצורה הזאת, זהו משתנה לוקאלי לגבי הפונקציה.
אנחנו יכולים לראות גם שיש פה איזשהו משתנה במיין, אנחנו נדבר עליו באחד הסרטונים הבאים. מונחים נוספים. המשתנה שנשלח בפועל לפונקציה נקרא מבחינת מונח משתנה אקטואלי או ערך אקטואלי, Actual Parameter, כי זה הדבר האמיתי שנשלח לפונקציה.
כאן אנחנו רואים שנשלח המשתנה num, כלומר הערך אחד אחד. אם אנחנו, בעצם זה הכוונה, כי זה נשלח לפונקציה, do something.
אם אנחנו קוראים ל-do something ושולחים לה לדוגמה שמונה, אז שמונה הוא ה-actual parameter, כלומר הדבר, בסופו של דבר האמיתי שנשלח.
משתנה שמתקבל לפונקציה, מעבר לזה שהוא משתנה לוקאלי בתוך הפונקציה, הוא נחשב formal parameter, משתנה פורמלי כי זה מה שהפונקציה מקבלת ועובדת איתו בצורה רשמית וגם מצפה לקבל בצורה רשמית כאשר אנחנו כותבים do something אנחנו פותחים סוגריים אנחנו רואים שכאן שבצורה רשמית פורמל הפונקציה אומרת לנו תביאו לי משתנה והוא נקרא מבחינתי num
אז יש לנו פה בעצם משתנה אקטואלי שנשלח לפונקציה ומתקבל למשתנה פורמלי בפונקציה וכמובן הם יכולים להיות שני ערכים שונים לגמרי או שני משתנים שונים לגמרי כמו שראינו מקודם.
אז יש לנו פה שלושה מונחים משתנה לוקאלי זה משתנה שמוגדר בתוך הפונקציה בין אם זה בצורה כזאת או בין אם זה בצורה כזאת הערך שנשלח לפונקציה זהו משתנה אקטואלי או ערך אקטואלי זה לא חייב להיות משתנה זה יכול להיות גם קבוע והמשתנה שמתקבל לפונקציה נחשב רק מבחינת מונח כן משתנה פורמלי שאיתו הפונקציה עובדת בתוכה.
המונח הבא שאנחנו הולכים ללמוד בעולם הפונקציה זה מונח שנקרא אורך חיים של משתנים. באנגלית זה נקרא Lifetime. אז מה זה בעצם אורך חיים של משתנה?
אורך חיים של משתנים זה פשוט מאוד אומר כמה זמן משתנה חי בזיכרון. מאיזה נקודה הוא נפתח בזיכרון ועד איזה נקודה הוא חי בזיכרון ואז כמובן נהרס.
והתשובה היא מאוד פשוטה. משתנים לוקאליים, אלה שהוגדרו בתוך פונקציה, אורך החיים שלהם הוא כאורך חיי הפונקציה. זאת אומרת שהמשתנה הזה, num, הוגדר במיין.
בגלל שהמיין חיה כל התוכנית, אז num יחיה כל התוכנית. אם אני אגדיר כאן x, אז x יתחיל לחיות כאשר המיין יתחיל, בגלל שהוא נפתח במיין, בעצם זה כאשר התוכנית תתחיל, ויהרס כאשר המיין יסתיים.
אני לא יוכל להגיע אליו מכל מקום, לדוגמה כאן אני לא יכול להשתמש איתו, אלא רק אחרי המקום שבו הגדרתי אותו, אבל עדיין הוא יהיה חי כאן, כלומר הפונקציה איך שהיא מתחילה היא כבר אז שומרת מקום לכל המשתנים גם העתידיים שהולכים להיפתח בתוכה.
אז בגלל זה יש הבדל בין טווח הכרה לבין אורך חיים של משתנים. טווח הכרה אומר איפה אני יכול להשתמש במשתנה, מאיפה הוא מוכר, ואמרנו, רק מהנקודה שבה הוגדר והלאה.
אורך חיים של משתנים זה כמה זמן אתה חי, וזה בעצם רק, זה בעצם לכל אורך חיי הפונקציה. אז אם אנחנו הולכים לכאן, ואנחנו מסתכלים על ה-Num הזה, המשתנה Num שמוגדר בתוך הפונקציה, בין אם זה בסוגריים ובין אם זה משתנה לוקאלי בצורה כזאת, חי כאורך חיי הפונקציה.
זאת אומרת, כאשר אנחנו קוראים לפונקציה, איך שהיא מתחילה להתבצע, הוא נוצר בזיכרון ויותר חשוב הוא נהרס כאשר הפונקציה מסתיימת.
פונקציה הזאת הולכת לפעול שבריר שנייה ולכן המשתנה הזה יחיה שבריר שנייה. אם אנחנו עכשיו הולכים לקרוא לפונקציה עוד פעם do something ושולחים לה 34 אז בעצם למשך שבריר שנייה הפונקציה הזאת הולכת להתבצע.
איך שהיא מתחילה לפעול המשתנה num מתרומם בזיכרון ומתחיל לחיות. כל אורך חיי הפונקציה הוא חי, ברגע שהפונקציה מסתיימת, המשתנה נ"ם נהרס.
זאת אומרת שמיד אחרי הפונקציה כבר המשתנה נ"ם לא יהיה קיים יותר בזיכרון. אז כל המשתנים הלוקאליים של הפונקציה חיים כאורך חיי הפונקציה.
דבר הבא שחשוב להבין בנוגע לפונקציה זה איפה ניתן להגדיר אותה. אנחנו ראינו כבר שבשביל לבנות את הפונקציה יצאנו מחוץ לנין וכתבנו אותה. אז למעשה אנחנו רואים שניתן להגדיר את הפונקציה בתוך הבלוק של הקלאס, לא מחוץ לבלוק של הקלאס ולא בתוך פונקציה אחרת.
אם אני גוזר עכשיו את הפונקציה וזורק אותה כאן, זאת כמובן שגיאה טוטאלית, כי ניסיתי לכתוב את הפונקציה בתוך המיין. אבל אנחנו יכולים להגדיר את הפונקציה גם לפני המיין וגם אחרי המיין.
זאת אומרת, אין חשיבות ואין משמעות למיקום הפונקציות בתוך הקלאס. פשוט נהוג מבחינת סדר הגיוני לכתוב את הפונקציה אחרי הנקודה שמשתמשים איתה.
זאת אומרת שברמת ההיגיון היה יותר הגיוני לכתוב אותה כאן. אבל יש כאלה שאוהבים לכתוב אותה מעל למיקום שבו רוצים להשתמש איתה וזה כבר תלוי בכם מה שיותר נוח לכם.
גם כאן זה בסדר וגם אחרי המיקום שמשתמשים איתה זה בסדר כל עוד היא נמצאת לא בתוך פונקציה אחרת ובתוך הקלאס.
הדבר הבא שאנחנו הולכים לראות נקרא Function Overloading. לצורך כך בואו נבנה פרויקט חדש, יש לנו פה Function Overloading. בעברית המונח הזה נקרא העמסת פונקציות.
להעמיס משהו אומר לכתוב אותו מספר פעמים עם אותו השם. מה הכוונה? בואו נניח שיש לנו פה פונקציה שנקראת Print וכל מה שהיא עושה הוא Printing something.
בואו נקרא לה, נריץ ונראה שהפונקציה מתבצעת. הכל בסדר אבל אנחנו יכולים לכתוב עוד פונקציה שנקראת פרים העיקר שיהיה ביניהם משהו שונה מבחינת החתימה כאשר אנחנו אומרים חתימה אנחנו מדברים בעצם על הפרמטרים שהפונקציה מקבלת למרות שבגדול חתימה של פונקציה קשורה גם לערך המוחזר שלה חתימה זה פשוט הכותרת של הפונקציה. אבל אם
אנחנו רוצים לכתוב שתי פונקציות שונות לגמרי ששתיהן מבצעות את אותה הפעולה הלוגית אז כנראה שאנחנו נרצה ששתיהן תהיינה באותו השם אבל אנחנו רואים שכרגע יש לנו שגיאה וזה גם לא הגיוני שהחתימה תהיה זהה ביניהם היא ובעצם שתי פונקציות שהן בדיוק אותה חתימה והן רוצות שני דברים שונים קצת לא הגיוני לכן ניתן לעשות את זה רק אם
יש משהו שונה בפרמטרים שלהם ומה שיכול להיות שונה בפרמטרים שלהם זה או מספר הפרמטרים שלהם שונה או הטיפוסים של הפרנקלים שלהם שונים, או כמובן גם המספר וגם הטיפוסים.
זאת אומרת, כאן אנחנו רואים שכבר יש לנו פה איזושהי שגיאה, ואם אנחנו עומדים על השגיאה אנחנו רואים שהמערכת בעצם לא יודעת לאיזה פונקציה אנחנו רוצים לקפוץ.
The call is ambiguous, כלומר דו-משמעותי, between the following methods or properties. אז אם אנחנו עכשיו אומרים כזה דבר, רגע, הפונקציה השנייה שאנחנו בונים בעצם היא מקבלת int n כבר אנחנו רואים שיש לנו פה יש לנו אפשרות לעשות את זה ואין לנו שגיאה read pin something n שווה לשרשרת n זאת הפונקציה
השנייה אז השאלה היא לאן תתבצע הקפיצה כאן ואכן ניחשתם נכון הקפיצה תתבצע לפונקציה הזאת מפני שלא שלחתי שום דבר לפונקציה השנייה המערכת יודעת לפי הפרמטרים שנשלחים לאן אני יכול לקפוץ אז פה אנחנו יכולים לראות שהטולטיפ בעצם אומר לנו שיש לנו שתי העמסות לפונקציה הזאת, אנחנו רואים one of two, ואנחנו יכולים לדפדף בין שניהם על ידי לחיצת
העכבר, ולראות בדיוק את שני המקרים של הפונקציות, את שתי העמסות שלה, מה כל אחת מקבלת, ולבחור איזה פונקציה אנחנו רוצים.
אם אנחנו נריץ את זה בצורה כזאת אנחנו רואים שהגענו לפונקציה הראשונה, זאת שלא מקבלת כלום. אם אנחנו נשלח ערך, ואנחנו רואים שהגענו לפונקציה השנייה, אתם