Rust
The Drop Trait - Destructeurs à Rust
Recherche…
Remarques
Utiliser le Drop Trait ne signifie pas qu'il sera exécuté à chaque fois. Bien qu'il s'exécute lorsqu'il est hors de portée ou qu'il se déroule, ce n'est peut-être pas toujours le cas, par exemple lorsque mem::forget est appelé.
Cela est dû au fait qu'une panique lors du déroulement du programme entraîne une interruption du programme. Il aurait également pu être compilé avec Abort on Panic activé.
Pour plus d'informations, consultez le livre: https://doc.rust-lang.org/book/drop.html
Implémentation simple de la goutte
use std::ops::Drop;
struct Foo(usize);
impl Drop for Foo {
fn drop(&mut self) {
println!("I had a {}", self.0);
}
}
Drop for Cleanup
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 vous permet de créer des conceptions simples et sûres.
Suppression de la journalisation pour le débogage de la gestion de la mémoire d'exécution
La gestion de la mémoire d'exécution avec Rc peut être très utile, mais elle peut également être difficile à comprendre, en particulier si votre code est très complexe et qu'une instance unique est référencée par des dizaines, voire des centaines d'autres types.
Ecrire un trait Drop qui inclut println!("Dropping StructName: {:?}", self); peut être extrêmement utile pour le débogage, car il vous permet de voir précisément quand les fortes références à une instance de structure sont épuisées.