מבנים גנריים

חלק מהיחידה תכנות מונחה עצמים במסלול ה-Rust של Coddy. שיעור 24 מתוך 61.

עד כה, לכל המבנים שיצרת היו שדות עם טיפוסים ספציפיים וקונקרטיים. ל־Pet יש שם מסוג String, ול־Rectangle יש ממדים מסוג f64. אבל מה אם תרצה ליצור מבנה שיכול להכיל כל סוג של נתונים?

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

הנה מבנה מעטפת פשוט שיכול להכיל כל סוג:

struct Wrapper<T> {
    value: T,
}

ה־<T> שאחרי שם המבנה מצהיר על פרמטר טיפוס גנרי. בתוך המבנה, T משמש כתחליף לטיפוס שבו תשתמשו בפועל. כשיוצרים מופע, Rust מסיק את הטיפוס הקונקרטי:

let int_wrapper = Wrapper { value: 42 };        // T הוא i32
let float_wrapper = Wrapper { value: 3.14 };    // T הוא f64
let text_wrapper = Wrapper { value: "hello" };  // T הוא &str

כל אחד מאלה הוא טיפוס קונקרטי שונה, Wrapper<i32>, Wrapper<f64> ו-Wrapper<&str>, אבל כולם חולקים את אותה הגדרת struct. כך אין צורך לכתוב structs נפרדים בשם IntWrapper, FloatWrapper ו-StringWrapper, שעושים למעשה את אותו הדבר.

האות T היא רק מוסכמה (קיצור של "Type"). אפשר להשתמש בכל מזהה תקין, אבל T היא הסטנדרט ב-Rust וברוב השפות האחרות שתומכות בגנריות.

אתגר

קל

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

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

container.rs: הגדר מבנה גנרי ציבורי בשם Container<T> עם שדה ציבורי יחיד בשם item מסוג T. המכל הזה צריך להיות מסוגל להכיל כל סוג: מספרים שלמים, מספרים עשרוניים, מחרוזות או כל דבר אחר.
main.rs: הוסף את מודול המכל שלך והדגם את הגמישות שלו על ידי יצירת מכלים שמכילים סוגים שונים של נתונים. תיצור שלושה מכלים ותציג מה כל אחד מהם מכיל.

בקובץ הראשי שלך, צור את המכלים הבאים:

מכל שמכיל ערך של מספר שלם (הקלט הראשון, מפורש כ-i32)
מכל שמכיל ערך עשרוני (הקלט השני, מפורש כ-f64)
מכל שמכיל מחרוזת (הקלט השלישי, נשמר כ-String)

הפלט שלך צריך להציג את התוכן של כל מכל בפורמט הזה:

Integer container: {value}
Float container: {value}
String container: {value}

לדוגמה, עבור הקלטים 42, 3.14 ו-hello:

Integer container: 42
Float container: 3.14
String container: hello

שים לב כיצד אותה הגדרת Container<T> עובדת עבור שלושת הסוגים השונים: זהו כוחן של הגנריות!

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

נסו בעצמכם

mod container;

use container::Container;

fn main() {
    // קראו את שלושת הקלטים
    let mut input1 = String::new();
    std::io::stdin().read_line(&mut input1).expect("Failed to read line");
    let int_value: i32 = input1.trim().parse().expect("Failed to parse integer");

    let mut input2 = String::new();
    std::io::stdin().read_line(&mut input2).expect("Failed to read line");
    let float_value: f64 = input2.trim().parse().expect("Failed to parse float");

    let mut input3 = String::new();
    std::io::stdin().read_line(&mut input3).expect("Failed to read line");
    let string_value = input3.trim().to_string();

    // TODO: צרו שלושה קונטיינרים באמצעות Container<T>
    // 1. קונטיינר של מספר שלם המכיל את int_value
    // 2. קונטיינר של מספר עשרוני המכיל את float_value
    // 3. קונטיינר של מחרוזת המכיל את string_value

    // TODO: הדפיסו את התוכן של כל קונטיינר בפורמט הנדרש
    // Integer container: {value}
    // Float container: {value}
    // String container: {value}
}