Rust for C-Programmers

2.14 Memory Safety Without a Garbage Collector

One of Rust’s defining features is its ability to guarantee memory safety (no dangling pointers, no use-after-free, no data races) at compile time without requiring a garbage collector (GC). This is achieved through its ownership and borrowing system:

• Ownership: Every value in Rust has a single owner. When the owner goes out of scope, the value is dropped (memory deallocated, resources released).
• Borrowing: You can grant temporary access (references) to a value without transferring ownership. References can be immutable (&T) or mutable (&mut T). Rust enforces strict rules: you can have multiple immutable references or exactly one mutable reference to a particular piece of data in a particular scope, but not both simultaneously.
• Lifetimes: The compiler uses lifetime analysis (a concept discussed later) to ensure references never outlive the data they point to.

This system eliminates many common bugs found in C/C++ related to manual memory management while providing performance comparable to C/C++.

2.14.1 Comparison with C

C relies on manual memory management (malloc, calloc, realloc, free). This gives programmers fine-grained control but makes it easy to introduce errors like memory leaks (forgetting free), double frees, use-after-free, and buffer overflows. Rust’s compiler acts as a vigilant checker, preventing these issues before the program even runs.