העמסת פונקציות

חלק מהיחידה תכנות מונחה עצמים במסלול ה-C++ של Coddy. שיעור 57 מתוך 104.

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

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

class Calculator {
public:
    int add(int a, int b) {
        return a + b;
    }
    
    double add(double a, double b) {
        return a + b;
    }
    
    int add(int a, int b, int c) {
        return a + b + c;
    }
};

Calculator calc;
calc.add(5, 3);        // קורא ל-add(int, int)
calc.add(2.5, 3.7);    // קורא ל-add(double, double)
calc.add(1, 2, 3);     // קורא ל-add(int, int, int)

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

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

int getValue();
double getValue();  // שגיאה: אי אפשר לבצע העמסה על סמך טיפוס ההחזרה בלבד

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

אתגר

קל

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

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

Formatter.h: הגדירו מחלקה בשם Formatter עם מתודות format() עמוסות, שמטפלות בתרחישים שונים:
- מתודה שמקבלת std::string יחיד ומדפיסה: Message: <text>
- מתודה שמקבלת std::string וערך עדיפות מסוג int, ומדפיסה: [Priority <priority>] <text>
- מתודה שמקבלת std::string וחותמת זמן מסוג double, ומדפיסה: [<timestamp>s] <text>
- מתודה שמקבלת שלושה פרמטרים מסוג std::string (sender, receiver, message) ומדפיסה: From <sender> to <receiver>: <message>
יש לתת לכל המתודות את השם format(): המהדר יבחר את המתודה המתאימה לפי הארגומנטים.
main.cpp: קראו ארבעה קלטים (כל אחד בשורה נפרדת):
1. טקסט פשוט של הודעה
2. רמת עדיפות (מספר שלם)
3. חותמת זמן (מספר מסוג double)
4. שם השולח
צרו אובייקט מסוג Formatter והדגימו את כל ארבע המתודות העמוסות:
- קראו ל־format() עם טקסט ההודעה בלבד
- קראו ל־format() עם טקסט ההודעה ורמת העדיפות
- קראו ל־format() עם טקסט ההודעה וחותמת הזמן
- קראו ל־format() עם השולח, כאשר "Admin" הוא הנמען, ועם טקסט ההודעה

לדוגמה, עם הקלטים System ready, 3, 12.5 ו־Server:

Message: System ready
[Priority 3] System ready
[12.5s] System ready
From Server to Admin: System ready

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

נסו בעצמכם

#include <iostream>
#include <string>
#include "Formatter.h"

using namespace std;

int main() {
    // קראו את הקלטים
    string message;
    getline(cin, message);
    
    int priority;
    cin >> priority;
    
    double timestamp;
    cin >> timestamp;
    cin.ignore();
    
    string sender;
    getline(cin, sender);
    
    // TODO: צרו אובייקט מסוג Formatter
    
    // TODO: קראו ל־format() עם טקסט ההודעה בלבד
    
    // TODO: קראו ל־format() עם טקסט ההודעה ועם priority
    
    // TODO: קראו ל־format() עם טקסט ההודעה ועם timestamp
    
    // TODO: קראו ל־format() עם sender, עם "Admin" כנמען ועם טקסט ההודעה
    
    return 0;
}