Understanding Ownership with Structs and Functions in Rust

Rust's ownership model is one of its most powerful—and sometimes intimidating—features. If you're diving into Rust, you've likely encountered its strict rules around ownership, borrowing, and lifetimes. While these rules might feel restrictive at first, they empower Rust to provide memory safety without a garbage collector. In this post, we'll tackle a key question: How does ownership work when passing structs to and from functions?

We'll explore the nuances of ownership as it applies to structs, comparing move, borrow, and mutable borrow in function arguments. By the end, you'll have a solid understanding of how to use these concepts effectively and avoid common pitfalls.

Why Does Ownership Matter?

Before we dive into structs and functions, let’s quickly revisit why ownership matters. Ownership is Rust's way of ensuring memory safety. It defines three core principles:

1. Each value in Rust has a single owner.
2. When the owner goes out of scope, the value is dropped.
3. Ownership can be transferred (moved) or temporarily shared (borrowed).

When working with structs, these rules govern how data is passed around in your program. Misunderstanding ownership can lead to issues like dangling references or double frees, which Rust prevents at compile time.

The Basics of Ownership with Structs

Imagine you have a struct representing a user profile:

#[derive(Debug)]
struct User {
    name: String,
    age: u32,
}

This struct contains a String (heap-allocated) and a u32 (stack-allocated). Understanding how ownership works with this struct is critical for designing efficient and safe Rust code.

Passing Structs to Functions: Move, Borrow, Mutable Borrow

When passing a struct to a function, you have three main options:

1. Move (Ownership Transfer)

When you pass a struct by value, ownership of the struct is transferred to the function. This means the original variable is no longer valid after the function call.

Here’s an example:

fn print_user(user: User) {
    println!("User: {:?}", user);
}

fn main() {
    let user = User {
        name: String::from("Alice"),
        age: 30,
    };

    print_user(user); // Ownership of `user` is moved to the function
    // println!("{:?}", user); // Error: `user` has been moved
}

In this case:

• user is moved into the function print_user.
• After the function call, user is no longer accessible in main.

When to Use Move

Use move when:

• The function needs full ownership of the data (e.g., to modify or consume it).
• You don’t need the original variable after the function call.

Downsides

• Once ownership is moved, the original variable becomes unusable.

2. Borrow (Immutable Reference)

If you don’t want to transfer ownership, you can borrow the struct by passing an immutable reference (&User). This allows the function to read the struct without taking ownership.

Here’s how it works:

fn print_user(user: &User) {
    println!("User: {:?}", user);
}

fn main() {
    let user = User {
        name: String::from("Alice"),
        age: 30,
    };

    print_user(&user); // Borrow the struct
    println!("{:?}", user); // `user` is still accessible here
}

In this case:

• The function receives a reference to user, not the actual value.
• The original user remains accessible after the function call.

When to Use Borrow

Use immutable borrowing when:

• The function only needs to read the data.
• You want to retain access to the original variable after the function call.

Downsides

• The function cannot modify the borrowed data.

3. Mutable Borrow

If the function needs to modify the struct but you still want to retain ownership, you can pass a mutable reference (&mut User).

Here’s an example:

fn update_user(user: &mut User) {
    user.age += 1;
    user.name.push_str(" (updated)");
}

fn main() {
    let mut user = User {
        name: String::from("Alice"),
        age: 30,
    };

    update_user(&mut user); // Mutable borrow
    println!("{:?}", user); // The struct is updated
}

In this case:

• The function receives a mutable reference to user.
• The function can modify the struct.
• Ownership is not transferred, so user is still accessible after the function call.

When to Use Mutable Borrow

Use mutable borrowing when:

• The function needs to modify the data.
• You want to retain ownership of the variable.

Downsides

• You can only have one mutable reference at a time, preventing data races.

Common Pitfalls and How to Avoid Them

Rust’s ownership rules are strict, and it’s easy to run into compile-time errors when you’re starting out. Let’s look at a few common pitfalls:

1. Dangling References

Rust ensures references are always valid, but it’s important to understand lifetimes. Here’s an example that won’t compile:

fn create_user<'a>() -> &'a User {
    let user = User {
        name: String::from("Alice"),
        age: 30,
    };
    &user // Error: `user` does not live long enough
}

Why? The user struct is dropped when the function ends, so returning a reference to it would create a dangling reference.

Fix: Return the struct itself or use smart pointers (e.g., Box, Rc, or Arc) for heap allocation.

2. Borrowing While Moved

You cannot use a variable after its ownership has been moved:

fn main() {
    let user = User {
        name: String::from("Alice"),
        age: 30,
    };

    let user_ref = &user; // Borrow
    print_user(user); // Move
    println!("{:?}", user_ref); // Error: `user` was moved
}

Fix: Ensure you don’t mix borrowing and ownership transfer in conflicting ways.

3. Multiple Mutable Borrows

You cannot have more than one mutable reference at a time:

fn main() {
    let mut user = User {
        name: String::from("Alice"),
        age: 30,
    };

    let user_ref1 = &mut user;
    let user_ref2 = &mut user; // Error: cannot borrow `user` as mutable more than once

    println!("{:?}", user_ref1);
}

Fix: Ensure only one mutable borrow exists at any given time.

Key Takeaways

1. Ownership is central to Rust’s safety guarantees. Understanding how structs interact with functions is critical.
2. Move transfers ownership, borrow allows shared access, and mutable borrow allows modification. Each has its use case.
3. Be mindful of common pitfalls like dangling references and multiple mutable borrows.
4. Rust’s compiler is your friend. If something doesn’t compile, it’s often a sign of unsafe behavior you need to address.

What’s Next?

Understanding ownership with structs is just the beginning. Here are some next steps to deepen your knowledge:

• Explore lifetimes to understand how references are tied to scopes.
• Learn about smart pointers like Box, Rc, and Arc for advanced memory management.
• Practice by designing real-world applications, such as implementing a task manager or a web server.

Rust’s ownership model might feel challenging at first, but it’s what makes Rust one of the safest systems programming languages. Keep practicing, and you’ll soon write code that’s not only safe but also efficient and elegant.

Happy coding! 🚀