Ownership

Introduction

Rust is a systems programming language that emphasizes safety, speed, and concurrency. One of its core features is the ownership model, which helps manage memory without a garbage collector. This tutorial will introduce you to Rust's ownership system, explaining how it works and how to use it effectively.

Concept

Ownership in Rust is a set of rules that the compiler enforces to ensure memory safety. The main idea is that each value in Rust has an owner, and there can only be one owner at a time. When the owner goes out of scope, the value is dropped (i.e., its memory is freed).

Ownership Rules

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

These rules might seem restrictive at first, but they help prevent common programming errors such as null pointer dereferencing and data races.

Examples

Let's explore some examples to understand how ownership works in practice.

Example 1: Basic Ownership

fn main() {
    let s = String::from("hello"); // s comes into scope

    println!("{}", s); // We can use s here

} // The scope is now over, and s is no longer valid

In this example, s is a string that comes into scope. When the function ends, s goes out of scope, and Rust automatically deallocates the memory.

Example 2: Ownership Transfer

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

    println!("{}", s2); // We can use s2 here
    // println!("{}", s1); // This would cause a compile-time error because s1 no longer owns the data
}

Here, when we assign `s1` to `s2`, ownership of the string is transferred from `s1` to `s2`. After this assignment, `s1` is no longer valid.

### Example 3: Clone

If you want to have two variables with the same data, you can use the `clone` method:

```rust
fn main() {
    let s1 = String::from("hello");
    let s2 = s1.clone(); // s2 is a copy of s1

    println!("s1 = {}, s2 = {}", s1, s2); // Both are valid and can be used
}

Using `clone` creates a deep copy of the data, so both variables have their own separate memory.

### Example 4: Ownership in Functions

Ownership rules also apply to functions:

```rust
fn main() {
    let s = String::from("hello");
    takes_ownership(s); // s's value moves into the function...
                         // ... and is no longer valid here

    let x = 5;
    makes_copy(x); // x would move into the function,
                   // but i32 is Copy, so it’s okay to still use x afterward
}

fn takes_ownership(some_string: String) { // some_string comes into scope
    println!("{}", some_string);
} // Here, some_string goes out of scope and `drop` is called. The memory is freed.

fn makes_copy(some_integer: i32) { // some_integer comes into scope
    println!("{}", some_integer);
} // Here, some_integer goes out of scope. Nothing special happens.

In this example, when we pass a variable to a function, ownership is transferred unless the type implements the Copy trait.

What's Next?

Now that you understand the basics of ownership in Rust, the next step is to learn about borrowing. Borrowing allows you to refer to data without taking ownership, providing more flexibility while maintaining safety. Stay tuned for the next section on borrowing!