Rust Programming Language - Ownership, Borrowing & Lifetimes Flashcards

Question 1

What are the three fundamental Ownership Rules in Rust?

Accepted Answer

1. Each value in Rust has an **owner** (a variable).
2. There can only be **one owner** at a time.
3. When the owner goes out of **scope**, the value is automatically dropped.

Question 2

What is a Scope in Rust and how does it affect variables?

Accepted Answer

A scope is a block of code enclosed by curly braces `{}`. When a variable enters scope, it becomes valid. When it exits scope, Rust calls the `drop` function to free its memory immediately.

Question 3

What are Move Semantics in Rust?

Accepted Answer

When a non-`Copy` variable is assigned to another variable, passed to a function, or returned, ownership of the resource transfers to the new owner. The original variable is invalidated and cannot be accessed.

Question 4

What is the `Copy` trait in Rust?

Accepted Answer

A marker trait for types whose values exist entirely on the stack and can be duplicated via a cheap bitwise copy. Types implementing `Copy` (e.g., `i32`, `bool`, `char`) do not transfer ownership on assignment.

Question 5

What is the difference between the `Copy` and `Clone` traits?

Accepted Answer

`Copy` is implicit and performs an inexpensive bitwise copy for stack-allocated types. `Clone` is explicit, requiring a `.clone()` call, and can perform expensive deep copies of heap-allocated data (e.g., `String` or `Vec`).

Question 6

What is Borrowing in Rust?

Accepted Answer

Borrowing is creating a reference to a value rather than taking ownership of it. References allow temporary access to data without destroying or moving the original owner.

Question 7

What is an Immutable Reference (`&T`)?

Accepted Answer

An immutable reference allows reading data without modifying it. You can have **multiple immutable references** to the same data active at the same time, as long as no mutable reference exists.

Question 8

What is a Mutable Reference (`&mut T`)?

Accepted Answer

A mutable reference permits reading and modifying data. To prevent data races, you can have **only one mutable reference** to a piece of data in a given scope, with zero coexisting immutable references.

Question 9

What is the Reference Aliasing XOR Mutability Rule?

Accepted Answer

Rust enforces that for any resource at any given moment, you can have either **aliasing** (multiple immutable references `&T`) OR **mutability** (one exclusive reference `&mut T`), but **never both**.

Question 10

What is a Dangling Reference and how does Rust prevent it?

Accepted Answer

A dangling reference points to a memory address that has been deallocated. Rust's borrow checker prevents dangling references at compile time by ensuring references never outlive the data they reference.

Question 11

What is the Rust Borrow Checker?

Accepted Answer

A static analysis tool within the Rust compiler that verifies all borrowing rules, ownership moves, and reference lifetimes at compile time to guarantee memory safety without a garbage collector.

Question 12

What is a Lifetime in Rust?

Accepted Answer

A lifetime is a construct used by the Rust compiler to track the scope for which a reference remains valid. Lifetimes ensure that references never refer to memory that has already been dropped.

Question 13

What is Lifetime Elision?

Accepted Answer

A set of three deterministic compiler rules that automatically assign explicit lifetime annotations to common function signatures, saving developers from manually writing lifetime parameters.

Question 14

What are the three Lifetime Elision Rules?

Accepted Answer

1. Each input reference parameter gets its own implicit lifetime.
2. If there is exactly one input lifetime parameter, it is assigned to all output lifetimes.
3. If there are multiple input parameters and one is `&self` or `&mut self`, the lifetime of `self` is assigned to all output references.

Question 15

How do explicit Lifetime Annotations work in function signatures?

Accepted Answer

Explicit lifetimes use generic syntax starting with an apostrophe (e.g., `'a`). They describe the relationship between reference parameters:
```rust
fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {
    if x.len() > y.len() { x } else { y }
}
```
This specifies that the returned string reference lives as long as the smaller of input lifetimes `'a`.

Question 16

What is the `'static` lifetime?

Accepted Answer

The `'static` lifetime specifies that a reference can live for the entire duration of the program execution. Examples include string literals (`&'static str`) baked into the binary or global static variables.

Question 17

What are Non-Lexical Lifetimes (NLL)?

Accepted Answer

An enhancement to Rust's borrow checker where lifetimes end at the **last point of use** of a reference, rather than extending strictly to the end of the enclosing block scope (`{}`).

Question 18

What is the `Drop` trait and how does RAII work in Rust?

Accepted Answer

The `Drop` trait allows customizing code run when a value goes out of scope. Rust uses Resource Acquisition Is Initialization (RAII), automatically reclaiming resources (heap memory, sockets) via `drop(&mut self)`.

Question 19

What is Interior Mutability in Rust?

Accepted Answer

A design pattern allowing data mutation even when holding an immutable reference to that data. Types like `RefCell<T>` move borrow checking rules from compile time to **runtime**, panicking if rules are violated.

Question 20

What is the difference between `Rc` and `Arc`?

Accepted Answer

Both are reference-counting smart pointers for multiple ownership. `Rc` is non-thread-safe with single-threaded runtime overhead. `Arc` uses atomic operations for thread-safe shared ownership across multiple threads.

Rust Programming Language - Ownership, Borrowing & Lifetimes

Card Preview

Related Flashcard Sets

Midterm #1 Formulas

French A1 - Basic Greetings & Everyday Phrases

Molecular Biology - DNA Replication & Repair Mechanisms

Classical Mechanics - Newton's Laws & Energy Conservation