פרק 7 - פונקציות

בפרק זה נלמד לכתוב פונקציות משלנו ולקרוא להן. פונקציות מחלקות את התוכנית לתתי-משימות, מאפשרות שימוש חוזר בקוד, ומשפרות את קריאות הקוד.

הגדרה: פונקציה היא מקבץ של פקודות המאוגדות תחת שם מזוהה, שניתן לקרוא לו (להפעיל אותו) מתוך חלקים שונים בתוכנית, כדי לבצע משימה מוגדרת. פונקציה יכולה לקבל נתונים (פרמטרים) ויכולה גם להחזיר תוצאה לפונקציה שקראה לה. כבר השתמשנו בפונקציות שקיימות בספריות השפה כגון, ()Console.WriteLine או ()Math.Round, וגם ראינו ש-Main היא פונקציה מיוחדת, שממנה מתחיל הכל.

ריצה של פונקציה:

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

כותרת פונקציה:

בתחביר של C# ו-Java, כתיבת פונקציה נעשית בתוך מחלקה (class). עד שנלמד תכנות מונחה-עצמים, נכתוב פונקציות מסוג סטטי (static) בתוך המחלקה הראשית של התוכנית, לצד הפונקציה Main. התחביר הוא:

[modifier(s)] [return_type(s)] FunctionName([parameter_list])
{
    // גוף הפונקציה: סדרת פעולות שתתבצענה בקריאה לפונקציה
}

חשוב:

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

  • הדרישה היא לא לקנן פונקציות זו בתוך זו אלא במצבים חריגים: החל מ־C# 7 יש אפשרות לפונקציות מקומיות, אך לא נעסוק בכך. פונקציות מקומיות הן הן המאפשרות (בגרסאות החדשות) לכתוב תוכנית בלי שמופיע Program, Main וכל הדברים המסורבלים האלו. כפי שאמרתי בעבר, בכתיבה כזו, אתם כבר בתוך Main וכשאתם כותבים שם פונקציות, אתם נשענים על היכולת לקנן פונקציות.
  • סדר ההגדרות אינו חשוב - ניתן להגדיר פונקציה לפני או אחרי Main - העיקר שההגדרה נמצאת בטווח המחלקה (בשונה מפייתון - שבה פונקציה חייבת להיות מוגדרת לפני כל מי שקורא לה (ולכן גם לפני ה- Main)).
• נקפיד להוסיף את המילה static (כמו בדוגמאות). כשנלמד עצמים נבין מה זה (וזה אחד המושגים שהכי קשה ללמוד).
• הפונקציה מחזירה בדרך כלל ערך אחד. בשלב מתקדם נראה כיצד להחזיר tuple: מקבץ של מספר ערכים.

7.1 פונקציות ללא פרמטרים

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

דוגמא 1: הדפסת שורת כוכביות מספר פעמים — ללא פונקציה

נניח שנרצה להדפיס 3 שורות של כוכביות (בכל שורה 10 כוכביות). נשווה בין שני מימושים: בלי פונקציה ועם פונקציה.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
public static void Main()
{
    // שלוש שורות של 10 כוכביות - מימוש ללא פונקציה
    for (int i = 0; i < 10; i++)
    {   
        Console.Write("*");
    }
    Console.WriteLine();

    for (int i = 0; i < 10; i++)
        Console.Write("*");

    Console.WriteLine();

    for (int i = 0; i < 10; i++)
        Console.Write("*");

    Console.WriteLine();
}

נחזור לדוגמא 1: הדפסת שורת כוכביות מספר פעמים — עם פונקציה

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public static void Print10Stars()
{
    for (int i = 0; i < 10; i++)
        Console.Write("*");

    Console.WriteLine();
}

public static void Main()
{
    // קריאה לפונקציה 3 פעמים
    Print10Stars();
    Print10Stars();
    Print10Stars();
}

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

דוגמה 2: פונקציה ללא קלט המבצעת חישוב

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

1
2
3
4
5
6
7
8
public static void SumEven100()
{
    int sum = 0;
    for (int num = 0; num <= 100; num += 2)
        sum += num;

    Console.WriteLine($"Sum of even numbers 1-100 is {sum}");
}

