Rust - Ownership, Borrowing & Lifetimes: Memory Safety Concepts Flashcards

Question 1

What is Rust's Ownership System?

Accepted Answer

Rust's ownership system is a set of rules that govern how a program manages memory. It ensures memory safety without a garbage collector by tracking variable ownership and scope at compile time, preventing common bugs like dangling pointers and data races.

Question 2

Why does Rust use Ownership?

Accepted Answer

Rust uses ownership to achieve memory safety and concurrency without runtime overhead (like a garbage collector). It allows Rust to guarantee memory safety at compile time, leading to predictable performance and preventing common memory-related errors.

Question 3

Explain Ownership Rule 1.

Accepted Answer

Each value in Rust has a variable that's called its *owner*. This means every piece of data in memory is explicitly managed by a single owner at any given time.

Question 4

Explain Ownership Rule 2.

Accepted Answer

When the owner goes out of scope, the value will be dropped. This rule ensures that memory is automatically deallocated when it's no longer needed, preventing memory leaks and double-frees.

Question 5

Explain Ownership Rule 3.

Accepted Answer

Ownership can be *moved*. When a value is assigned to another variable or passed to a function, ownership is transferred, and the original variable can no longer be used. This is known as 'move semantics'.

Question 6

Illustrate ownership move with a `String` example.

Accepted Answer

```rust
let s1 = String::from("hello");
let s2 = s1; // Ownership of "hello" moves from s1 to s2
// println!("{}", s1); // ERROR: s1 is no longer valid (borrow of moved value)
println!("{}", s2); // s2 is the new owner
```

Question 7

When does Rust perform a 'copy' instead of a 'move'?

Accepted Answer

Rust performs a 'copy' for types that implement the `Copy` trait. These are typically simple, fixed-size types stored on the stack, like integers (`i32`, `u64`), booleans, characters, and tuples containing only `Copy` types. For `Copy` types, both variables remain valid after assignment.

Question 8

What is Borrowing in Rust?

Accepted Answer

Borrowing is the mechanism by which Rust allows you to access data without taking ownership. This is done by creating *references* to a value, which are like pointers but with strict compile-time rules to ensure validity.

Question 9

What is a Reference in Rust?

Accepted Answer

A reference is a way to refer to a value without owning it. It's similar to a pointer but is guaranteed to always point to valid data. References are created using the `&` operator.

Question 10

What are Immutable References?

Accepted Answer

Immutable references (`&T`) allow you to read data but not modify it. You can have any number of immutable references to a piece of data simultaneously, as long as there are no active mutable references.

Question 11

What are Mutable References?

Accepted Answer

Mutable references (`&mut T`) allow you to read and modify the data they point to. A key borrowing rule is that you can have *only one* mutable reference to a particular piece of data in a given scope.

Question 12

Explain Borrowing Rule 1.

Accepted Answer

At any given time, you can have either *one mutable reference* OR *any number of immutable references* to a particular piece of data. You cannot have both simultaneously.

Question 13

Explain Borrowing Rule 2.

Accepted Answer

References must always be valid. This means a reference cannot outlive the data it points to. Rust's compiler (the borrow checker) enforces this to prevent dangling references.

Question 14

How do Rust's borrowing rules prevent data races?

Accepted Answer

Data races occur when two or more pointers access the same memory at the same time, at least one is writing, and there's no synchronization. Rust's borrowing rules prevent this by ensuring that you can either have multiple readers (immutable references) OR one writer (mutable reference), but never both simultaneously, thus guaranteeing exclusive access for writes.

Question 15

What are Lifetimes in Rust?

Accepted Answer

Lifetimes are a generic parameter that the Rust compiler uses to ensure references are valid for as long as they're needed. They describe the scope for which a reference is valid and are primarily used when references are stored in structs or passed into/returned from functions.

Question 16

Why are Lifetimes needed?

Accepted Answer

Lifetimes are needed to prevent dangling references at compile time. They help the borrow checker understand how long references are valid and ensure that no reference outlives the data it points to, even across function calls or within complex data structures.

Question 17

Illustrate lifetime annotations in a function signature.

Accepted Answer

```rust
fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {
    if x.len() > y.len() {
        x
    } else {
        y
    }
}
// The lifetime parameter 'a indicates that the returned reference
// will live for the shorter of the two input references' lifetimes.
```

Question 18

Illustrate lifetime annotations in a struct.

Accepted Answer

```rust
struct ImportantExcerpt<'a> {
    part: &'a str,
}

fn main() {
    let novel = String::from("Call me Ishmael. Some years ago...");
    let first_sentence = novel.split('.').next().expect("Could not find a '.'");
    let i = ImportantExcerpt { part: first_sentence };
    // The 'a ensures that the ImportantExcerpt cannot outlive 'novel'.
}
```

Question 19

What is the `'static` lifetime?

Accepted Answer

The `'static` lifetime denotes that a reference can live for the entire duration of the program. String literals (`&'static str`) have the `'static` lifetime, as they are often embedded directly into the program's binary.

Question 20

What are Slices (`&[T]`)?

Accepted Answer

Slices are references to a contiguous sequence of elements in a collection, like an array or `Vec`. They allow you to borrow a portion of a collection without taking ownership, providing a safe and efficient way to work with parts of data.

Question 21

What is `Box<T>` and when is it used?

Accepted Answer

`Box` is a smart pointer that allocates data on the heap. It's used when you have data of unknown size at compile time (e.g., recursive types), or when you want to transfer ownership of heap-allocated data. `Box` provides single ownership.

Question 22

What is `Rc<T>` and when is it used?

Accepted Answer

`Rc<T>` (Reference Counted) is a smart pointer that enables multiple ownership of data on the heap. It keeps a count of its references, and the data is dropped only when the count reaches zero. It's used for single-threaded scenarios where multiple parts of your program need to own the same data.

Question 23

What is `Arc<T>` and when is it used?

Accepted Answer

`Arc` (Atomic Reference Counted) is similar to `Rc` but is safe to use across multiple threads. It uses atomic operations for its reference count, ensuring thread safety. It's essential for sharing ownership of data between threads.

Question 24

What is Interior Mutability in Rust?

Accepted Answer

Interior mutability is a design pattern in Rust that allows you to mutate data even when you have an immutable reference to it. This is achieved using smart pointers like `RefCell` (for single-threaded) or `Mutex` (for multi-threaded), which enforce borrowing rules at runtime instead of compile time.

Question 25

When would you use `RefCell<T>`?

Accepted Answer

`RefCell<T>` is used for interior mutability in single-threaded contexts. It allows you to get a mutable reference to data even when you only have an immutable reference to the `RefCell`. It enforces Rust's borrowing rules at runtime, panicking if violated.

Rust - Ownership, Borrowing & Lifetimes: Memory Safety Concepts

Cards in this deck

Related Flashcard Sets

German B1 - Intermediate Conversational Phrases & Structures

French A1/A2 - Essential Grammar & Vocab

Neuroscience - Neurotransmitters & Synaptic Transmission

CFA Level 1 - Equity Investments & Valuation