References and Borrowing

4 minutes
Share the link to this page
Copied
  Completed
You need to have access to the item to view this lesson.
One-time Fee
$69.99
List Price:  $99.99
You save:  $30
€64.94
List Price:  €92.78
You save:  €27.83
£55.57
List Price:  £79.40
You save:  £23.82
CA$95.27
List Price:  CA$136.11
You save:  CA$40.83
A$107.88
List Price:  A$154.13
You save:  A$46.24
S$94.55
List Price:  S$135.08
You save:  S$40.52
HK$547.57
List Price:  HK$782.28
You save:  HK$234.71
CHF 63.42
List Price:  CHF 90.61
You save:  CHF 27.18
NOK kr759.63
List Price:  NOK kr1,085.23
You save:  NOK kr325.60
DKK kr484.38
List Price:  DKK kr692.01
You save:  DKK kr207.62
NZ$117.46
List Price:  NZ$167.80
You save:  NZ$50.34
د.إ257.02
List Price:  د.إ367.19
You save:  د.إ110.16
৳7,682.93
List Price:  ৳10,976.08
You save:  ৳3,293.15
₹5,837.41
List Price:  ₹8,339.52
You save:  ₹2,502.10
RM331.26
List Price:  RM473.25
You save:  RM141.99
₦99,285.71
List Price:  ₦141,842.81
You save:  ₦42,557.10
₨19,466.20
List Price:  ₨27,810.04
You save:  ₨8,343.84
฿2,553.28
List Price:  ฿3,647.70
You save:  ฿1,094.41
₺2,262.39
List Price:  ₺3,232.12
You save:  ₺969.73
B$349.43
List Price:  B$499.21
You save:  B$149.77
R1,335.92
List Price:  R1,908.54
You save:  R572.62
Лв126.45
List Price:  Лв180.65
You save:  Лв54.20
₩94,634.34
List Price:  ₩135,197.71
You save:  ₩40,563.37
₪258.03
List Price:  ₪368.63
You save:  ₪110.60
₱3,943.57
List Price:  ₱5,633.91
You save:  ₱1,690.34
¥10,600.67
List Price:  ¥15,144.47
You save:  ¥4,543.79
MX$1,161.53
List Price:  MX$1,659.40
You save:  MX$497.87
QR255
List Price:  QR364.31
You save:  QR109.30
P959.59
List Price:  P1,370.91
You save:  P411.31
KSh9,203.68
List Price:  KSh13,148.68
You save:  KSh3,945
E£3,310.52
List Price:  E£4,729.52
You save:  E£1,419
ብር3,976.27
List Price:  ብር5,680.63
You save:  ብር1,704.36
Kz58,526.41
List Price:  Kz83,612.74
You save:  Kz25,086.33
CLP$68,581.80
List Price:  CLP$97,978.20
You save:  CLP$29,396.40
CN¥506.04
List Price:  CN¥722.95
You save:  CN¥216.90
RD$4,144.87
List Price:  RD$5,921.50
You save:  RD$1,776.62
DA9,443.17
List Price:  DA13,490.83
You save:  DA4,047.65
FJ$158.28
List Price:  FJ$226.12
You save:  FJ$67.84
Q545.87
List Price:  Q779.86
You save:  Q233.98
GY$14,645.83
List Price:  GY$20,923.51
You save:  GY$6,277.68
ISK kr9,762.20
List Price:  ISK kr13,946.60
You save:  ISK kr4,184.40
DH709.20
List Price:  DH1,013.19
You save:  DH303.99
L1,234.28
List Price:  L1,763.34
You save:  L529.05
ден3,991.30
List Price:  ден5,702.11
You save:  ден1,710.80
MOP$564.10
List Price:  MOP$805.89
You save:  MOP$241.79
N$1,325.35
List Price:  N$1,893.44
You save:  N$568.09
C$2,576.69
List Price:  C$3,681.15
You save:  C$1,104.45
रु9,334.54
List Price:  रु13,335.63
You save:  रु4,001.09
S/259.58
List Price:  S/370.84
You save:  S/111.26
K267.89
List Price:  K382.72
You save:  K114.82
SAR262.49
List Price:  SAR375
You save:  SAR112.51
ZK1,765.85
List Price:  ZK2,522.76
You save:  ZK756.90
L322.98
List Price:  L461.43
You save:  L138.44
Kč1,645.46
List Price:  Kč2,350.75
You save:  Kč705.29
Ft25,709.21
List Price:  Ft36,729.02
You save:  Ft11,019.81
SEK kr749.87
List Price:  SEK kr1,071.30
You save:  SEK kr321.42
ARS$60,034.20
List Price:  ARS$85,766.82
You save:  ARS$25,732.62
Bs483.70
List Price:  Bs691.04
You save:  Bs207.33
COP$271,296.95
List Price:  COP$387,583.68
You save:  COP$116,286.73
₡35,581.11
List Price:  ₡50,832.34
You save:  ₡15,251.22
L1,728.07
List Price:  L2,468.78
You save:  L740.71
₲516,441.87
List Price:  ₲737,805.73
You save:  ₲221,363.85
$U2,647.22
List Price:  $U3,781.90
You save:  $U1,134.68
zł280.50
List Price:  zł400.73
You save:  zł120.23
Already have an account? Log In

