In this lesson, you will learn how to promote a temporary borrowed view of data into an independent, owned piece of memory using cloning.
The Limitation of Borrowing
As we’ve discussed, references (&T) are like "read-only windows" into someone else’s data. Because the reference does not own the memory, it cannot outlive the original owner, nor can it modify the data if the owner is immutable. Sometimes, however, you have a reference but need to store that data somewhere else—like inside a new struct or a collection—where you require your own copy of that information to keep past the current scope.
From View to Owner
When you have a reference but need an owner, you must perform a "deep copy." In Rust, we explicitly perform this transition using the .clone() method.
Think of a reference as a guest looking at a painting in a gallery. You can admire it, but you don't own it. If you want to take that painting home, you must commission an artist to create an exact replica. Once that replica is finished, you own it entirely.
Consider this example:
fn main() {
let original_string = String::from("Hello, Rust!");
let reference = &original_string; // We have a view of the data
// We transition from a reference to an owned type:
let owned_copy = reference.clone();
// Now 'owned_copy' is its own variable, independent of 'original_string'
println!("I own: {}", owned_copy);
}
Why this matters
By using .clone(), you take the data that a reference is pointing to and allocate new memory on the heap. The original owner keeps its memory, and you get a fresh, independent heap allocation. This transition is crucial because it allows you to break free from the constraints of the borrow checker. You are no longer tethered to the lifetime of the original variable because you now possess your own independent copy that you are responsible for cleaning up.
Key Takeaway: When you need to transform a borrowed reference into an owned value, use .clone() to perform a deep copy, effectively creating a new allocation that you fully control.