The Drop Trait

Values which implement Drop can specify code to run when they go out of scope:

  1. struct Droppable {
  2.     name: &'static str,
  3. }
  5. impl Drop for Droppable {
  6.     fn drop(&mut self) {
  7.         println!("Dropping {}", self.name);
  8.     }
  9. }
  11. fn main() {
  12.     let a = Droppable { name: "a" };
  13.     {
  14.         let b = Droppable { name: "b" };
  15.         {
  16.             let c = Droppable { name: "c" };
  17.             let d = Droppable { name: "d" };
  18.             println!("Exiting block B");
  19.         }
  20.         println!("Exiting block A");
  21.     }
  22.     drop(a);
  23.     println!("Exiting main");
  24. }

This slide should take about 8 minutes.

  • Note that std::mem::drop is not the same as std::ops::Drop::drop.
  • Values are automatically dropped when they go out of scope.
  • When a value is dropped, if it implements std::ops::Drop then its Drop::drop implementation will be called.
  • All its fields will then be dropped too, whether or not it implements Drop.
  • std::mem::drop is just an empty function that takes any value. The significance is that it takes ownership of the value, so at the end of its scope it gets dropped. This makes it a convenient way to explicitly drop values earlier than they would otherwise go out of scope.
    • This can be useful for objects that do some work on drop: releasing locks, closing files, etc.

Discussion points:

  • Why doesn’t Drop::drop take self?
    • Short-answer: If it did, std::mem::drop would be called at the end of the block, resulting in another call to Drop::drop, and a stack overflow!
  • Try replacing drop(a) with a.drop().