Xiaomao's blog

Advent of Rust 2024: Day 1 - Rust's Ownership🦀

Xiaomao's photo
Xiaomao
·

2 min read

Table of contents

The Original Challenge

fn main() {    
    let gift_message = String::from("Merry Christmas! Enjoy your gift!");    
    attach_message_to_present(gift_message);     
    println!("{}", gift_message);
} 

fn attach_message_to_present(message: String) {    
    println!("The present now has this message: {}", message);
}

Why Does This Code Fail?

In Rust, every value has a single owner. When gift_message is passed to the attach_message_to_present() function, something strict happens:

  1. Ownership Transfer: The message parameter takes complete ownership of the gift_message string.

  2. Resource Management: Once ownership is transferred, the original variable becomes invalid.

  3. Memory Safety: Rust prevents you from accidentally using a value that has been moved.

Think of a special gift tag. When you pass the gift to someone else, you can no longer use that original tag. That’s how ownership works in Rust. You could use the variable in most languages again, but Rust says, "Nope, that's not how we do things here!"

Solving the Puzzle: .clone() to the Rescue

fn main() {
    let gift_message = String::from("Merry Christmas! Enjoy your gift!");
    attach_message_to_present(gift_message.clone()); 
    println!("{}", gift_message);
}

What is Cloning?

Cloning creates a complete, independent copy of your data. It's like creating an exact duplicate of a gift, so you can send one to a friend while keeping an identical one for yourself.

Memory Implications of .clone()

It allocates new memory and creates a deep copy of the entire string.

It’s also slightly more expensive than simple operations.

One last important thing is that it guarantees two separate, owned values.

When to Use .clone()

.clone() can be used in rare scenarios where you need multiple independent copies, when prototyping, e.t.c

In production code, more efficient patterns exist like references, borrowing and Smart pointers like Rc or Arc

Rust's Ownership:

Read more about rust’s ownership here: https://doc.rust-lang.org/book/ch04-01-what-is-ownership.html

https://github.com/wamimi/adventofrust/blob/master/src/bin/day1.rs

Reflection(my opinions)

Ownership is not a limitation but a feature

.clone() is a learning tool, not a production solution -_-

RustAdventOfCode2024
Â