הבנת הסוגים הגנריים של חלודה

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

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

שימוש בסוגים גנריים בחלודה

הסוג הגנרי של חלודה יכול לפעול יחד עם סוגי נתוני חלודה אחרים. תגדיר סוגים גנריים עם סוגריים זווית (<>), ואחריהם שני פרמטרים או יותר.

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

structנְקוּדָה {
// T ו-U הם פרמטרים מהסוג הגנרי ששדות x ו-y יהיו 
// הנחה על מופע
 x: T,
 אתה,
}

בתוך ה נְקוּדָה מבנה, ט, ו U הם פרמטרי סוג גנריים.

אתה יכול להחליף את פרמטרי הסוג הגנריים בכל סוג נתונים במופע:

fnרָאשִׁי() {
לתת my_point = נקודה { x: חוּט::מ("שלום"), y: חוּט::מ("עוֹלָם") };





instagram viewer
println!(
"ערך x של my_point הוא {} וערך y הוא {}.",
 my_point.x,
 my_point.y
 );
}

ה הנקודה שלי משתנה הוא מופע של ה נְקוּדָה struct מאותחל עם סוגי מחרוזות. מהדר Rust מסיק את סוגי הבטון של ט ו U מבוסס על הערכים על מופע.

גבולות תכונה עבור סוגים גנריים

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

גבולות תכונה מציינים שסוג גנרי חייב ליישם תכונה אחת או יותר.

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

// מקסימום היא תכונה המגדירה שיטה להערכת המקסימום של שניים
// סוגים
תְכוּנָהמַקסִימוּם {
fnמקסימום(עצמי, אחר: עצמי) -> עצמי;
}
// מיישם את התכונה 'מקסימום' עבור כל הסוגים שמיישמים את
// תכונת `PartialOrd`.
implPartialOrd> מקסימום ל T {
fnמקסימום(עצמי, אחר: עצמי) -> עצמי {
// החזר `עצמי` אם הוא גדול מ`אחר`; אחרת, לחזור
// `אחר.`
אםעצמי > אחר {
עצמי
 } אַחֵר {
 אַחֵר
 }
 }
}
fnרָאשִׁי() {
לתת א = 5;
לתת ב = 10;
לתת הגדול ביותר = מקסימום:: max (a, b);
println!("הערך הגדול ביותר הוא {}", הגדול ביותר);
}

ה מַקסִימוּם לתכונה יש א מקסימום שיטה המחזירה את הגדול מבין שני הערכים מאותו סוג. כל סוג שמיישם את PartialOrd תכונה מיישמת את מַקסִימוּם תְכוּנָה.

ה מקסימום השיטה לוקחת שני ערכים של עצמי סוג - מתייחס לסוג המיישם את מַקסִימוּם תכונה - ומשווה בין הערכים.

ה רָאשִׁי הפונקציה משווה שני משתנים באמצעות ה- מקסימום שיטה ומדפיס את הגדול ביותר.

אילוצים לסוגים גנריים

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

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

// ToString היא תכונה עם שיטת המרת מחרוזת
תְכוּנָהToString {
fnto_string(&עצמי) -> חוּט;
}
// to_string היא פונקציה גנרית שלוקחת ערך מכל סוג שהוא
// מיישם את התכונה ToString
fnto_stringToString>(ערך: T) -> חוּט {
 value.to_string()
}

ה to_string פרמטר value חייב ליישם את ToString תכונה, המבטיחה שתוכל להמיר ערכי סוג ט לחרוז עם ה to_string שיטה.

סוגים גנריים שימושיים לעבודה עם תכונות

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

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