```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

```

Ownership and Functions - Rust Programming

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

    // This line would cause a compile error,
    //  as s1 is no longer valid
    // println!("{}", s1);
    println!("{}", s2);
}
```

University of Michigan - Ann Arbor

Ownership is central and unique concept to the Rust programming language, and it refers to the way in which the ownership of resources (such as memory) is managed.
   Each value has a single owner, and when the owner goes out of scope, the value is automatically dropped. This ensures that there are no unused pointers or *use-after-free* errors, which can lead to crashes or security vulnerabilities in other programming languages.

Learn Before

Related

Learn After