יחידה 7: תבניות (Templates/Generics)

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

תכנות גנרי: הרעיון המרכזי

תכנות גנרי הוא פרדיגמת תכנות המאפשרת לכתוב אלגוריתמים ומבני נתונים באופן שאינו תלוי בטיפוסים ספציפיים. במקום לכתוב פונקציה או מחלקה נפרדת לכל טיפוס נתונים (לדוגמה, פונקציית max עבור int, double, string), אנו כותבים גרסה אחת "כללית" המקבלת פרמטרי טיפוס.

תבניות פונקציה: גמישות מיידית

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

דוגמה: פונקציית max גנרית

במקום לכתוב:

• int max(int a, int b) { return a > b ? a : b; }
• double max(double a, double b) { return a > b ? a : b; }

אנו כותבים תבנית פונקציה אחת:

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

כאשר נקרא ל-max(5, 10), המהדר ייצור מופע של max עבור int. כאשר נקרא ל-max(3.14, 2.71), הוא ייצור מופע עבור double.

תבניות מחלקה: מבני נתונים גנריים

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

דוגמה: מחלקת Stack גנרית

במקום לכתוב IntStack, DoubleStack, אנו כותבים:

template <typename T>
class Stack {
private:
    T* elements;
    int top;
    int capacity;
public:
    Stack(int size) : capacity(size), top(-1) {
        elements = new T[capacity];
    }
    void push(T val) { /* ... */ }
    T pop() { /* ... */ }
    // ...
};

כדי להשתמש במחסנית של מספרים שלמים, נכתוב Stack<int> myIntStack(10);. עבור מחסנית של מחרוזות, Stack<std::string> myStringStack(5);.

היבטים מתקדמים ושיקולי תכנון

פרמטרי טיפוס מרובים ופרמטרים שאינם טיפוס

ניתן להגדיר תבניות עם מספר פרמטרי טיפוס (לדוגמה, template <typename Key, typename Value> class Map { ... };) וכן עם פרמטרים שאינם טיפוס (Non-type template parameters), כגון גודל קבוע (לדוגמה, template <typename T, int N> class Array { T arr[N]; ... };).

typename מול class

המילים השמורות typename ו-class שקולות בהקשר של הגדרת פרמטרי טיפוס בתבנית (לדוגמה, template <typename T> או template <class T>). עם זאת, typename משמשת גם כדי לציין ששם תלוי (dependent name) בתוך תבנית הוא אכן שם של טיפוס, ולא של משתנה או פונקציה.

יתרונות וחסרונות

שאלות לדיון

• הסבירו את ההבדל העיקרי בין שימוש ב-void* לבין שימוש בתבניות לצורך כתיבת קוד גנרי, והדגישו את היתרונות והחסרונות של כל גישה.
• מתי כדאי לשקול שימוש בהתמחות מפורשת (Explicit Specialization) של תבנית מחלקה, ומהם השיקולים שיש לקחת בחשבון?
• כיצד תבניות משפיעות על גודל קובץ ההרצה ועל זמן הקומפילציה, ומהן הדרכים למזער השפעות שליליות אלו?
• תארו מצב בו שגיאת קומפילציה בתבנית פונקציה תהיה קשה במיוחד לאיתור, וכיצד הייתם ניגשים לפתור אותה.

נקודות לתשובת מודל

לשאלה: "הסבירו את ההבדל העיקרי בין שימוש ב-void* לבין שימוש בתבניות לצורך כתיבת קוד גנרי, והדגישו את היתרונות והחסרונות של כל גישה."

• void*: מצביע לכתובת זיכרון ללא מידע טיפוס. מאפשר אחסון והעברת כל טיפוס של נתונים.
  • יתרונות: גמישות מוחלטת, קוד קטן יותר (אין יצירת מופעים נפרדים).
  • חסרונות: חוסר בטיחות טיפוסים מוחלט (Type Safety) - אין בדיקת טיפוסים בזמן קומפילציה, דורש השלכת טיפוסים (casting) ידנית בזמן ריצה, מה שמוביל בקלות לשגיאות זמן ריצה (runtime errors) קשות לאיתור. תקורה של זמן ריצה אם נדרשות בדיקות טיפוסים ידניות.
• תבניות (Templates): מנגנון המאפשר לכתוב קוד עם פרמטרי טיפוס, אשר המהדר יוצר עבורו מופעים ספציפיים לטיפוסים שונים בזמן קומפילציה.
  • יתרונות: בטיחות טיפוסים מלאה (Type Safety) - בדיקת טיפוסים בזמן קומפילציה, מונע שגיאות טיפוסים בזמן ריצה. ביצועים גבוהים (קוד מכונה אופטימלי לכל טיפוס). קוד קריא ונקי יותר.
  • חסרונות: הגדלת זמן קומפילציה וגודל קובץ הרצה (Code Bloat) עקב יצירת מופעים נפרדים לכל טיפוס. הודעות שגיאה מורכבות.
• הבדל עיקרי: תבניות פותרות את בעיית הגנריות בזמן קומפילציה (Compile-time polymorphism), תוך שמירה על בטיחות טיפוסים וביצועים. void* פותר את הבעיה בזמן ריצה (Runtime polymorphism), אך על חשבון בטיחות טיפוסים.