#[lang = "drop"]
pub trait Drop {
fn drop(&mut self);
}
Used to run some code when a value goes out of scope.
This is sometimes called a 'destructor'.
When a value goes out of scope, it will have its drop method called if
its type implements Drop. Then, any fields the value contains will also
be dropped recursively.
Because of this recursive dropping, you do not need to implement this trait
unless your type needs its own destructor logic.
Refer to the chapter on Drop in The Rust Programming Language
for some more elaboration.
The drop method is called when _x goes out of scope, and therefore
main prints Dropping!.
struct HasDrop;
impl Drop for HasDrop {
fn drop(&mut self) {
println!("Dropping!");
}
}
fn main() {
let _x = HasDrop;
}When outer goes out of scope, the drop method will be called first for
Outer, then for Inner. Therefore, main prints Dropping Outer! and
then Dropping Inner!.
struct Inner;
struct Outer(Inner);
impl Drop for Inner {
fn drop(&mut self) {
println!("Dropping Inner!");
}
}
impl Drop for Outer {
fn drop(&mut self) {
println!("Dropping Outer!");
}
}
fn main() {
let _x = Outer(Inner);
}_first is declared first and _second is declared second, so main will
print Declared second! and then Declared first!.
struct PrintOnDrop(&'static str);
impl Drop for PrintOnDrop {
fn drop(&mut self) {
println!("{}", self.0);
}
}
fn main() {
let _first = PrintOnDrop("Declared first!");
let _second = PrintOnDrop("Declared second!");
}fn drop(&mut self)
Executes the destructor for this type.
This method is called implicitly when the value goes out of scope,
and cannot be called explicitly (this is compiler error E0040).
However, the std::mem::drop function in the prelude can be
used to call the argument's Drop implementation.
When this method has been called, self has not yet been deallocated.
That only happens after the method is over.
If this wasn't the case, self would be a dangling reference.
Given that a panic! will call drop as it unwinds, any panic!
in a drop implementation will likely abort.
impl<'a> Drop for boolean_enums::lstd::string::Drain<'a> | [src] |
impl<'a, T> Drop for boolean_enums::lstd::collections::vec_deque::Drain<'a, T> where
T: 'a, | [src] |
impl<'a, T> Drop for boolean_enums::lstd::vec::Drain<'a, T> | [src] |
impl<K, V> Drop for boolean_enums::lstd::collections::btree_map::IntoIter<K, V> | [src] |
Drops the Rc.
This will decrement the strong reference count. If the strong reference
count reaches zero then the only other references (if any) are
Weak, so we drop the inner value.
use std::rc::Rc;
struct Foo;
impl Drop for Foo {
fn drop(&mut self) {
println!("dropped!");
}
}
let foo = Rc::new(Foo);
let foo2 = Rc::clone(&foo);
drop(foo);
drop(foo2); impl<T> Drop for boolean_enums::lstd::rc::Weak<T> where
T: ?Sized, | [src] |
Drops the Weak pointer.
use std::rc::{Rc, Weak};
struct Foo;
impl Drop for Foo {
fn drop(&mut self) {
println!("dropped!");
}
}
let foo = Rc::new(Foo);
let weak_foo = Rc::downgrade(&foo);
let other_weak_foo = Weak::clone(&weak_foo);
drop(weak_foo);
drop(foo);
assert!(other_weak_foo.upgrade().is_none());
Drops the Arc.
This will decrement the strong reference count. If the strong reference
count reaches zero then the only other references (if any) are
Weak, so we drop the inner value.
use std::sync::Arc;
struct Foo;
impl Drop for Foo {
fn drop(&mut self) {
println!("dropped!");
}
}
let foo = Arc::new(Foo);
let foo2 = Arc::clone(&foo);
drop(foo);
drop(foo2);
impl<T> Drop for boolean_enums::lstd::sync::Weak<T> where
T: ?Sized, | [src] |
Drops the Weak pointer.
use std::sync::{Arc, Weak};
struct Foo;
impl Drop for Foo {
fn drop(&mut self) {
println!("dropped!");
}
}
let foo = Arc::new(Foo);
let weak_foo = Arc::downgrade(&foo);
let other_weak_foo = Weak::clone(&weak_foo);
drop(weak_foo);
drop(foo);
assert!(other_weak_foo.upgrade().is_none());