העמסת פונקציות ב-C++: אותו שם, פרמטרים שונים

שם אחד, הרבה גרסאות

לעיתים קרובות צריך את אותה פעולה לסוגים שונים של נתונים: להדפיס int, להדפיס string, להדפיס double. בשפות מסוימות הייתם ממציאים printInt, printString, printDouble. C++ מאפשרת לתת לכולן אותו שם ומבדילה ביניהן לפי הפרמטרים. זו העמסת פונקציות (function overloading).

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

#include <iostream>
#include <string>
using namespace std;

void print(int x) {
    cout << "int: " << x << "\n";
}

void print(double x) {
    cout << "double: " << x << "\n";
}

void print(const string& x) {
    cout << "string: " << x << "\n";
}

int main() {
    print(42);          // int: 42
    print(3.14);        // double: 3.14
    print(string("hi")); // string: hi
}

שלוש פונקציות, שם אחד. כל קריאה נוחתת על הגרסה שטיפוס הפרמטר שלה מתאים לארגומנט. זה מה שגורם ל-std::cout << x לעבוד עם ints, doubles ומחרוזות באותה מידה: operator<< מועמס פעמים רבות.

מה נחשב להעמסה שונה

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

int  area(int side);                 // פרמטר 1
int  area(int width, int height);    // 2 פרמטרים  -> שונה
double area(double r);               // טיפוס שונה -> שונה

void log(string msg, int level);     // הסדר חשוב...
void log(int level, string msg);     // ...ולכן גם זו שונה

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

טיפוס ההחזרה לבד לא מספיק

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

int    convert(double x);   // OK
double convert(double x);   // שגיאה: הגדרה מחדש, רק טיפוס ההחזרה שונה

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

איך overload resolution בוחרת מנצחת

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

1. התאמה מדויקת (לא צריך המרה).
2. קידום (promotion, למשל char או short -> int, float -> double).
3. המרה סטנדרטית (למשל int -> double, double -> int, מצביע למחלקת בסיס).

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

#include <iostream>
using namespace std;

void show(int x)    { cout << "int version\n"; }
void show(double x) { cout << "double version\n"; }

int main() {
    show(5);     // int version  (התאמה מדויקת)
    show(5.0);   // double version (התאמה מדויקת)
    show('A');   // int version  ('A' מקודם char -> int)
}

'A' הוא char, אבל קידום ל-int מדורג מעל המרה ל-double, ולכן נקראת ההעמסה של int. כללי הדירוג האלה הם הסיבה ש-overload resolution בדרך כלל "פשוט עושה את הדבר הנכון", ולפעמים מפתיעה אתכם.

מלכודת העמימות

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

void f(int x);
void f(double x);

f(0L);   // שגיאה: עמום, long -> int ו-long -> double הן המרות באותה דרגה

לא int ולא double הם התאמה מדויקת ל-long, ושתי ההמרות נמצאות באותה דרגה, ולכן הקריאה עמומה. יש שני תיקונים נקיים:

#include <iostream>
using namespace std;

void f(int x)    { cout << "int\n"; }
void f(double x) { cout << "double\n"; }

int main() {
    f(static_cast<int>(0L));  // הסרת העמימות בעזרת המרה -> int
    // או הוספת העמסה עם התאמה מדויקת כמו  void f(long)  שתנצח בבירור
}

הפתעה קשורה: העברת ליטרל מחרוזת. void g(const string&) ו-void g(bool) יתחרו שתיהן על g("hi"), ו-bool עלולה לנצח, כי const char* מומר ל-bool (לא null -> true) בפחות צעדים מאשר בניית std::string. אם אי פעם תראו ליטרל מחרוזת שקורא באופן מסתורי להעמסה של bool, זו הסיבה: הוסיפו העמסה של const char* או const string& שתיקח את ההתאמה המדויקת.

העמסה וארגומנטים ברירת מחדל לא מסתדרים טוב

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

void connect(string host, int port = 8080);   // אפשר לקרוא לה עם ארגומנט אחד
void connect(string host);                     // גם לה אפשר לקרוא עם ארגומנט אחד

connect("localhost");   // שגיאה: עמום, שתיהן מתאימות לארגומנט יחיד

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

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

הבא בתור: Lambdas

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