Rust
Drop and cleanup
Learn memory cleanup and the Drop trait in FFI.
Drop and cleanup
C libraries usually offer a "create" and a "free" function. In a Rust wrapper, the freeing goes inside Drop; this way the user can't forget it, and it also runs on errors or panics:
unsafe extern "C" {
fn malloc(n: usize) -> *mut c_void;
fn free(p: *mut c_void);
}
struct CTampon {
p: *mut u8,
n: usize,
}
impl Drop for CTampon {
fn drop(&mut self) {
// SAFETY: p came from malloc and is freed only here.
unsafe { free(self.p as *mut c_void) };
}
}
A safe interface
Offering access through a slice without giving out the raw pointer makes the type safe to use:
impl CTampon {
fn new(n: usize) -> Option<Self> {
let p = unsafe { malloc(n) } as *mut u8;
if p.is_null() { None } else { Some(Self { p, n }) }
}
fn dilim(&mut self) -> &mut [u8] {
// SAFETY: p points to a valid region of n bytes.
unsafe { std::slice::from_raw_parts_mut(self.p, self.n) }
}
}
If malloc fails it returns a null pointer; expressing this with Option forces the user to check.
Exercise C buffer
Write the CTampon type above (new, dilim, Drop); let Drop print serbest bırakıldı after freeing. Allocate a 4-byte buffer, write the values 1 to 4 into the bytes and print their sum.
Show example solution
use std::ffi::c_void;
unsafe extern "C" {
fn malloc(n: usize) -> *mut c_void;
fn free(p: *mut c_void);
}
struct CTampon {
p: *mut u8,
n: usize,
}
impl CTampon {
fn new(n: usize) -> Option<Self> {
// SAFETY: malloc herhangi bir boyut için çağrılabilir.
let p = unsafe { malloc(n) } as *mut u8;
if p.is_null() {
None
} else {
Some(Self { p, n })
}
}
fn dilim(&mut self) -> &mut [u8] {
// SAFETY: p, n baytlık geçerli bir bölgeyi gösterir.
unsafe { std::slice::from_raw_parts_mut(self.p, self.n) }
}
}
impl Drop for CTampon {
fn drop(&mut self) {
// SAFETY: p malloc'tan geldi ve yalnızca burada serbest bırakılır.
unsafe { free(self.p as *mut c_void) };
println!("serbest bırakıldı");
}
}
fn main() {
let mut t = CTampon::new(4).unwrap();
for (i, b) in t.dilim().iter_mut().enumerate() {
*b = i as u8 + 1;
}
let toplam: u32 = t.dilim().iter().map(|&b| b as u32).sum();
println!("{}", toplam);
}
Test yourself
-
Why is freeing memory from C with Rust's <code>Box::from_raw</code> wrong?
- It doesn't compile
- The memory came from a different allocator; the allocating side must free it
- Box is slow
- It's correct
Show answer
The memory came from a different allocator; the allocating side must free it — Rule: whichever side allocated the memory frees it.
-
Free it
impl Drop for CTampon {
fn drop(&mut self) {
unsafe { ____(self.p as *mut c_void) };
}
}
Show answer
impl Drop for CTampon {
fn drop(&mut self) {
unsafe { free(self.p as *mut c_void) };
}
}
-
Step and owner
- malloc
- Allocates
- Drop::drop
- Calls free
- p.is_null()
- Allocation failed
- dilim()
- Safe access
Next lesson: Summary - FFI
