# Ownership, References, and Borrowing

https://doc.rust-lang.org/book/print.html#ownership-and-functions

• Ownership rules

• Each value on the heap has a (variable) owner.
• Only one owner at a given time.
• The value is dropped (collected?) when the owner goes out of scope.
• Here, s2 is taking ownership of the String that s1 points to, so s1 can no longer be used.

let s1 = String::from("hello");
let s2 = s1;
// Compile-time error if s1 is used here.

• Here we’re only dealing with data on the stack, so no ownership rules apply:

let x = 5;
let y = x;

• Ownership is transferred during function calls too:

fn main() {
let s = String::from("hello");

// s is no longer valid after this line; takes_ownership owns it now
takes_ownership(s);
}

• Ownership can be transferred back to the caller via return value(s):

fn main() {
let s = String::from("hello");

// s is no longer valid here, but s2 is.
let s2 = takes_and_returns_ownership(s);
}

• This is too cumbersome to do everytime you want to use a value without necessarily owning it. What if we want to let a function use a value but not take ownership?

• Rust fixes this with references.

fn main() {
let s1 = String::from("hello");

// calculate_length gets a reference to s1, and so doesn't own s1.
let len = calculate_length(&s1);
println!("The length of '{}' is {}.", s1, len);
}

fn calculate_length(s: &String) -> usize {
s.len()
}

• Having references as function parameters is called borrowing.

• A function that accepts a reference can’t modify the data it refers to, unless it’s a mutable reference:

fn main() {
let mut s = String::from("hello");
change(&mut s);
}

fn change(some_string: &mut String) {
some_string.push_str(", world");
}

• There are rules around mutable references, though, which allows Rust to avoid data races at compile time:

• You can have only one mutable reference to a particular piece of data in a particular scope.
• You cannot have a mutable reference while you have an immutable one (in a particular scope).
• Effectively, this is “either one mutable reference or many immutable references are allowed in a given scope”.
• A reference’s scope starts from where it is introduced and continues through the last time that reference is used, so scopes are not necessarily denoted by {}.

fn main() {
let mut s = String::from("hello");

let r1 = &s;
let r2 = &s;
println!("{} and {}", r1, r2);
// r1 and r2's scope _implicitly_ ends here

// so this is fine
let r3 = &mut s;
println!("{}", r3);
}

Edit