Chapter 6: Ownership and Memory Management in Rust

In C, manual memory management is a central aspect of programming. Developers allocate and deallocate memory using malloc and free, which provides flexibility but also introduces risks such as memory leaks, dangling pointers, and buffer overflows.

C++ mitigates some of these issues with RAII (Resource Acquisition Is Initialization) and standard library containers like std::string and std::vector. Many higher-level languages, such as Java, C#, Go, and Python, handle memory through garbage collection. While garbage collection increases safety and convenience, it often depends on a runtime system that can be unsuitable for performance-critical applications, particularly in systems and embedded programming.

Rust offers a different solution: it enforces memory safety without relying on a garbage collector, all while maintaining minimal runtime overhead.

This chapter introduces Rust’s ownership system, focusing on key concepts like ownership, borrowing, and lifetimes. Where relevant, we compare these ideas with C to help clarify how they differ.
We will primarily use Rust’s String type to illustrate these concepts. Unlike simple scalar values, strings are dynamically allocated, making them an excellent example for exploring ownership and borrowing. We will cover the basics of creating a string and passing it to a function here, with more advanced topics introduced later.

At the end of the chapter, you will find a short introduction to Rust’s smart pointers, which manage heap-allocated data while allowing controlled flexibility through runtime checks and interior mutability. We also provide a brief look at Rust’s unsafe blocks, which enable the use of raw pointers and interoperability with C and other languages. Chapters 19 and 25 will explore these advanced subjects in more detail.