The Smart Pointer Mechanics: Deref and Drop

Smart pointers are data structures that act like pointers but have additional metadata and features (such as reference counting or automated resource cleanup). In Rust, any struct can behave like a smart pointer by implementing the standard library's Deref and Drop traits.

The Deref Trait (Pointer Coercion)

Implementing Deref allows you to customize the behavior of the dereference operator *. It also enables deref coercion, letting you pass a reference to a smart pointer as a reference to its inner type automatically.

use std::ops::Deref;

struct CustomBox<T>(T);

impl<T> CustomBox<T> {
    fn new(x: T) -> CustomBox<T> {
        CustomBox(x)
    }
}

// Implement Deref to allow dereferencing (*box)
impl<T> Deref for CustomBox<T> {
    type Target = T;

    fn deref(&self) -> &Self::Target {
        &self.0
    }
}

let x = 5;
let y = CustomBox::new(x);

assert_eq!(5, x);
assert_eq!(5, *y); // deref is called under the hood: *(y.deref())

Deref Coercion in Action

If a method expects a &str, you can pass a &String or a &Box<String> directly because of deref coercion:

fn print_message(s: &str) {
    println!("{}", s);
}

let boxed_str = Box::new(String::from("Hello"));
print_message(&boxed_str); // &Box<String> coerces to &String, which coerces to &str!

The Drop Trait (Automated Destructors)

The Drop trait lets you customize what happens when a value falls out of scope. It is widely used to free heap memory, close file descriptors, release sockets, or return locks to a pool.

struct DatabaseConnection {
    id: u32,
}

impl Drop for DatabaseConnection {
    fn drop(&mut self) {
        // Automatically runs when the connection variable falls out of scope
        println!("Closing database connection #{}...", self.id);
    }
}

{
    let conn = DatabaseConnection { id: 101 };
    // Operations with connection...
} // conn falls out of scope here -> 💥 Prints: "Closing database connection #101..."

Manual Early Drop

You cannot call drop directly on a value because Rust will attempt to double-drop it when it falls out of scope, which is unsafe. Instead, use the global prelude function std::mem::drop:

let conn = DatabaseConnection { id: 101 };
std::mem::drop(conn); // forces early drop and ownership consumption!
// conn is no longer valid here