Szukaj…


Uwagi

Użycie cechy Drop nie oznacza, że będzie uruchamiana za każdym razem. Chociaż będzie działał, gdy wychodzisz poza zasięg lub odwijanie, nie zawsze tak jest, na przykład, gdy wywoływana jest funkcja mem::forget .

Wynika to z tego, że panika podczas odwijania powoduje przerwanie programu. Można go również skompilować z włączoną Abort on Panic .

Aby uzyskać więcej informacji, sprawdź książkę: https://doc.rust-lang.org/book/drop.html

Prosta implementacja zrzutu

use std::ops::Drop;

struct Foo(usize);

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

Upuść na czyszczenie

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);
}

Drop pozwala tworzyć proste i bezpieczne projekty.

Upuszczanie rejestrowania w celu debugowania zarządzania pamięcią wykonawczą

Zarządzanie pamięcią w czasie wykonywania za pomocą Rc może być bardzo przydatne, ale może być również trudne do obejścia, szczególnie jeśli kod jest bardzo złożony, a do jednej instancji odwołują się dziesiątki, a nawet setki innych typów w wielu zakresach.

Pisanie cechy Drop, która obejmuje println!("Dropping StructName: {:?}", self); może być niezwykle cenny podczas debugowania, ponieważ pozwala dokładnie zobaczyć, kiedy wyczerpują się silne odwołania do instancji struct.



Modified text is an extract of the original Stack Overflow Documentation
Licencjonowany na podstawie CC BY-SA 3.0
Nie związany z Stack Overflow