References and borrowing are essential concepts that work alongside ownership to allow safe memory access and efficient resource management. They allow you to use data without transferring ownership.

References and Borrowing - Rust Programming

```rust
fn main() {
    let s1 = String::from("hello");
    let s2 = takes_and_gives_back(s1);

    println!("{}", s2);
}

fn takes_and_gives_back(some_string: String) -> String {
    // some_string comes into scope
   
    // some_string is returned and
    // its ownership is transferred back to the caller
    some_string
}
```

University of Michigan - Ann Arbor

```rust
fn main() {
    let s1 = String::from("hello");
    // Ownership of s1 is moved to the function
    takes_ownership(s1);

    let x = 5;
    // i32 is a Copy type, so x is still
    // valid after the function call
    makes_copy(x);
}

fn takes_ownership(some_string: String) {
    println!("{}", some_string);
} // some_string goes out of scope
  // and the memory is freed

fn makes_copy(some_integer: i32) {
    println!("{}", some_integer);
} // some_integer goes out of scope,
  // but no resources need to be freed

```

Learn Before

Related

Learn After