Ownership

Question 1

How does the stack store values?

Answer 1

In the order it gets them and removes the values in the opposite order.

Question 2

Why is the stack fast?

Answer 2

It never has to search for it because it is always at the top. The data on the stck must also take up a known fixed size.

Question 3

What data is suitable to be stored on the heap?

Answer 3

Data with a size unknown at compile time or a size that might change.

Question 4

Is pushing data on the stack considered allocating?

Answer 4

No

Question 5

Why is accessing data on the heap slower than on the stack?

Answer 5

Because you have to follow a pointer to get to the location.

Question 6

When you call a function, the values passed into the function (including pointers to data on the heap) and the functions local variables get pushed onto the ____.

Answer 6

Stack

Question 7

What does ownership address?

Answer 7

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 8

Why does the concept of ownership exist?

Answer 8

To manage heap data.

Question 9

What are the three rules of ownership in rust?

Answer 9

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

Question 10

What is the scope of an item?

Answer 10

A scope is a range within a program for which an item is valid.

Question 11

Why are string literals fast and efficient?

Answer 11

The text is hard coded directly into the executable.

Question 12

Since rust doesn’t use a garbage collector, how does it keep track and clean up memory?

Answer 12

Memory is automatically returned once the variable that owns it goes out of scope.

Question 13

What is the name of the function that is called when a variable goes out of scope?

Answer 13

Drop

Question 14

How is a String stored on the stack?

Answer 14

Ptr |*
Len |
Capacity|

Question 15

If s1 and s2 both point to the same content on the heap, what happens when both s1 and s2 go out of scope? Is this allowed in rust?

Answer 15

They will both try to free the same memory. This is known as double free error. Rust will invalidate the first variable when the second is assigned to it. This is called a move (similar to a shallow copy).

Question 16

Will rust ever automatically create a deep copy of data on the heap?

Answer 16

No, a deep copy must explicitly call the clone method.

Question 17

How do you know if some arbitrary code is being executed and that code may be expensive?

Answer 17

It’s calling the clone method.

Question 18

When is a items stored on the stack?

Answer 18

Items that have a known size at compile time are stored on the stack. In this case there is no difference between a shallow and deep copy and a copy will not invalidate the original variable.

Question 19

If an older variable is still usable after assignment then the type must use which trait?

Answer 19

Copy trait

Question 20

You cannot annotate a type with the Copy trait if the type, or any of its parts, has implemented which trait?

Answer 20

Drop

Question 21

True or False: passing a variable to a function will move or copy m, just as assignment does.

Answer 21

True

Question 22

Describe the pattern of ownership.

Answer 22

1. Assigning a value to another variable moves it.
2. When a variable that includes data on the heap goes out of scope the value will be cleans up by drop unless the data has been moved to be owned by another variable.

Question 23

What do references allow you to do?

Answer 23

They allow you to refer to some value without taking ownership of it.

Question 24

If you have a reference to a variable will the item being referenced be dropped when the reference goes out of scope?

Answer 24

No

Question 25

What do you call references as functional parameters?

Answer 25

Borrowing

Question 26

What happens if you try to modify something that is borrowed?

Answer 26

It won’t work. You need a mutable reference.

Question 27

What is the main restriction of a mutable reference?

Answer 27

You can have only one mutable reference to a particular piece of data in a particular scope.

Question 28

What is the benefit of restricting mutable references?

Answer 28

Rust can prevent data races at compile time.

Question 29

Why are multiple immutable references ok?

Answer 29

Because no one who is reading the data has the ability to affect anyone else’s reading of the data.

Question 30

Can you have a single mutable reference with multiple immutable references?

Answer 30

No

Question 31

What is a dangling pointer?

Answer 31

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

Question 32

How does rust ensure that there will be no dangling pointers?

Answer 32

If you have 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 33

What are the rules of references?

Answer 33

1. At any time you can have either but not both of the of the following: one mutable reference or any number of immutable references
2. References must always be valid

Question 34

What does a slice enable you to do?

Answer 34

Let you reference a contiguous sequence of elements in a collection rather than the whole collection.

Question 35

list the common issues that ownership solves:

Answer 35

1. Double free error - solved by moving
2. Data races - restriction on mutable references
3. Dangling pointers - data will not go out of scope before the reference to the data does