जंग में जीवनकाल पर एक और लेख

नौसिखिया दंगा करने वाले के पहले महीने आम तौर पर जीवनकाल और कब्जे की अवधारणा के बारे में एक हेडर के लिए आते हैं। कुछ लोग इस पर टूट जाते हैं, लेकिन जो लोग जीवित रहने में सक्षम थे, यह अब असामान्य या गलत नहीं लगता है। मैं उन प्रमुख बिंदुओं का वर्णन करूंगा जो मुझे प्रतीत होते हैं, उन्होंने जीवनकाल और संपत्ति की अवधारणा को तेजी से और बेहतर रूप से अनुकूलित करने में मदद की है।

बेशक, आधिकारिक समाचार पत्र फुलर और अधिक विस्तृत है, लेकिन इसे पूरी जानकारी को समझने और अवशोषित करने के लिए अधिक समय और धैर्य की भी आवश्यकता होती है। मैंने बड़ी संख्या में विवरणों से बचने और बढ़ती जटिलता के क्रम में सब कुछ पेश करने की कोशिश की, इस लेख को उन लोगों के लिए और अधिक सुलभ बनाने के प्रयास में जो या तो सिर्फ रैस्ट देखना शुरू कर देते थे, या वास्तव में आधिकारिक बुलेटिन बोर्ड से शुरुआती क्षणों को नहीं समझते थे।

इसने मुझे यह भी लिखा है कि, उदाहरण के लिए, भिक्षुओं से, आप कुछ आधिकारिक प्रशिक्षण सामग्री पा सकते हैं, लेकिन वे हमेशा अच्छी तरह से समझ में नहीं आते हैं, और इस विषय पर "एक और परिचय" जैसे कुछ पढ़ने के बाद ही समझ पैदा होती है।

लाइफटाइम (जीवन)

पहले हमें दो चीजों के साथ सहज होने की आवश्यकता है - ब्लॉक का अंत और मूल्य को दूसरे ब्लॉक में ले जाना। बाद में हम "उधार", "परिवर्तनशीलता" और "छिपी हुई परिवर्तनशीलता" जोड़कर इसे जटिल करना शुरू कर देंगे।

सबसे पहले, एक मूल्य का जीवन निम्न खंड द्वारा निर्धारित किया जाता है:

• जीवन की शुरुआत: मूल्य बनाना। यह अधिकांश प्रोग्रामिंग भाषाओं के लिए आम है, इसलिए यह कोई असामान्य भार नहीं उठाता है।
• जीवन का अंत। यह वह जगह है जहां रस्ट स्वचालित रूप से विध्वंसक को कॉल करेगा और मूल्य के बारे में भूल जाएगा। एक स्कोप ब्लॉक में, यह बिना रुके इस ब्लॉक के अंत में होगा। यह जीवन के अंत की मानसिक ट्रैकिंग है, जो मेरी राय में, उधारकर्ता के साथ सफल बातचीत की कुंजी है।

मैं एक विवरण जोड़ूंगा जो काम आ सकता है: यदि दायरे में कई मूल्य हैं, तो वे निर्माण के रिवर्स ऑर्डर में नष्ट हो जाएंगे।

एक और बिंदु: मैं एक स्ट्रिंग बनाऊंगा, क्योंकि इसमें एक कॉपी मार्कर नहीं है, और जिन मानों में यह मार्कर नहीं है, वे स्थानांतरित नहीं होते हैं, बल्कि कॉपी किए जाते हैं, जिन्हें एक सस्ता ऑपरेशन माना जाता है, लेकिन इस कदम के व्यवहार को बदल देता है (और यह प्राइमर प्रकार के साथ काम करना आसान बनाता है), लेकिन उस पर और बाद में।

उदाहरण यहां दिए जा सकते हैं: https://play.rust-lang.org/