בדוגמה זו, הפונקציה SumEven100 לא זקוקה לקלט חיצוני - היא יודעת לסרוק את הטווח 1 עד 100 בעצמה ולחשב את הסכום. היעדר פרמטרים מפשט את השימוש בפונקציה (פשוט קוראים ()SumEven100), אך מצד שני הפונקציה אינה גמישה לטווחים אחרים. מה אם נרצה לחשב סכום זוגיים עד 50 או עד 1000? נוכל כמובן לכתוב פונקציה נפרדת לכל טווח, אך זו לא דרך יעילה. כאן, עולה הצורך להגדיר פונקציה גמישה יותר - כזו שמקבלת פרמטרים לשינוי התנהגותה. נעבור כעת לנושא הפרמטרים.

7.2 העברת פרמטרים לפונקציה

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

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

  public static void PrintSum(int a, int b)
  {
    Console.WriteLine($"{a} + {b} = {a + b}");
  }
  

  כעת, בקריאה לפונקציה יש לספק שני ארגומנטים מתאימים, למשל PrintSum(5, 7) ידפיס את השורה \(5 + 7 = 12\). שימו לב שסדר הארגומנטים חייב להתאים לסדר הפרמטרים כפי שהוגדרו. טיפוס כל ארגומנט נבדק בזמן הקומפילציה - אם ננסה להעביר ערך מטיפוס לא תואם, נקבל שגיאת קומפילציה. (החריג הוא מקרה שבו קיים implicit conversion כמו למשל אם נרצה לשלוח int כשמצפים ל-double, אבל לא להיפך).

• פרמטר לעומת ארגומנט: פרמטר הוא חלק מהגדרת הפונקציה (מעין משתנה “תבנית” שהפונקציה מצפה לקבל), ואילו ארגומנט הוא הערך המסוים שאנו מעבירים לקריאה. אפשר לומר שפונקציות מגדירות פרמטרים פורמליים, וכשאנו קוראים להן בפועל אנו מוסרים ערכי ארגומנט. לדוגמה, בפונקציה PrintSum(int a, int b) המשתנים a ו-b הם פרמטרים. בקריאה PrintSum(5, 7) הערכים 5 ו-7 הם הארגומנטים שמועברים לפרמטרים. בכיתה, אני קורא לכולם פרמטרים.
• אני ממליץ להקפיד, לפחות בחלק מהמקרים, על שימוש בשמות שונים ב-Main לארגומנט ובפונקציה לפרמטר, כדי להמחיש את הנתק בינהם ברגע העברת הארגומנט. ראו בהמשך הרחבה בנושא העברת ערכים.

דוגמה 3: פונקציה המקבלת פרמטר יחיד (אורך)

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

1
2
3
4
5
6
7
8
9
10
11
12
13
public static void PrintStars(int length)
{
    for (int i = 0; i < length; i++)
        Console.Write("*");
    Console.WriteLine();
}

public static void Main()
{
    PrintStars(5); // *****
    PrintStars(10); // **********
    PrintStars(3); // ***
}

הפונקציה PrintStars מקבלת פרמטר יחיד length. בכל קריאה, הערך שנמסר (ארגומנט) יוכנס למשתנה length ויקבע את מספר הפעמים שהלולאה תרוץ. בתוכנית הדוגמה קראנו לפונקציה עם הערכים 5, 10 ו-3 - ובהתאם הודפסו שורות באורכים מתאימים. כעת הפונקציה גמישה בהרבה: היא יודעת להדפיס שורת כוכביות בכל אורך שנבקש, ללא חזרת קוד. אפשר, כמובן, לשלב כמה פרמטרים. לדוגמה, נכתוב פונקציה שמדפיסה מלבן של כוכביות, עם שני פרמטרים: rows ו-cols הקובעים את ממדי המלבן:

תרגול: כתבו פונקציה PrintRectangle המקבלת שני פרמטרים שלמים - rows (שורות) ו-cols (עמודות), ומדפיסה מלבן כוכביות בגודל המבוקש. לדוגמה, עבור קריאה PrintRectangle(3, 5) הפלט יהיה:

*****  
*****  
*****  

נסו לחשוב כיצד לכתוב זאת (Tip: השתמשו בלולאה מקוננת), לפני שאתם חושפים את הפתרון.

1
2
3
4
5
6
7
8
9
public static void PrintRectangle(int rows, int cols)
{
    for (int i = 0; i < rows; i++)
    {
        for (int j = 0; j < cols; j++)
            Console.Write("*");
        Console.WriteLine();
    }
}

1
2
3
4
5
private static void PrintRectangle(int v1, int v2)
{
    for (int i = 0; i < v1; i++)
        PrintStars(v2); //prints a row
}

