Referências e Empréstimo Explicados

In Rust, variables own their data. But what if you need to let other parts of your code look at or even change that data without taking ownership?

That's where references come in! A reference is like a pointer to a value, but with strict rules enforced by the Rust compiler.

Think of it as looking at something through a window instead of owning the item itself.

We create a reference using the & operator. This creates a non-owning pointer to a value. Let's see it in action:

When you create a reference to a value, you are borrowing that value. The owner still owns it, but you get temporary access.

• Lending without giving away: You can use the borrowed data.
• No ownership transfer: The original variable still owns the data and will drop it when it goes out of scope.
• Safety first: Rust's borrowing rules prevent common programming errors like data races.

By default, references in Rust are immutable. This means you can read the data they point to, but you cannot change it.

This is a core safety feature! If multiple parts of your code have read-only access, they can't accidentally interfere with each other's data.

Here, the calculate_sum function takes an immutable reference to a vector. It can read the elements but cannot add or remove them.

Sometimes, you need to modify data that you've borrowed. For this, you use a mutable reference, denoted by &mut.

Mutable references come with a crucial rule: you can only have one mutable reference to a particular piece of data at a time. This prevents data races and ensures safety.

The add_suffix function takes a mutable reference to a String. It can modify the original String directly.

Rust's compiler enforces these rules at compile time to guarantee memory safety:

• You can have one mutable reference to a piece of data at a time.
• OR, you can have any number of immutable references at a time.
• You cannot have a mutable reference while there are active immutable references.
• References must always be valid (they can't outlive the data they point to).

These rules prevent data races and ensure your programs are safe and predictable.

This code attempts to create both an immutable and a mutable reference to my_value at the same time, which violates Rust's borrowing rules. It will NOT compile.

Try to run it and see the compiler error!

Consider the following Rust code snippet:

fn process_data(data: &mut Vec<i32>) {
  data.push(4);
}

fn main() {
  let mut numbers = vec![1, 2, 3];
  let first_ref = &numbers[0]; // Line A
  process_data(&mut numbers); // Line B
  println!("First element: {}", first_ref); // Line C
}

Which line(s) will cause a compile-time error due to Rust's borrowing rules?

Great job! You've learned the fundamentals of references and borrowing in Rust:

• References (&) allow you to access data without taking ownership.
• Borrowing is the act of creating a reference, lending access to data.
• Immutable references (&) provide read-only access.
• Mutable references (&mut) provide read/write access.
• Rust's strict borrowing rules (one mutable OR many immutable) prevent data races and ensure memory safety at compile time.

These concepts are crucial for writing safe and efficient Rust code!