With the Rust Drop trait and destructor, we can run codes before Rust destroys an instance. This post shows how to perform just that.
Sample Rust Codes Using Drop Trait
To achieve our goal, we need to use the Drop trait. We have these initial codes with implemented Drop traits. While the codes are simple, they exhibit behavior that works implicitly. Meaning, we do not run any destructor. Instead, we only implement the Drop trait and let Rust run the drop function.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 | #[derive(Debug)] struct DatabaseConnection {} impl Drop for DatabaseConnection { fn drop(&mut self) { println!("Resource Released!") } } fn another_func1(v: DatabaseConnection) { println!("[In another_func] - {:?} will drop right after this!", v); } fn main() { let database_connection = DatabaseConnection{}; another_func1(database_connection); // println!("[In main] - will drop right after this!"); } |
First, we define a struct. In our case, we have the DatabaseConnection struct, which is a plain struct. Therefore, it cannot connect to a database.
Testing Rust With struct Instances
Given the output below and considering the concept of ownership and how it works in Rust, where did the drop(&mut self) function execute – in main() or another_func1()? At first glance, it appears that Rust has destroyed the instance when main() finishes execution.
1 2 | [In another_func] - DatabaseConnection will drop right after this! Resource Released! |
Now, let us modify the previous codes to ascertain when the Rust runs the drop function. We would expect it to happen before the main function completes.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 | #[derive(Debug)] struct DatabaseConnection {} impl Drop for DatabaseConnection { fn drop(&mut self) { println!("Resource Released!") } } fn another_func1(v: DatabaseConnection) { println!("[In another_func] - {:?} will drop right after this!", v); } fn main() { let database_connection = DatabaseConnection{}; another_func1(database_connection); // UNCOMMENTED THIS OUT println!("[In main] - will drop right after this!"); } |
When we run the codes, we get the following out.
1 2 3 | [In another_func] - DatabaseConnection will drop right after this! Resource Released! [In main] - will drop right after this! |
The output proves that the instance was “destroyed” in the another_func1() function. Now, why is that? It has something to do with ownership in Rust. When the function executes, it accepts an instance of a struct. As a result, a change of ownership happens from the main function to the another_func1() function. By the time it completes its execution before the main function does, Rust destroys the struct instance.
Now how do we make the code destroy our instance within the main function? In the previous codes, we let the function another_func1() take ownership of a resource. This time we let another_func1() borrow a resource still owned by the main() function.
Hence, we the modified codes as shown below.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 | #[derive(Debug)] struct DatabaseConnection {} impl Drop for DatabaseConnection { fn drop(&mut self) { println!("Resource Released!") } } // CHANGED TO &DatabaseConnection fn another_func1(v: &DatabaseConnection) { println!("[In another_func] - {:?} will drop right after this!", v); } fn main() { let database_connection = DatabaseConnection{}; // CHANGED TO &database_connection another_func1(&database_connection); // UNCOMMENTED THIS OUT println!("[In main] - will drop right after this!"); } |
The codes generate the following output.
1 2 3 | [In another_func] - DatabaseConnection will drop right after this! [In main] - will drop right after this! Resource Released! |
run codes before instance destroy
As we can see, Rust ran codes to destroy a struct instance after the println!() statement in the main() function. The destruction happened because we used the Rust Drop trait and let the destructor mechanism in Rust work.
