Templates ב-C++: פונקציות ומחלקות גנריות

כותבים פעם אחת, משתמשים לכל טיפוס

בדף הקודם מיינתם vector<int> עם std::sort. אבל std::sort ממיין גם vector<string>, vector<double> או מערך של structs משלכם, בלי שמישהו כתב sort נפרד לכל אחד. זה לא קסם וזה לא overloading. זה template: קטע קוד אחד שהמהדר משתמש בו מחדש לכל טיפוס שתעבירו לו.

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

int    maximum(int a, int b)       { return a > b ? a : b; }
double maximum(double a, double b) { return a > b ? a : b; }
string maximum(string a, string b) { return a > b ? a : b; }

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

Function templates

הופכים פונקציה ל-template על ידי הוספת template <typename T> לפניה ושימוש ב-T בכל מקום שבו בדרך כלל היה טיפוס קונקרטי.

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

template <typename T>
T maximum(T a, T b) {
    return a > b ? a : b;
}

int main() {
    cout << maximum(3, 7) << "\n";          // 7   (T = int)
    cout << maximum(2.5, 1.1) << "\n";      // 2.5 (T = double)
    cout << maximum(string("apple"),
                    string("banana")) << "\n"; // banana (T = string)
    return 0;
}

שימו לב שאף פעם לא כתבתם maximum<int> או maximum<double>. המהדר מסתכל על הארגומנטים ומבין מה T צריך להיות: זו template argument deduction (הסקת ארגומנטים של template). כל טיפוס שונה שקוראים איתו גורם למהדר לייצר (instantiate) מאחורי הקלעים פונקציה קונקרטית נפרדת.

אפשר לכתוב את הטיפוס במפורש, בסוגריים משולשים, כשההסקה לא יכולה לעזור:

#include <iostream>
using namespace std;

template <typename T>
T zero() {            // אין ממה להסיק: אין ארגומנטים
    return T{};
}

int main() {
    cout << zero<int>() << "\n";     // 0
    cout << zero<double>() << "\n";  // 0
    return 0;
}

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

maximum(3, 7.5);   // שגיאה: T הוא int או double? המהדר מסרב לנחש.

אפשר לתקן את זה בכתיבה מפורשת, maximum<double>(3, 7.5), או במתן פרמטר טיפוס נפרד לכל פרמטר, וזה מה שנעשה עכשיו.

כמה פרמטרי טיפוס

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

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

template <typename A, typename B>
void printPair(A first, B second) {
    cout << first << " -> " << second << "\n";
}

int main() {
    printPair(1, "one");        // A = int, B = const char*
    printPair(3.14, true);      // A = double, B = bool
    printPair("pi", 3.14159);   // A = const char*, B = double
    return 0;
}

כשטיפוס ההחזרה תלוי בפרמטרים, תנו למהדר להבין אותו עם auto (מ-C++14 ומעלה), שמשתלב באופן טבעי עם templates:

#include <iostream>
using namespace std;

template <typename A, typename B>
auto add(A a, B b) {
    return a + b;   // טיפוס ההחזרה מוסק מ-a + b
}

int main() {
    cout << add(2, 3) << "\n";     // 5    (int + int)
    cout << add(2, 3.5) << "\n";   // 5.5  (int + double -> double)
    return 0;
}

Class templates

templates הם לא רק לפונקציות: אפשר להפוך מחלקות שלמות ל-templates. כך בדיוק עובדים הקונטיינרים הסטנדרטיים: vector<int>, ה-map של מפתח וערך ו-pair<A, B> הם כולם class templates. כותבים את מבנה הנתונים פעם אחת, והוא מאחסן כל טיפוס שתגדירו לו כפרמטר.

הנה Box גנרי קטנטן שמחזיק ערך אחד מכל טיפוס:

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

template <typename T>
class Box {
    T value;
public:
    Box(T v) : value(v) {}
    T get() const { return value; }
    void set(T v) { value = v; }
};

int main() {
    Box<int> intBox(42);
    Box<string> wordBox("hello");

    cout << intBox.get() << "\n";   // 42
    cout << wordBox.get() << "\n";  // hello

    intBox.set(100);
    cout << intBox.get() << "\n";   // 100
    return 0;
}

ההבדל המרכזי מ-function templates: עם class template בדרך כלל צריך לספק את הטיפוס בסוגריים משולשים, Box<int>, כי בתקנים ישנים אין ארגומנטים של בנאי להסיק מהם. (C++17 הוסיפה class template argument deduction, כך ש-Box b(42); עובד גם כן, אבל כתיבה מפורשת תמיד בטוחה וקריאה.)

השגיאות יהיו ענקיות, והנה הסיבה

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

template <typename T>
T maximum(T a, T b) {
    return a > b ? a : b;   // דורש ש-T יתמוך באופרטור >
}

struct Point { int x, y; };

// maximum(Point{1,2}, Point{3,4});
// שגיאה: אין operator > ל-Point. ההודעה מזכירה את Point וגם
// מצטטת את כל הפונקציה הזו, ולעיתים קרובות משתרעת על שורות רבות.

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

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

התיקון האמיתי הוא לוודא שהטיפוס שלכם תומך בכל מה שה-template צריך: עבור maximum, זה אומר להעמיס את operator> עבור Point, נושא לדף מאוחר יותר. concepts של C++20 המודרנית יכולים להקדים את השגיאות האלה ולהפוך אותן לקריאות, אבל מודל ההצבה שמתחת נשאר אותו דבר.

הבא בתור: מחלקות

זה עתה בניתם class template בשם Box, מחלקה עם נתונים פרטיים, בנאי ופונקציות חברות, בזמן שהתמקדתם ב-templates. הדף הבא מאט ומלמד מחלקות כמו שצריך: איך מאגדים נתונים עם הפונקציות שפועלות עליהם, מה public ו-private באמת שולטים בו, ואיך פונקציות חברות ניגשות למצב של האובייקט עצמו. templates ומחלקות משתלבים כל הזמן ב-C++ אמיתית, אז שליטה טובה במחלקות הופכת קוד גנרי להרבה יותר קל לכתיבה.