fn main() { { //    let a = "a".to_string(); // <-   "a" let b = 100; // <-   "b" // <-   b // <-   a } //    //     "a"  "b" } 

एक साधारण ब्लॉक के साथ, सब कुछ अपेक्षाकृत सरल है, अगला चरण तब होता है जब हम फ़ंक्शन और क्लोजर जैसी प्रतीत होता है सरल चीजों का उपयोग करते हैं:

विस्थापन

एक मूल्य की तरह एक अवधारणा जोड़ें। सरल शब्दों में, "चलती" का मतलब है कि वर्तमान ब्लॉक अब मूल्य के भाग्य में दिलचस्पी नहीं रखता है और यह इसके बारे में भूल जाता है, और इसका भाग्य दूसरे ब्लॉक में स्थानांतरित किया जाता है, उदाहरण के लिए, किसी अन्य फ़ंक्शन या एक बंद करने के लिए, या बस किसी अन्य मूल्य पर।

 fn f<T: std::fmt::Display>(x: T) { //   ,         . println!("{}", x); // <-  ,   "a",    . } fn main() { let a = "a".to_string(); // "a"    let b = 2; f(a); //   "a"  f //        f(a) -   ,    "a"        .    a  b,    ,      Copy   . // "b" . } 

बंद होने के साथ।

बंद मूल्य को अपने ब्लॉक में स्थानांतरित करने के लिए बंद करने के लिए, कीवर्ड चाल का उपयोग किया जाता है, यदि आप चाल नहीं लिखते हैं, तो मूल्य उधार लिया जाता है, जिसे मैं बहुत जल्द लिखूंगा।

 fn main() { let a = "a".to_string(); // "a"    let b = 2; let f_1 = move || {println!("{}", a)}; //   "a" //    "a"    . // let f_2 = move || {println!("{}", a)}; f_1(); } 

आप फ़ंक्शन और फ़ंक्शन से या किसी अन्य मान पर दोनों को स्थानांतरित कर सकते हैं।

यह उदाहरण प्रदर्शित करता है कि उधारकर्ताओं के साथ शांति से रहने के लिए उन तरीकों का ट्रैक कैसे रखा जाए, जिसमें मान चलता है।

 fn f(x: String) -> String { x + " and x" //    x   +,     . //  +   String,    . } fn main() { let a = "a".to_string(); //  "a" let b = f(a); //  "a"  "f",  f     b. println!("{}", b); // "a"   . } 

उधार

हम इस नई अवधारणा को पेश करते हैं: चलती के विपरीत, इसका मतलब है कि वर्तमान ब्लॉक मूल्य के नियंत्रण को सुरक्षित रखता है, यह बस दूसरे ब्लॉक को अपने मूल्य का उपयोग करने की अनुमति देता है।

मैं ध्यान देता हूं कि उधारी भी वहीं होती है जहां यह समाप्त हुई, जो इन उदाहरणों में बहुत महत्वपूर्ण नहीं है, लेकिन अगले पैराग्राफ में पॉप अप होगा।

नोट: मैं इस बारे में नहीं लिखूंगा कि जीवनकाल को सीधे फ़ंक्शन में कैसे निर्दिष्ट किया जाए, क्योंकि आधुनिक जंग पुराने दिनों की तुलना में स्वचालित रूप से बेहतर करती है, और इस सब का खुलासा कुछ और पृष्ठों पर है।

 fn f(x: &String) { //   &,    . println!("{}", x); // <-  ,  "x"     } fn main() { let a = "a".to_string(); // "a"    f(&a); //   "a"  f //   f(&a); //    -  . println!("{}", a); //   // "a"  . } 

समान रूप से बंद होने के साथ:

 fn main() { let mut a = "a".to_string(); // "a"    let f_1 = || a.push_str("and x"); //   "a" let f_2 = || a.push_str("and x"); //   f_1(); f_2(); println!("{}", a); // "a"  . } 

दरअसल, इन सरल निर्माणों में से अधिकांश में, उपयोगकर्ता को केवल यह तय करने की आवश्यकता है कि वह मूल्य का जीवन कहां समाप्त करना चाहता है: वर्तमान ब्लॉक के अंत में और इसे कुछ कार्यों को उधार देना, या, अगर हम जानते हैं कि हमें अब मूल्य की आवश्यकता नहीं है, तो इसे अंत में फ़ंक्शन पर ले जाएं। जिसके द्वारा यह स्वयं नष्ट हो जाएगा, हम मेमोरी को जितनी तेजी से मुक्त करेंगे, लेकिन मूल्य वर्तमान ब्लॉक में उपलब्ध नहीं होगा।

परिवर्तनशील

उदाहरण के लिए, उदाहरण के लिए, कोटलिन में, परस्पर और गैर-स्थिर मूल्यों में एक विभाजन होता है। लेकिन समस्या यह है कि उत्परिवर्तन का उधार पर प्रभाव पड़ता है:
आप कई बार एक गैर-स्थिर मूल्य उधार ले सकते हैं, और एक परस्पर मूल्य को केवल एक बार पारस्परिक रूप से उधार लिया जा सकता है। आप पहले से पहले से उधार लिए गए मूल्य को बदल नहीं सकते हैं।

एक उदाहरण जो पिछले वाले से संबंधित नहीं है, जब यह अवधारणा हमें एक साथ उत्परिवर्तनीय और गैर-स्थिर उधार को रोककर समस्याओं से बचाती है:

 fn main() { let mut a = "abc".to_string(); for x in a.chars() { //   a.push_str(" and "); //  .  . a.push(x); } } 

यहाँ यह पहले से ही विभिन्न चालों पर स्टॉक करने के लिए आवश्यक है ताकि संतुष्ट हो सके, अधिकांश भाग के लिए, रैस्टा का दावा है। ऊपर के उदाहरण में, सबसे आसान "क्लोन ए" होगा -> क्लोन में एक गैर-स्थिर ऋण होगा, और मूल "ए" से संबंधित नहीं होगा।

 for x in a.clone().chars() { //  ,   . a.push_str(" and "); //  .      -   . 

लेकिन मैं निरंतरता बनाए रखने के लिए अपने उदाहरणों पर वापस जाना बेहतर समझता हूं। हमें "ए" बदलने की आवश्यकता है और हम ऐसा नहीं कर सकते।

 fn main() { let mut a = "a".to_string(); // "a"    let mut f_1 = || a.push_str(" and x"); //   "a".   - ,  mut  mut. //      ,   f_1  . let mut f_2 = || a.push_str(" and y"); //     : second mutable borrow occurs here f_1(); f_2(); println!("{}", a); } 

छिपा हुआ उत्परिवर्तन

सैद्धांतिक रूप से, एक क्लोजर कुछ फ़ंक्शन के लिए पारित किया जा सकता है जो प्रक्रिया करता है, उदाहरण के लिए, एक और धागे में अतुल्यकालिक रूप से, और फिर हमें वास्तव में समस्याएं होंगी, लेकिन इस मामले में, उधारकर्ता फिर से पुनर्बीमा है, हालांकि यह इस तथ्य को रद्द नहीं करता है कि हमें किसी भी तरह से सहमत होने की आवश्यकता है ।

नीचे पंक्ति: हमें दो उत्परिवर्ती उधार की आवश्यकता है, लेकिन रैस्ट केवल एक चीज की अनुमति देता है, लेकिन रस्टा के चालाक आविष्कारक एक "छिपे हुए म्यूटेशन" के साथ आते हैं: RefCell।

RefCell - हम RefCell में क्या लपेटते हैं - रेखापुंज इसे नीम योग्य मानता है, हालांकि, उधार_मूट () फ़ंक्शन का उपयोग करके हम अस्थायी रूप से एक उत्परिवर्तित लिंक निकाल सकते हैं जिसके द्वारा यह मान बदल सकता है, लेकिन एक महत्वपूर्ण nance है: लिंक केवल तभी प्राप्त किया जा सकता है जब RefCell रनटाइम में सुनिश्चित करता है कि कोई अन्य नहीं है। सक्रिय ऋण, अन्यथा वह घबरा जाएगा, या एक त्रुटि लौटाएगा यदि try_borrow_mut () का उपयोग किया जाता है। यानी यहाँ विकास उपयोगकर्ता की देखभाल के लिए ऋण देने के बारे में सभी चिंताओं को देता है, और उसे स्वयं यह सुनिश्चित करना चाहिए कि वह एक बार में कई स्थानों से मूल्य नहीं लेता है।

 use std::cell::RefCell; fn main() { let a = RefCell::new("a".to_string()); // "a"    let f_1 = || a.borrow_mut().push_str(" and x"); //    "a" let f_2 = || a.borrow_mut().push_str(" and y"); //    f_1(); //      a.borrow_mut() ,           mut    . f_2(); //   . println!("{}", a.borrow()); //         . } 

आरसी लिंक काउंटर

यह निर्माण कई भाषाओं में परिचित है, और इसका उपयोग रैस्ट में किया जाता है, जब, उदाहरण के लिए, हम किसी कारण के लिए एक मूल्य उधार नहीं ले सकते हैं, और एक एकल मान के लिए कई संदर्भ मान रखने की आवश्यकता है। आरसी, जैसा कि नाम का अर्थ है, एक संदर्भ काउंटर है जो एक मूल्य का मालिक है, यह गैर-स्थिर लिंक उधार ले सकता है, उनकी संख्या गिन सकता है और जैसे ही उनकी संख्या रीसेट हो जाती है, यह मूल्य और स्वयं को नष्ट कर देता है। यह पता चला है कि आरसी अनुमति देता है, जैसा कि यह था, गुप्त रूप से उस मूल्य के जीवनकाल का विस्तार करना जो इसमें निहित है।

मैं यह जोड़ूंगा कि रैस्ट स्वचालित रूप से उन संरचनाओं के लिए डीआरएफ़ कर सकता है जिनके लिए इसे परिभाषित किया गया है, जिसका अर्थ है कि आरसी के साथ काम करने के लिए, एक नियम के रूप में, आपको आंतरिक मूल्य के किसी भी अतिरिक्त निष्कर्षण की आवश्यकता नहीं है और हम आरसी के साथ काम करते हैं।

यहाँ एक सरल उदाहरण को थोड़ा कठिन माना गया था, आइए अनुकरण करने की कोशिश करें कि ऊपर दिए गए उदाहरण से क्लोजर & T या String स्वीकार नहीं करना चाहता, लेकिन केवल स्ट्रिंग चाहता है:

 fn f(x: String) { //  String,    &String println!("{}", x); } fn main() { let a = "a".to_string(); let f_1 = move || f(a); //   move,    ... let f_2 = move || f(a); // ...     ,           f_1(); f_2(); println!("{}", a); } 

यदि हम फ़ंक्शन को fn f(x: &String) (या & str) में बदल सकते हैं, तो यह समस्या आसानी से हल हो जाएगी, लेकिन आइए कल्पना करें कि किसी कारण से हम उपयोग नहीं कर सकते हैं &

हम आर सी का उपयोग करते हैं

 use std::rc::Rc; fn f(x: Rc<String>) { //       Rc println!("{}", x); //     ,  println          ,           ,       ,    . } fn main() { let a_rc = Rc::new("a".to_string()); //  Rc   let a_ref_1 = a.clone(); //   -,  . let a_ref_2 = a.clone(); //   let f_1 = move || f(a_ref_1); //      - let f_2 = move || f(a_ref_2); //  f_1(); f_2(); println!("{}", a_rc); //     Rc  . //    a_rc       . } 

मैं अंतिम उदाहरण जोड़ूंगा, क्योंकि कंटेनर के सबसे लगातार जोड़े में से एक जो पाया जा सकता है वह आरसी <RefCell> है

 use std::rc::Rc; use std::cell::RefCell; fn f(x: Rc<RefCell<String>>) { x.borrow_mut().push_str(" and x"); //      ,       ,   . } fn main() { let a = Rc::new(RefCell::new("a".to_string())); //      let a_ref_1 = a.clone(); let a_ref_2 = a.clone(); let f_1 = move || f(a_ref_1); let f_2 = move || f(a_ref_2); f_1(); f_2(); println!("{}", a.borrow()); // Rc   ,   RefCell   } 

इसके अलावा, इस ट्यूटोरियल को Rc-Arc के थ्रेड-सुरक्षित एनालॉग में ले जाना और फिर Mutex के बारे में जारी रखना तर्कसंगत होगा, लेकिन आपने थ्रेड सुरक्षा और उधारकर्ता के बारे में एक पैराग्राफ में बात नहीं की है, और यह स्पष्ट नहीं है कि इस प्रकार के लेख की आवश्यकता है, क्योंकि आधिकारिक धागा है। इसलिए मैं निष्कर्ष निकालता हूं।