מצביעים חכמים בחלודה: איך הם עובדים?

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

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

מהם מצביעים חכמים בחלודה?

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

חלודה משתמשת במבנים לביצוע מצביעים חכמים; לפיכך, למצביעים חכמים יש גם יכולות בעלות.

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

היתרונות של שימוש במצביעים חכמים

הנה כמה יתרונות של שימוש במצביעים חכמים:

1. ניהול זיכרון אוטומטי: מצביעים חכמים מספקים ניהול זיכרון אוטומטי, כולל הקצאה והקצאה, בניגוד לניהול זיכרון ידני עם מצביעים רגילים.
2. בטיחות משופרת: מצביעים חכמים אוכפים סמנטיקה של בעלות, מבטיחים שרק בעלים אחד יכול לגשת למשאבים בכל פעם, מונעים עקבות נתונים ובאגים הקשורים במקביל.
3. גְמִישׁוּת: חלודה מספקת מצביעים חכמים מרובים, כל אחד עם הסט שלו סמנטיקה של בעלות לכתיבת קוד בטוח בצורה גמישה.
4. ניהול משאבים: אתה יכול להשתמש במצביעים חכמים כדי לנהל משאבים אחרים כמו מטפלי קבצים ושקעי רשת על ידי הקפצת המשאבים בתוך מצביע חכם שמקל על ניהול מחזור החיים שלהם ולהבטיח שהם נסגרים כראוי ומשוחררים לאחר מכן להשתמש.
5. ביצועים משופרים: מצביעים חכמים עוזרים לשפר את הביצועים על ידי הפחתת העתקת זיכרון והקצאות - טביעת זיכרון מופחתת משימוש במצביעים חכמים מביאה לביצועים מוגברים.

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

סוגי מצביעים חכמים

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

1. The Box Smart Pointer

ה קופסא Smart Pointer הוא המצביע החכם הפשוט והנפוץ ביותר של Rust. ה קופסא מצביע חכם מסייע בהקצאת ערכים בערימה ויוצר מצביע בקופסה עבור נגישות.

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

כך תוכל להצהיר ולהשתמש ב-a קופסא מַצבִּיעַ:

fnרָאשִׁי(){
// מופע חדש של מצביע התיבה החכם 
לתת x = קופסא::חָדָשׁ(5);
println!(איקס)
}

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

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

2. ה-Rc Smart Pointer

ה Rc (Reference Counted) מצביע חכם מספק פונקציונליות ליצירת ערכים של בעלות משותפת. ה Rc מצביעים חכמים עוקבים אחר מספר ההפניות לערך ומקצים את הערך כאשר ההפניה האחרונה מחוץ לתחום.

ה Rc מצביע חכם שימושי כאשר אתה צריך לחלוק בעלות על ערך נגישות בחלקים מרובים של התוכנית שלך.

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

להשתמש std:: rc:: Rc;
fnרָאשִׁי() {
// מופע חדש של המצביע החכם RC 
לתת x = Rc:: new(5);
לתת y = Rc:: clone(&x);
println!("x = {}, y = {}", x, y);
}

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

3. ה-RefCell Smart Pointer

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

ה RefCell מצביע חכם שימושי בעת שינוי בערכים שבבעלות הפניות הניתנות לשינוי.

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

להשתמש std:: cell:: RefCell;
fnרָאשִׁי(){
// מופע חדש של המצביע החכם Refcell 
לתת x = RefCell:: new(5);
לתת y = x.borrow();
לתת z = x.borrow_mut();
println!("y = {}", *y);
println!("z = {}", *z);
} 

ה Refcell מצביע חכם מכיל את הערך ואת y משתנה הוא ההתייחסות הבלתי ניתנת לשינוי לערך. ה לשאל_מוט הפונקציה יוצרת התייחסות ניתנת לשינוי של הערך.

התוכנית בטוחה אם יש רק הפניה אחת הניתנת לשינוי בכל פעם.

4. ה-Mutex Smart Pointer

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

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

תצטרך לייבא את ה מנעול לבנות וליצור מופע חדש עם חָדָשׁ פונקציה לשימוש מנעול Smart Pointer בחלודה.

להשתמש std:: sync:: Mutex;
fnרָאשִׁי() {
// מופע חדש של מצביע ה-mutex 
לתת counter = Mutex:: new(0);
 {
לתתמוט num = counter.lock().unwrap();
 *מספר += 1;
 }
println!("תוצאה: {}", *counter.lock().unwrap());
}

ה דֶלְפֵּק המשתנה הוא החדש מנעול למשל. ה רָאשִׁי הפונקציה רוכשת נעילה על המוטקס עם ה- לנעול שיטת ה מנעול למשל. המנעול מאפשר שינוי בטוח של ערך המונה לפני שחרור המנעול והדפסת הערך.

ה מנעול סוג מבטיח שרק שרשור אחד יכול לגשת למשאבים המשותפים (במקרה זה, ה דֶלְפֵּק משתנה) ולשנות את ערכו בכל פעם. ההחרגה ההדדית מבטיחה גישה במקביל למשאבים משותפים מסודרת כדי למנוע עקבות נתונים ובעיות במקביל.

דגם הבעלות של Rust מבטיח בטיחות זיכרון

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

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