העמסת מתודות

חלק מהיחידה תכנות מונחה עצמים במסלול ה-C# של Coddy. שיעור 50 מתוך 70.

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

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

public static void Print(string message)
{
    Console.WriteLine(message);
}

public static void Print(string message, int times)
{
    for (int i = 0; i < times; i++)
        Console.WriteLine(message);
}

public static void Print(int number)
{
    Console.WriteLine(number);
}

// המהדר בוחר את הגרסה המתאימה
Print("Hello");           // קורא ל־Print(string)
Print("Hi", 3);           // קורא ל־Print(string, int)
Print(42);                // קורא ל־Print(int)

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

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

אתגר

קל

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

תארגנו את הקוד בשני קבצים:

Calculator.cs: צרו מחלקה בשם Calculator במרחב השמות MathTools, ובה מתודות מועמסות שמשתפות שמות אך מקבלות פרמטרים שונים:
- Multiply — צרו שלוש גרסאות מועמסות:
  - אחת שמקבלת שני פרמטרים מסוג int ומחזירה את המכפלה שלהם כערך מסוג int
  - אחת שמקבלת שלושה פרמטרים מסוג int ומחזירה את המכפלה שלהם כערך מסוג int
  - אחת שמקבלת שני פרמטרים מסוג double ומחזירה את המכפלה שלהם כערך מסוג double
- Describe — צרו שתי גרסאות מועמסות:
  - אחת שמקבלת ערך מסוג int ומחזירה "Integer: {value}"
  - אחת שמקבלת ערך מסוג double ומחזירה "Double: {value}"
Program.cs: בקובץ הראשי, צרו מופע של Calculator והדגימו כיצד המהדר בוחר אוטומטית את המתודה המועמסת המתאימה על סמך הארגומנטים שאתם מספקים.

תקבלו ארבעה קלטים:

המספר השלם הראשון (לדוגמה, 5)
המספר השלם השני (לדוגמה, 4)
המספר השלם השלישי (לדוגמה, 3)
מספר עשרוני (לדוגמה, 2.5)

באמצעות המחשבון שלכם, בצעו את הפעולות הבאות והדפיסו כל תוצאה בשורה נפרדת:

הכפילו את שני המספרים השלמים הראשונים (משתמש בגרסה שמקבלת שני ערכים מסוג int)
הכפילו את כל שלושת המספרים השלמים (משתמש בגרסה שמקבלת שלושה ערכים מסוג int)
הכפילו את המספר השלם הראשון ואת המספר העשרוני (משתמש בגרסה שמקבלת שני ערכים מסוג double)
תארו את המספר השלם הראשון (משתמש בגרסה שמקבלת ערך מסוג int)
תארו את המספר העשרוני (משתמש בגרסה שמקבלת ערך מסוג double)

לדוגמה, אם הקלטים הם 5, 4, 3 ו-2.5, הפלט צריך להיות:

20
60
12.5
Integer: 5
Double: 2.5

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

נסו בעצמכם

using System;
using MathTools;

class Program
{
    public static void Main(string[] args)
    {
        // קראו את נתוני הקלט
        int firstInt = Convert.ToInt32(Console.ReadLine());
        int secondInt = Convert.ToInt32(Console.ReadLine());
        int thirdInt = Convert.ToInt32(Console.ReadLine());
        double decimalNum = Convert.ToDouble(Console.ReadLine());

        // TODO: צרו מופע של Calculator

        // TODO: קראו ל-Multiply עם שני מספרים שלמים והדפיסו את התוצאה

        // TODO: קראו ל-Multiply עם שלושה מספרים שלמים והדפיסו את התוצאה

        // TODO: קראו ל-Multiply עם המספר השלם הראשון והמספר העשרוני, והדפיסו את התוצאה

        // TODO: קראו ל-Describe עם המספר השלם הראשון והדפיסו את התוצאה

        // TODO: קראו ל-Describe עם המספר העשרוני והדפיסו את התוצאה
    }
}