#[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.
Drop
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 implilcitly 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<T, A> Drop for RawVec<T, A> where
A: Alloc,
[src]
impl<'a, T, F> Drop for DrainFilter<'a, T, F> where
F: FnMut(&mut T) -> bool,
impl<'a, T> Drop for PeekMut<'a, T> where
T: Ord,
impl<'a, I> Drop for Splice<'a, I> where
I: Iterator,
impl<'a> Drop for std::string::Drain<'a>
impl<T> Drop for std::rc::Weak<T> where
T: ?Sized,
impl<T> Drop for Arc<T> where
T: ?Sized,
impl<T> Drop for Rc<T> where
T: ?Sized,
impl<T> Drop for VecDeque<T>
impl<'a, T> Drop for std::vec::Drain<'a, T>
impl<T> Drop for Box<T> where
T: ?Sized,
impl<T> Drop for std::sync::Weak<T> where
T: ?Sized,
impl<T> Drop for IntermediateBox<T> where
T: ?Sized,
impl<T> Drop for Vec<T>
impl<T> Drop for std::vec::IntoIter<T>
impl<K, V> Drop for std::collections::btree_map::IntoIter<K, V>
impl<'a, T> Drop for std::collections::vec_deque::Drain<'a, T> where
T: 'a,
impl<K, V> Drop for BTreeMap<K, V>
impl<T> Drop for LinkedList<T>
impl<'a, K, V> Drop for EntryPlace<'a, K, V>
impl Drop for CString
impl<W: Write> Drop for BufWriter<W>
impl Drop for Select
impl<'rx, T: Send> Drop for Handle<'rx, T>
impl<T> Drop for Sender<T>
impl<T> Drop for SyncSender<T>
impl<T> Drop for Receiver<T>
impl Drop for Condvar
impl<T: ?Sized> Drop for Mutex<T>
impl<'a, T: ?Sized> Drop for MutexGuard<'a, T>
impl<T: ?Sized> Drop for RwLock<T>
impl<'a, T: ?Sized> Drop for RwLockReadGuard<'a, T>
impl<'a, T: ?Sized> Drop for RwLockWriteGuard<'a, T>
© 2010 The Rust Project Developers
Licensed under the Apache License, Version 2.0 or the MIT license, at your option.
https://doc.rust-lang.org/std/ops/trait.Drop.html