Rust
ड्रॉप ट्रेल - जंग में विध्वंसक

टिप्पणियों

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

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); डिबगिंग के लिए बहुत मूल्यवान हो सकता है, क्योंकि यह आपको ठीक से देखने की अनुमति देता है जब एक संरचनात्मक उदाहरण के मजबूत संदर्भ बाहर निकलते हैं।