public static void SayHello(string userName)
{
    Console.WriteLine($"Hello, {userName}!");
}

בקריאה SayHello("Dan") תודפס ההודעה Hello, Dan!. בצורה דומה אפשר לקבל בפרמטרים קלטים מטיפוס double (למספרים ממשיים), char (לתו בודד) וכדומה, או לשלב מספר פרמטרים מסוגים שונים. לדוגמה, פונקציה המקבלת שם וכמות: PrintNameMultiple(string name, int times) שתדפיס את השם מספר פעמים לפי הערך (הארגומנט) שיועבר לפרמטר השני.

• הרחבה בנושא העברת ערכים: בשפות כמו C#, ברירת המחדל היא העברה לפי ערך – כלומר, לפונקציה מועבר עותק של הארגומנט. שינוי בפרמטר בתוך הפונקציה לא משפיע על המשתנה המקורי ששלחנו. למשל, אם נקרא ;PrintStars(n) כאשר n הוא 5, הפרמטר length מקבל ערך 5. כאשר נשנה בתוך הפונקציה את הערך של length ל־10, זה לא ישפיע על המשתנה n שמחוץ לפונקציה: ערכו נשאר 5.
• פונקציה יכולה לקבל אפס, אחד או מספר רב של פרמטרים. אם הפונקציה לא זקוקה לקלט חיצוני - פשוט נגדיר סוגריים ריקים (כמו בקטע 7.1). אם היא דורשת כמה ערכים, נגדיר את כולם ברשימת הפרמטרים, מופרדים בפסיקים.
• קיימת גם אפשרות להגדרת ערכי ברירת מחדל לפרמטרים (Default Parameters values) כדי להפוך חלק מהם לאופציונליים - נושא זה נדון בנפרד בסוף הפרק.

absolute = Math.Abs(num);

Console.WriteLine(Math.Abs(num));

if (Math.Sqrt(num) == 10.0)

avg = (Math.Abs(num1) + Math.Abs(num2)) / 2.0;

string name = "Elisabeth";
// LIS הדפסת
Console.WriteLine(name.ToUpper().Substring(1,3));

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

סיכום ביניים 2:

בחלקים 7.1-7.2 למדנו כיצד להגדיר פונקציות ללא ערך חזרה: פונקציות המבצעות פעולה (כגון חישוב או הדפסה) ואינן מחזירות נתון חזרה למקום הקריאה. ראינו דוגמאות לפונקציות שאינן מקבלות פרמטרים וכאלו המקבלות פרמטרים, והדגשנו את היתרון בגמישות שמקנה העברת פרמטרים. בשלב זה כל הפונקציות שהגדרנו היו עם סוג החזרה void. בחלק הבא נרחיב את היכולת של פונקציות ונדון בפונקציות מחזירות ערך: כיצד פונקציה יכולה לחשב ולהחזיר תוצאה למי שקרא לה. זה יאפשר לנו לכתוב פונקציות כמו Max(a,b) שמחזירה את הגדול מבין שני מספרים, IsPrime(n) שמחזירה אמת/שקר אם המספר ראשוני, ועוד.

7.3 העברה וקבלת ערכים מהפונקציה

נחזור לתחביר הבסיסי:

[modifier(s)] [return_type(s)] FunctionName([parameter_list])
{
    // גוף הפונקציה: סדרת פעולות שתתבצענה בקריאה לפונקציה
}

string s = "Hello, World!";
s = s.ToUpper().Replace("WORLD", "C#").Replace("HELLO,", "Go");

סיכום ביניים 3: העברה וקבלת ערכים מהפונקציה

• פונקציות מקבלות פרמטרים, כולל ערכי ברירת מחדל (int n = 0).
• ערך החזרה אינו זורם שמאלה/ימינה, אלא מוחזר ישירות ומיושם במקום הקריאה.
• בשרשור שיטות (כדוגמת s.ToUpper().Replace(...)), ההחזרה נעשית דרך נקודה, ימינה, וכל פעולה מחזירה מצביעה לאובייקט (קיים או חדש).

תרגול

⬅ עברו לתרגול 7.1 - פונקציות void: פעולות ללא פרמטרים

⬅ עברו לתרגול 7.2 - פונקציות המקבלות פרמטרים

⬅ עברו לתרגול 7.3 - פונקציות המקבלות ומחזירות ערך

סרטונים

סרטוני קמפוס פרק 7: פעולות

פלייליסט השתלמות חלק ב