DEV Community

Subesh Yadav
Subesh Yadav

Posted on

Day 29 of #100DaysOfRust: The Drop Trait and Resource Cleanup

#rust #webdev #learning #100daysofrust

Today’s focus was on the Drop trait, one of the most important traits in Rust’s memory and resource management story. After learning about smart pointers and deref coercion, we now dive into how Rust automatically cleans up values when they go out of scope, and how we can customize this behavior.

🧹 What is the Drop Trait?

The Drop trait allows you to specify what should happen when a value goes out of scope. It’s particularly useful for cleaning up resources like:

  • Memory allocations
  • File handles
  • Network connections
  • Locks

In other languages, forgetting to free these resources could cause crashes or memory leaks. Rust’s Drop trait ensures cleanup is handled automatically.

The trait requires implementing a single method:

impl Drop for MyType {
    fn drop(&mut self) {
        // cleanup code here
    }
}
Enter fullscreen mode Exit fullscreen mode

Rust then inserts calls to this method automatically when the value goes out of scope.

🛠 Example: Custom Smart Pointer with Drop

Let’s implement a simple smart pointer to see how Drop works.

struct CustomSmartPointer {
    data: String,
}

impl Drop for CustomSmartPointer {
    fn drop(&mut self) {
        println!("Dropping CustomSmartPointer with data `{}`!", self.data);
    }
}

fn main() {
    let c = CustomSmartPointer {
        data: String::from("my stuff"),
    };
    let d = CustomSmartPointer {
        data: String::from("other stuff"),
    };
    println!("CustomSmartPointers created.");
}
Enter fullscreen mode Exit fullscreen mode

Output: 

CustomSmartPointers created.
Dropping CustomSmartPointer with data `other stuff`!
Dropping CustomSmartPointer with data `my stuff`!
Enter fullscreen mode Exit fullscreen mode

Notice how values are dropped in the reverse order of their creation.

🚫 You Can’t Call Drop Directly

If you try to explicitly call c.drop(), Rust won’t allow it:

fn main() {
    let c = CustomSmartPointer {
        data: String::from("some data"),
    };
    c.drop(); // ❌ not allowed
}
Enter fullscreen mode Exit fullscreen mode

You’ll get this compiler error:

error[E0040]: explicit use of destructor method
help: consider using `drop` function
Enter fullscreen mode Exit fullscreen mode

This is to prevent double frees (Rust automatically calls drop at the end of the scope).

✅ Forcing Early Drop with std::mem::drop

If you do need to clean up a value before the end of its scope, you can use the drop function from Rust’s standard library:

fn main() {
    let c = CustomSmartPointer {
        data: String::from("some data"),
    };
    println!("CustomSmartPointer created.");
    drop(c);
    println!("CustomSmartPointer dropped before the end of main.");
}
Enter fullscreen mode Exit fullscreen mode

Output: 

CustomSmartPointer created.
Dropping CustomSmartPointer with data `some data`!
CustomSmartPointer dropped before the end of main.
Enter fullscreen mode Exit fullscreen mode

This way, the cleanup code runs exactly when you want.

💡 Why Drop Matters

The Drop trait is everywhere in Rust’s standard library:

  • Box<T> deallocates heap memory when dropped.
  • Vec<T> and String clean up their buffers.
  • File and network types close their handles safely.
  • Mutexes release their locks.

It ensures Rust programs are safe, memory-efficient, and free from resource leaks.

🧠 Key Takeaways

  • The Drop trait runs cleanup code when values go out of scope.
  • Rust automatically calls drop; you don’t have to (and can’t) call it directly.
  • Use std::mem::drop to clean up resources before scope ends.
  • Variables are dropped in reverse order of creation.
  • Drop underpins Rust’s safe and predictable memory management.

That’s all for Day 29! 🚀 Tomorrow, I’ll continue exploring more smart pointers and their patterns.

👉 Follow me on my #100DaysOfRust journey!

Top comments (0)