Comprendre le modèle de propriété de Rust

Rust's ownership system is a set of rules that manage how your program uses memory. It's a core concept that helps Rust achieve memory safety without a garbage collector.

• No dangling pointers.
• No double-free errors.
• No data races in concurrent code.

It checks these rules at compile time!

Programs use two main memory areas: the stack and the heap.

• Stack: Faster, fixed-size data (like integers, booleans, known-size types). Data is pushed and popped in order.
• Heap: Slower, variable-size data (like String, Vec). Data is requested and returned by the allocator.

Ownership primarily manages data on the heap, ensuring its safe use and cleanup.

The first rule of ownership is simple: each value in Rust has a variable that's called its owner.

Think of it like a label on a box. The variable s below is the owner of the text "hello".

The second rule states: at any given time, there can only be one owner for a value. This is crucial for preventing memory issues.

When you assign a complex value (like a String, which lives on the heap) from one variable to another, ownership is moved, not copied.

See what happens when s1's value is assigned to s2. Try running the code.

After let s2 = s1;, s1 is no longer considered valid. Rust prevents you from using s1 again.

• This is called a move. The pointer, length, and capacity on the stack are copied, but the heap data itself is not.
• If s1 were still valid, both s1 and s2 would try to free the same memory when they go out of scope (a double-free error).

Rust's ownership system prevents this at compile time!

Passing a value to a function works similarly to assigning it to another variable: ownership is moved into the function.

When the function finishes, the value's owner (the function parameter) goes out of scope, and the value is dropped.

Observe how the String value is moved into takes_ownership and then gives_ownership returns a new String.

The final rule: when the owner goes out of scope, the value will be dropped.

• A scope is the range within a program for which an item is valid, usually defined by {} curly brackets.
• When a variable goes out of scope, Rust automatically calls a special function called drop.

This ensures memory is cleaned up automatically, safely, and without a garbage collector.

The ownership rules work together to guarantee memory safety:

• One owner: Prevents multiple parts of your code from trying to free the same memory.
• Drop on scope end: Ensures memory is freed exactly once, and at the correct time.

This eliminates common bugs like double-free errors and use-after-free errors at compile time, giving you peace of mind!

Consider the following Rust code. What will happen when you try to compile and run it?

fn main() {
  let message = String::from("Rust is fun!");
  let greeting = message;
  println!("{}", message);
}

Great job! You've learned the fundamental rules of Rust's ownership system:

• Every value has an owner.
• There can only be one owner at a time.
• When the owner goes out of scope, the value is dropped.

This system prevents common memory errors without a garbage collector. Next, we'll explore borrowing to share data without transferring ownership.