Ownership and Borrowing in Rust

Introduction

Welcome to this lesson on Ownership and Borrowing in Rust. In previous lessons, we've established a strong foundation in core Rust concepts like structs, enums, generics and traits. Now, we'll delve into Rust's unique approach to memory safety: Ownership and Borrowing. Understanding these concepts is crucial as they form the backbone of safe and efficient programming in Rust, allowing you to write robust applications with confidence.

Memory Management in Rust

Before we dive in, let's briefly discuss how Rust manages memory using the stack and the heap : Stack : Used for storing data with a known, fixed size at compile time. It's fast for allocation and deallocation. Heap : Used for data that can change size or when the size is not known at compile time, like String . It requires explicit memory management. Ownership rules in Rust govern how heap-allocated data is managed, preventing issues like dangling pointers and data races at compile time.

Exploring Ownership in Rust

Ownership in Rust is a set of rules governing how a program manages memory. These rules ensure clean memory usage and prevent issues like dangling references. There are three main rules of ownership: Each value in Rust has a variable that's its owner. There can only be one owner at a time. When the owner goes out of scope, the value is dropped. Consider the following function that takes ownership of a String: Rustfn takes_ownership(some_string: String) { println!("Owned string: {}", some_string); }fn takes_ownership(some_string: String) { println!("Owned string: {}", some_string); } In this code: some_string takes ownership of the String parameter passed to it. The ownership moves to some_string, and when it goes out of scope at the end of the function, the String is dropped. For instance: Rustfn main() { let s = String::from("Hello"); takes_ownership(s); // 's' is no longer valid here as ownership has been transferred // println!("{}", s); // This would cause a compile-time error }fn main() { let s = String::from("Hello"); takes_ownership(s); // 's' is no longer valid here as ownership has been transferred // println!("{}", s); // This would cause a compile-time error } When takes_ownership is called, s is moved into the function and dropped when it leaves the scope. Attempting to use s after it has been moved results in a compile-time error, ensuring memory safety by preventing access to dropped data.

Copy vs Move Semantics

Join the 1M+ learners on CodeSignal

Be a part of our community of 1M+ users who develop and demonstrate their skills on CodeSignal

Rust

fn takes_ownership(some_string: String) {
    println!("Owned string: {}", some_string);
}

Rust

fn main() {
    let s = String::from("Hello");
    takes_ownership(s);
    // 's' is no longer valid here as ownership has been transferred
    // println!("{}", s); // This would cause a compile-time error
}

Rust

fn makes_copy(some_integer: i32) {
    // `i32` implements `Copy`, so it is duplicated, not moved.
    println!("Copied integer: {}", some_integer);
}
fn main() {
    let x = 5;
    makes_copy(x);
    // 'x' remains valid here because it is copied, not moved
    println!("x is still accessible: {}", x);
}

fn makes_copy(some_integer: i32) {
    // `i32` implements `Copy`, so it is duplicated, not moved.
    println!("Copied integer: {}", some_integer);
}
fn main() {
    let x = 5;
    makes_copy(x);
    // 'x' remains valid here because it is copied, not moved
    println!("x is still accessible: {}", x);
}

Rust

fn calculate_length(s: &String) -> usize {
    // &String allows read-only access to `s`
    s.len()
}

fn main() {
    let s1 = String::from("Hello");
    let len = calculate_length(&s1);
    println!("The length of '{}' is {}.", s1, len);
}

fn calculate_length(s: &String) -> usize {
    // &String allows read-only access to `s`
    s.len()
}

fn main() {
    let s1 = String::from("Hello");
    let len = calculate_length(&s1);
    println!("The length of '{}' is {}.", s1, len);
}

Rust

fn main() {
    let mut s = String::from("Hello");
    let r1 = &s;
    let r2 = &s;
    let r3 = &mut s; // Error: cannot borrow `s` as mutable because it is also borrowed as immutable
    println!("keeping {}, {} and {} in scope", r1, r2, r3);
}

fn main() {
    let mut s = String::from("Hello");
    let r1 = &s;
    let r2 = &s;
    let r3 = &mut s; // Error: cannot borrow `s` as mutable because it is also borrowed as immutable
    println!("keeping {}, {} and {} in scope", r1, r2, r3);
}

Rust

fn first_word(s: &String) -> &str {
    let bytes = s.as_bytes();
    for (i, &item) in bytes.iter().enumerate() {
        if item == b' ' {
            return &s[0..i];
        }
    }
    &s[..]
}

fn main() {
    let s = String::from("Hello world");
    let word = first_word(&s);
    println!("First word: {}", word);
}

fn first_word(s: &String) -> &str {
    let bytes = s.as_bytes();
    for (i, &item) in bytes.iter().enumerate() {
        if item == b' ' {
            return &s[0..i];
        }
    }
    &s[..]
}

fn main() {
    let s = String::from("Hello world");
    let word = first_word(&s);
    println!("First word: {}", word);
}

Rust

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

fn main() {
    let mut s2 = String::from("Hello");
    change(&mut s2);
    println!("After mutation: {}", s2);
}

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

