स्वामित्व के नियम

स्वामित्व रस्ट की सबसे अनोखी विशेषता है। यह भाषा को गार्बेज कलेक्टर की आवश्यकता के बिना या आपको मैन्युअल रूप से हीप मेमोरी को हटाने के लिए बाध्य किए बिना (जैसे C या C++ में) मेमोरी सुरक्षा की गारंटी देने की अनुमति देता है।

स्वामित्व के तीन नियम

रस्ट में मेमोरी प्रबंधन कंपाइलर द्वारा सख्ती से जांचे गए तीन सरल नियमों द्वारा नियंत्रित होता है:

1. रस्ट में प्रत्येक मान का एक वेरिएबल होता है जिसे उसका स्वामी कहा जाता है।
2. एक समय में केवल एक ही मालिक हो सकता है।
3. जब मालिक दायरे से बाहर चला जाता है, तो मूल्य अपने आप कम हो जाता है।

ढेर बनाम ढेर

स्वामित्व को समझने के लिए, यह जानना महत्वपूर्ण है कि डेटा कहाँ रहता है:

• स्टैक: संकलन समय पर ज्ञात निश्चित आकार के डेटा को संग्रहीत करता है (उदाहरण के लिए, पूर्णांक, बूलियन)। पहुंच बेहद तेज है.
• हीप: संकलन समय पर अज्ञात गतिशील आकार के डेटा को संग्रहीत करता है (उदाहरण के लिए, String)। आवंटन धीमा है और स्टैक पर संग्रहीत पॉइंटर की आवश्यकता होती है।

"हटो" की अवधारणा

जब हम एक हीप-आवंटित वैरिएबल को दूसरे को असाइन करते हैं, तो रस्ट पहले वैरिएबल को अमान्य करते हुए, मान के स्वामित्व को स्थानांतरित कर देता है (या स्थानांतरित करता है):

let s1 = String::from("ciao");
let s2 = s1; // Ownership of the text moves to s2. s1 is NO longer usable!

// println!("{}", s1); // COMPILATION ERROR! s1 is "borrow of moved value"
println!("{}", s2); // Valid!

यह व्यवहार "डबल फ्री एरर" (स्कोप से बाहर जाने पर एक ही मेमोरी को दो बार फ्री करने की कोशिश) से बचाता है, क्योंकि केवल s2 ही मेमोरी को फ्री करेगा।

"क्लोन" की अवधारणा (डीप कॉपी)

यदि हमें स्पष्ट रूप से String (स्टैक पॉइंटर्स और हीप में वास्तविक टेक्स्ट डेटा दोनों) की संपूर्ण सामग्री की प्रतिलिपि बनाने की आवश्यकता है, तो हम .clone() विधि का उपयोग कर सकते हैं। यह नई मेमोरी आवंटन के लिए प्रदर्शन ओवरहेड की कीमत पर, मूल और नए वैरिएबल दोनों को वैध रखते हुए, ढेर पर डेटा को पूरी तरह से डुप्लिकेट करता है:

let s1 = String::from("ciao");
let s2 = s1.clone(); // Deep copy. Both variables remain valid!
println!("s1: {}, s2: {}", s1, s2);

"कॉपी" की अवधारणा

पूरी तरह से स्टैक पर संग्रहीत सरल प्रकारों के लिए (जैसे पूर्णांक i32, बूलियन्स bool, वर्ण char), असाइनमेंट एक वास्तविक स्वचालित उथली प्रतिलिपि निष्पादित करता है, जिसका अर्थ है कि दोनों चर मान्य रहते हैं:

let x = 5;
let y = x; // Copies the value 5 onto the stack. Both variables are usable!
println!("x: {}, y: {}", x, y); // Valid!

खुद कोशिश करना