הבנת ההשאלה בחלודה

Rust משתמשת בודק השאלה כדי לאכוף את כללי הבעלות שלה ולהבטיח שהתוכניות בטוחות בזיכרון. חוקי הבעלות מכתיבים כיצד Rust מנהלת את הזיכרון מעל הערימה והערימה.

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

מה זה ללוות בחלודה?

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

משך חיים הוא כמה זמן קיים משתנה. תקופות חיים מתחילות ביצירת משתנה ומסתיימות בהרס משתנה. אתה יכול לשאול את הבעלות על משתנה, וכאשר ההתייחסות המושאלת היא מחוץ לתחום, הבעלות חוזרת למשתנה הבעלים. הלוואה היא קצת כמו ה מצביעים שתמצא בשפות כמו C++ ו-Go. אבל מהדר Rust משתמש בבודק ההשאלה כדי להבטיח שהתוכניות בטוחות בזיכרון.

דוגמה להשאלה בחלודה

אתה יכול לשאול את הבעלות על משתנה על ידי הפניה לבעלים באמצעות סמל האמפרסנד (&).

fnרָאשִׁי() {
תן x = חוּט::from("שלום"); // x הוא הבעלים של "שלום"
תן y = &x; // y הפניות x, שואל "שלום"
println!("{}", איקס); 
println!("{}", y)
}

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

fnprint_even(וקטור: &Vec<i32>) {
ל ערכים ב vectr {
אם ערכים % 2 == 0 {
println!("{}", ערכים);
 }
 }
}

ה print_even הפונקציה מתייחסת לוקטור של מספרים שלמים של 32 סיביות כארגומנט שלה. לאחר מכן הוא מדפיס שורות של ערכים שהם כפולות של שניים בווקטור באמצעות for-loop וה-println! מאקרו.

fnרָאשִׁי() {
תן number_vector = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12];
 print_even(&number_vector); // הבעלות מושאלת, לא מועברת
println!("הפונקציה הראשית שומרת על הבעלות על וקטור המספרים{:?}", number_vector)
}

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

הפונקציה העיקרית שומרת על הבעלות על number_vector הוא יכול להמשיך להשתמש בערך במיקום הזיכרון שלו.

שאילת והפניות מוטציות

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

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

לפני ביצוע הפניות הניתנות לשינוי, המשתנה שברצונך לשנות חייב להיות ניתן לשינוי.

fnהסר_ערך(וקטור: &מוטVec<i32>) -> &Vec<i32> {
 vectr.remove(4);
לַחֲזוֹר וקטור
}

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

fnרָאשִׁי() {
תןמוט מספרים = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12];
 remove_value(&מוט מספרים); // התייחסות ניתנת לשינוי כאן
println!("{:?}", nums); 
}

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

שימו לב שהארגומנט הוא הפניה לוקטור שניתן לשינוי.

חשוב להבין בעלות והשאלה

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

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