Rust
The Drop Trait - Destructors in Rust
Zoeken…
Opmerkingen
Het gebruik van de Drop Trait betekent niet dat deze elke keer wordt uitgevoerd. Hoewel het wordt uitgevoerd als je buiten bereik bent of ontspant, is het misschien niet altijd het geval, bijvoorbeeld wanneer mem::forget wordt aangeroepen.
Dit komt omdat een paniek tijdens het afrollen ertoe leidt dat het programma wordt afgebroken. Mogelijk is het ook gecompileerd met Abort on Panic ingeschakeld.
Bekijk het boek voor meer informatie: https://doc.rust-lang.org/book/drop.html
Eenvoudige drop-implementatie
use std::ops::Drop;
struct Foo(usize);
impl Drop for Foo {
fn drop(&mut self) {
println!("I had a {}", self.0);
}
}
Drop voor opruimen
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);
}
Met Drop kun je eenvoudige en faalveilige ontwerpen maken.
Drop Logging voor Runtime Memory Management Debuggen
Beheer van runtime-geheugen met Rc kan erg handig zijn, maar het kan ook moeilijk zijn om je hoofd eromheen te zetten, vooral als je code erg complex is en naar een enkele instantie wordt verwezen door tientallen of zelfs honderden andere typen in veel scopes.
Een Drop-eigenschap schrijven met println!("Dropping StructName: {:?}", self); kan enorm waardevol zijn voor foutopsporing, omdat u precies kunt zien wanneer de sterke verwijzingen naar een struct-instantie opraken.