fn main() {
    let mut s2 = String::from("Hello");
    change(&mut s2);
    println!("After mutation: {}", s2);
}

Rust

fn main() {
    let mut s = String::from("Hello");
    let r1 = &mut s;
    let r2 = &mut s; // Error: cannot borrow `s` as mutable more than once at a time
    println!("{}, {}", r1, r2);
}

fn main() {
    let mut s = String::from("Hello");
    let r1 = &mut s;
    let r2 = &mut s; // Error: cannot borrow `s` as mutable more than once at a time
    println!("{}, {}", r1, r2);
}

Rust

fn print_string(s: &String) {
    println!("{}", s);
}

fn print_string(s: &String) {
    println!("{}", s);
}

Rust

fn takes_ownership(s: String) {
    println!("Owned string: {}", s);
}

fn main() {
    let s = String::from("Hello");
    takes_ownership(s.clone());
    println!("Original string: {}", s);
}

fn takes_ownership(s: String) {
    println!("Owned string: {}", s);
}

fn main() {
    let s = String::from("Hello");
    takes_ownership(s.clone());
    println!("Original string: {}", s);
}

Rust

fn takes_boxed_string(s: Box<String>) {
    // Method calls work through deref coercion (Box<String> -> String)
    println!("Inside function: {}", s.as_str());
}

fn main() {
    let b = Box::new(String::from("Hello"));

    // Borrowing the boxed value (no ownership transfer)
    let len = calculate_length(&b); // &Box<String> coerces to &String
    println!("Length: {}", len);

    // Moving the box transfers ownership of the heap allocation
    takes_boxed_string(b);
    // println!("{:?}", b); // Error: use of moved value
}

fn takes_boxed_string(s: Box<String>) {
    // Method calls work through deref coercion (Box<String> -> String)
    println!("Inside function: {}", s.as_str());
}

fn main() {
    let b = Box::new(String::from("Hello"));

    // Borrowing the boxed value (no ownership transfer)
    let len = calculate_length(&b); // &Box<String> coerces to &String
    println!("Length: {}", len);

    // Moving the box transfers ownership of the heap allocation
    takes_boxed_string(b);
    // println!("{:?}", b); // Error: use of moved value
}

Rust

fn makes_copy(some_integer: i32) {
    // `i32` implements `Copy`, so it is duplicated, not moved.
    println!("Copied integer: {}", some_integer);
}
fn main() {
    let x = 5;
    makes_copy(x);
    // 'x' remains valid here because it is copied, not moved
    println!("x is still accessible: {}", x);
}

Rust

fn calculate_length(s: &String) -> usize {
    // &String allows read-only access to `s`
    s.len()
}

fn main() {
    let s1 = String::from("Hello");
    let len = calculate_length(&s1);
    println!("The length of '{}' is {}.", s1, len);
}

Rust

fn main() {
    let mut s = String::from("Hello");
    let r1 = &s;
    let r2 = &s;
    let r3 = &mut s; // Error: cannot borrow `s` as mutable because it is also borrowed as immutable
    println!("keeping {}, {} and {} in scope", r1, r2, r3);
}

Rust

fn first_word(s: &String) -> &str {
    let bytes = s.as_bytes();
    for (i, &item) in bytes.iter().enumerate() {
        if item == b' ' {
            return &s[0..i];
        }
    }
    &s[..]
}

fn main() {
    let s = String::from("Hello world");
    let word = first_word(&s);
    println!("First word: {}", word);
}

Rust

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

fn main() {
    let mut s2 = String::from("Hello");
    change(&mut s2);
    println!("After mutation: {}", s2);
}

Rust

fn main() {
    let mut s = String::from("Hello");
    let r1 = &mut s;
    let r2 = &mut s; // Error: cannot borrow `s` as mutable more than once at a time
    println!("{}, {}", r1, r2);
}

Rust

fn print_string(s: &String) {
    println!("{}", s);
}

Rust

fn takes_ownership(s: String) {
    println!("Owned string: {}", s);
}

fn main() {
    let s = String::from("Hello");
    takes_ownership(s.clone());
    println!("Original string: {}", s);
}

Rust

fn takes_boxed_string(s: Box<String>) {
    // Method calls work through deref coercion (Box<String> -> String)
    println!("Inside function: {}", s.as_str());
}

fn main() {
    let b = Box::new(String::from("Hello"));

    // Borrowing the boxed value (no ownership transfer)
    let len = calculate_length(&b); // &Box<String> coerces to &String
    println!("Length: {}", len);

    // Moving the box transfers ownership of the heap allocation
    takes_boxed_string(b);
    // println!("{:?}", b); // Error: use of moved value
}

Introduction

Memory Management in Rust

Exploring Ownership in Rust

Copy vs Move Semantics

Join the 1M+ learners on CodeSignal

Borrowing with References

Slices: Borrowing Sections of Data

Working with Mutable References

Common Ownership Patterns

Smart Pointers

Summary and Preparation for Practice