खोज…


टिप्पणियों

ड्रॉप ट्रेल का उपयोग करने का मतलब यह नहीं है कि इसे हर बार चलाया जाएगा। हालांकि यह दायरे से बाहर जाने या अनइंड करने पर चलेगा, लेकिन यह हमेशा ऐसा नहीं हो सकता है, उदाहरण के लिए जब mem::forget को कहा जाता है।

ऐसा इसलिए होता है क्योंकि अनजाने में घबराहट के कारण कार्यक्रम निरस्त हो जाता है। हो सकता है कि इसे एबोर्ट के साथ Abort on Panic स्विच ऑन करने के लिए भी संकलित किया गया हो।

अधिक जानकारी के लिए पुस्तक देखें: https://doc.rust-lang.org/book/drop.html

सरल ड्रॉप कार्यान्वयन

use std::ops::Drop;

struct Foo(usize);

impl Drop for Foo {
    fn drop(&mut self) {
        println!("I had a {}", self.0);
    }
}

क्लीनअप के लिए ड्रॉप

use std::ops::Drop;

#[derive(Debug)]
struct Bar(i32);

impl Bar {
    fn get<'a>(&'a mut self) -> Foo<'a> {
        let temp = self.0; // Since we will also capture `self` we..
                           // ..will have to copy the value out first
        Foo(self, temp) // Let's take the i32
    }
}

struct Foo<'a>(&'a mut Bar, i32); // We specify that we want a mutable borrow..
                                  // ..so we can put it back later on

impl<'a> Drop for Foo<'a> {
    fn drop(&mut self) {
        if self.1 < 10 { // This is just an example, you could also just put..
                         // ..it back as is
            (self.0).0 = self.1;
        }
    }
}

fn main() {
    let mut b = Bar(0);
    println!("{:?}", b);
    {
        let mut a : Foo = b.get(); // `a` now holds a reference to `b`..
        a.1 = 2;                   // .. and will hold it until end of scope
    }                              // .. here
        
    println!("{:?}", b);
    {
        let mut a : Foo = b.get();
        a.1 = 20;
    }
    println!("{:?}", b);
}

ड्रॉप आपको सरल और असफल-सुरक्षित डिजाइन बनाने की अनुमति देता है।

रनटाइम मेमोरी मैनेजमेंट डिबगिंग के लिए ड्रॉप लॉगिंग

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

एक ड्रॉप विशेषता लिखना जिसमें println!("Dropping StructName: {:?}", self); शामिल है println!("Dropping StructName: {:?}", self); डिबगिंग के लिए बहुत मूल्यवान हो सकता है, क्योंकि यह आपको ठीक से देखने की अनुमति देता है जब एक संरचनात्मक उदाहरण के मजबूत संदर्भ बाहर निकलते हैं।



Modified text is an extract of the original Stack Overflow Documentation
के तहत लाइसेंस प्राप्त है CC BY-SA 3.0
से संबद्ध नहीं है Stack Overflow