Transcript

Now that we've gone over ownership, we can talk about references and borrowing. Instead of moving our variable, let's use a reference. Here's our do stuff function again, only this time it takes a reference to a string. The ampersand before the type indicates a reference to type. When we call do stuff, we pass it a reference to s one. And s one retains ownership of the value, do stuff borrows a reference to the value, the reference not the value gets moved into the function.

At the end of the function, the reference goes out of scope and the reference gets dropped. So our borrowing ends at that point. After the function call, we can use s one like normal because the value never moved. Under the hood, when we create a reference to s one rust creates a pointer to s one. But you will almost never talk about pointers in rust because the language automatically handles their creation and design. For the most part and make sure they're always valid using a concept called lifetimes lifetimes can be summed up as a rule that references must always be valid, which means the compiler won't let you create a reference that outlives the data it is ultimately referencing and you can never point to no references default to immutable even if the value being referenced is immutable.

But if we make a mutable reference to a mutable value, then we can use the reference to change the value as well. The syntax for a mutable reference is a little special, ampersand, mute space, variable or type. Now wait, why didn't we have to dereference the mutable reference in order to alter s in the do stuff method? Look at this. We are using the same dot syntax to access a string method on a mutable reference, as we do for the value itself. How does that work?

The dot operator For a method or a field auto D references down to the actual value. So at least when you're dealing with a dot operator, you don't have to worry about whether something is a value or a reference or even a reference of a reference. If we manually dereferenced s, it would look like this. You use an asterisk immediately before a reference to dereference to the value similar to see, the dereference operator has pretty low precedence, so you'll sometimes need to use parentheses. With most other operators like the assignment operator, for example, you will need to manually dereference your reference if you want to read from or write to the actual value. Here, I'm dereferencing s so that I can replace the entire value.

So let's stop and go over what references look like. Again, if you have a variable x, then this creates an immutable reference to that variables value. And this creates a mutable reference to that variables value. Similarly with types, if this is the type of your value, then this is the type of your immutable reference. And this is the type of your mutable reference. going the other way around.

If your variable is a mutable reference to a value, then dereferencing x gives you mutable access to the value. And if x is an immutable reference to a value, then dereferencing x gives you immutable access to the value. Naturally, since references are implemented via pointers rust has a special rule to keep us safe. At any given time, you can have either exactly one mutable reference, or any number of immutable references. This rule applies across all threads. When you consider that references to a variable many exists in different threads.

It starts to make it pretty obvious why it's not safe to have multiple mutable references to the same variable at the same time without some type of locking But if all the references are immutable, then there's no problem. So you can have lots of immutable references spread across multiple threads. All these rules I've been talking about are enforced by the compiler. And by enforced I mean compiler errors, lots of compiler errors. At first, you're like, ah, I hate the compiler keeps giving me errors. But then as you get the hang of it, you realize you don't get mysterious seg faults anymore.

And the error messages are really pretty informative. And if the code compiles, it works and that is an amazing feeling. In the next video, we'll learn about structs

Sign Up

Share

Share with friends, get 20% off
Invite your friends to LearnDesk learning marketplace. For each purchase they make, you get 20% off (upto $10) on your next purchase.