Understanding Ownership

Question 1

How does Rust handle memory management?

Answer 1

Through a system of ownership with a set of rules that the compiler checks at compile time. None of the ownership features slow down your program while it’s running.

Question 2

Why is pushing to the Stack faster than allocating to the Heap?

Answer 2

On the Stack, the OS does not have to search for the data. Allocating space on the heap requires more work, because the OS must first find a big enough space to hold the data and then perform bookkeeping to prepare for the next allocation.

Question 3

What are some problems that ownership addresses?

Answer 3

1. Keeping track of what parts of code are using what data on the heap.
2. Minimizing the amount of duplicate data on the heap.
3. Cleaning up unused data on the heap so you don’t run out of space.

Question 4

What are the three ownership rules in Rust?

Answer 4

1. Each value in Rust has a variable that’s called its owner.
2. There can only be one owner at a time.
3. When the owner goes out of scope, the value will be dropped.

Question 5

When does memory become free?

Answer 5

When a variable that owns it goes out of scope.

Question 6

When a variable goes out of scope, what special function is called by Rust?

Answer 6

drop, it is called automatically at a closing curly brace (Resource Acquisition Is Initialization (RAII)).

Question 7

What is a move in Rust?

Answer 7

Transferring ownership of resources from one reference to another and invalidating the first reference.

Question 8

What does the clone method do?

Answer 8

Performs a deep copy of a variable and value from Stack and Heap.

Question 9

How is the Copy trait used?

Answer 9

Annotates types that are stored entirely on the Stack. If a type is annotated with Copy, an older variable is still usable after assignment.

Question 10

What is the pattern the value of a variable follows everytime?

Answer 10

Assigning the value to another variable moves it.

Question 11

When will a value be cleaned up by Drop?

Answer 11

When a variable that includes data on the heap goes out of scope, unless the value has been moved to be owned by another variable.

Question 12

What does the & represent?

Answer 12

A reference.

Question 13

What does a reference do?

Answer 13

Allow reference to some value without taking ownership of it.

Question 14

What is borrowing in Rust?

Answer 14

Having references as function parameters. When an function is passed a reference to a value.

Question 15

Are references mutable by default?

Answer 15

No.

Question 16

How many mutable references are allowed on a particular piece of data?

Answer 16

Exactly one.

Question 17

What is the benefit of allowing only one mutable reference for a particular piece of data?

Answer 17

Allows for prevention of data races at compile time.

Question 18

When does a data race occur?

Answer 18

when these three behaviors occur:

1. Two or more pointers access the same data at the same time.
2. At least one of the pointers is being used to write to the data.
3. There’s no mechanism being used to synchronize access to the data.

Question 19

Does Rust allow for simultaneous mutable and immutable references?

Answer 19

No.

Question 20

What is a dangling pointer?

Answer 20

A pointer that references a location in memory that may have been given to someone else, by freeing some memory while preserving a pointer to that memory.

Question 21

How does Rust prevent dangling pointers?

Answer 21

If there is a reference to some data, the compiler will ensure that the data will not go out of scope before the reference to the data does.

Question 22

What are the two rules for references?

Answer 22

1. At any given time, you can have either one mutable reference or any number of immutable references.
2. References must always be valid.

Question 23

Do Slice data types have ownership?

Answer 23

No.

Question 24

What do Slices allow for?

Answer 24

Referencing a contiguous sequence of elements in a collection rather than the whole collection.

Question 25

How do we create a Slice?

Answer 25

Using a range within brackets by specifying [starting_index..ending_index], where starting_index is the first position in the slice and ending_index is one more than the last position in the slice.

Question 26

What is Rust’s range syntax?

Answer 26

..