מהי בעלות בחלודה?

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

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

מהי בעלות?

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

מהדר Rust בודק אם תוכנית מצייתת לכללי הבעלות בזמן ההידור. אם התוכנית פועלת לפי הכללים האלה, היא יכולה לפעול. אם לא, המהדר מסרב לייצר קובץ הפעלה.

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

כללי הבעלות

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

כלל הבעלות הראשון הוא שכל משתנה הוא הבעלים של הערך האתחול שלו.

תן בעלים = חוּט::מאחד");

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

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

תן new_owner = בעלים;

ה בעלים חדשים המשתנה הוא כעת הבעלים של הערך המאוחסן במיקום הזיכרון של בעלים מִשְׁתַנֶה. אם תנסה להשתמש ב- בעלים משתנה, המהדר ייכנס לפאניקה, והוא יסרב ליצור קובץ הפעלה.

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

תן בעל = "בעלים";
תן new_owner = בעלים;
לְנַחֵם.log (בעל_חדש);

הפעלת קוד ה-JavaScript שלמעלה פועלת ללא שגיאות, ואם תעשה את אותו הדבר ב-Go או ב-Python, התוכנית שלך תעבוד גם ללא שגיאות.

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

// משתנה בהיקף נפרד
{
תן דוגמה = חוּט::from("הנה היקף חדש");
}
הדפס!("{}", דוגמא)

אתה לא יכול לגשת ל דוגמא משתנה מחוץ לתחום שלו; ניסיון לעשות זאת יגרום למהדר להיכנס לפאניקה.

בעלות בפונקציות

כאשר אתה מעביר ערך לפונקציה כארגומנט, הפונקציה יכולה לגשת למשתנה הזה למרות שהוא לא הוכרז בהיקפו:

fnמדפסת(ערך: חוּט) -> חוּט {
לַחֲזוֹר ערך
}
fnרָאשִׁי() {
תן x = חוּט::from("מדפיס ערך"); // x הוא הבעלים של ערך המחרוזת
// הבעלות מועברת לפונקציית המדפסת כאן
הדפס!("{} ה תוֹצָאָה של הדפסה X היא שזה -:", מדפסת (x));
}

הפונקציה יכולה לגשת למשתנה הזה מכיוון ש- Rust מעבירה את הבעלות עליו לפונקציה בזמן הקומפילציה.

אתה עשוי לחשוב שעדיין אפשרי להשתמש במשתנה מאוחר יותר בהיקפו המקורי:

fnמדפסת(ערך: חוּט) -> חוּט {
לַחֲזוֹר ערך
}
fnרָאשִׁי() {
תן x = חוּט::from("מדפיס ערך");
הדפס!("{} ה תוֹצָאָה של הדפסה x הוא שזה -:", מדפסת (x)); 
// מנסה להשתמש במשתנה לאחר העברת הבעלות על ערכו
println!("{} לא אמור להיות נגיש", x)
}

אבל אם תנסה את זה, המהדר ייכנס לפאניקה ויסרב לייצר קובץ הפעלה:

חלודה נותנת עדיפות לשימוש חוזר בקוד

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

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