Skip to main content
In this lesson, we explore the interaction between variables and data cloning in Rust. Rust employs a move mechanism to safeguard memory by transferring ownership between variables. However, situations arise where you need to retain access to the original data while creating an independent duplicate. This is where the clone trait becomes essential. Rust’s clone trait explicitly generates deep copies of data. It is particularly useful for duplicating heap-allocated resources that cannot be managed through a simple bitwise copy. In contrast, the copy trait is reserved for types stored entirely on the stack—such as integers, floats, and simple tuples—that support inexpensive shallow copies.
The image explains the "Clone trait" in Rust, illustrating how value ownership is moved from Variable A to Variable B, emphasizing the need to retain access to original data while creating an independent copy.
For any type that implements the clone trait, a concrete implementation of the clone method is required. This method returns a deep copy of the instance. Here is the definition of the clone trait: 
pub trait Clone {
    fn clone(&self) -> Self;
}
Unlike the copy trait—which merely duplicates the bits—clone performs a deep replication of the data. This means that for types managing heap data or other resources (like strings), a new allocation is created with the same contents.
  • The copy trait is used for types that do not manage heap memory (e.g., integer types).
  • The clone trait is essential for types that allocate memory on the heap or hold other resources, ensuring each copy has its own independent allocation.
The image is a comparison between "Copy" and "Clone" in programming, highlighting that "Copy" involves a shallow copy of bits, while "Clone" involves a deep copy of heap data.

​
Practical Examples

Consider the following examples to understand the difference between copying and cloning in Rust. The type i32 implements the Copy trait, so its value is automatically copied during assignments. On the other hand, a String requires an explicit call to clone to create an independent copy. 
fn main() {
    // Example using Copy trait
    let x = 5; // i32 implements Copy
    let y = x; // x is copied to y
    println!("x: {}, y: {}", x, y); // Both x and y are valid

    // Example using Clone trait
    let s1 = String::from("hello");
    let s2 = s1.clone(); // Explicitly clone s1 to create an independent copy
    println!("s1: {}, s2: {}", s1, s2); // Both s1 and s2 are valid
}
In the code above, the variable x (of type i32) is effortlessly copied, allowing both x and y to be used independently. For the String type, invoking s1.clone() explicitly creates an independent duplicate, ensuring that both s1 and s2 point to different heap allocations. When you create a string using String::from, memory is allocated on the heap. The string consists of a pointer, its length, and its capacity. Invoking clone on a string allocates new memory and copies the content from the original string. Thus, the new string, s2, has its own pointer, length, and capacity.
The image is a flowchart detailing the process of cloning a string in programming, including steps for string creation and cloning with memory allocation.

​
Summary

This lesson covered the distinctions between moving, copying, and cloning data in Rust. Proper understanding of when to use the clone trait is crucial for working with heap-allocated resources and ensuring memory safety. For more detailed insights, explore Rust’s Ownership and Borrowing. Happy coding with Rust!

Watch Video