Moves, cloning, and copying - Rust for C-Programmers

6.2 Move Semantics, Cloning, and Copying

Rust primarily uses move semantics for data stored on the heap, while also providing cloning for explicit deep copies and a light copy trait for small, stack-only types. Let’s clarify a few terms first:

Move: Transferring ownership of a resource from one variable to another without duplicating the underlying data.
Shallow copy: Copying only the “outer” parts of a value (for example, a pointer) while leaving the heap-allocated data it points to untouched.
Deep copy: Copying both the outer data (such as a pointer) and the resource(s) on the heap to which it refers.

6.2.1 Move Semantics

In Rust, many types that manage heap-allocated resources (like String) employ move semantics. When you assign one variable to another or pass it to a function, ownership is moved rather than copied. Rust doesn’t create a deep copy—or even a shallow copy—of heap data by default; it simply transfers control of that data to the new variable. This ensures that only one variable is responsible for freeing the memory.

Rust Example

fn main() {
    let s1 = String::from("hello");
    let s2 = s1; // Ownership moves from s1 to s2
    // println!("{}", s1); // Error: s1 is no longer valid
    println!("{}", s2);    // Prints: hello
}

Once ownership moves to s2, s1 becomes invalid and cannot be used. Rust disallows accidental uses of s1, avoiding a class of memory errors upfront.

Comparison with C++ and C

In C++, assigning one std::string to another typically does a deep copy, creating a distinct instance with its own buffer. You must explicitly use std::move to achieve something akin to Rust’s move semantics:

#include <iostream>
#include <string>

int main() {
    std::string s1 = "hello";
    std::string s2 = std::move(s1); // Conceptually moves ownership to s2
    // std::cout << s1 << std::endl; // UB if accessed
    std::cout << s2 << std::endl;   // Prints: hello
    return 0;
}

In Rust, assigning s1 to s2 automatically moves ownership. By contrast, in C++, you must call std::move(s1) explicitly, and s1 is left in an unspecified state.

Meanwhile, C has no built-in ownership model. When two pointers reference the same block of heap memory, the compiler does not enforce which pointer frees it:

#include <stdlib.h>
#include <string.h>

int main() {
    char *s1 = malloc(6);
    strcpy(s1, "hello");
    char *s2 = s1; // Both pointers refer to the same memory
    // free(s1);
    // Using either s1 or s2 now leads to undefined behavior
    return 0;
}

This can easily cause double frees, dangling pointers, or memory leaks. Rust prevents such problems via strict ownership transfer.

6.2.2 Shallow vs. Deep Copy and the `clone()` Method

A shallow copy duplicates only metadata—pointers, sizes, or capacities—without cloning the underlying data. Rust’s design discourages shallow copies by enforcing ownership transfer and encouraging an explicit .clone() method for a full deep copy. Nonetheless, in unsafe contexts, programmers can bypass these safeguards and create shallow copies manually, risking double frees if two entities both believe they own the same resource.

To create a true duplicate, call .clone(), which performs a deep copy. This allocates new memory on the heap and copies the original data:

Example: Difference Between Move and Clone

fn main() {
    let s1 = String::from("hello");
    let s2 = s1;          // Move
    // println!("{}", s1); // Error: s1 has been moved

    let s3 = String::from("world");
    let s4 = s3.clone();  // Clone
    println!("s3: {}, s4: {}", s3, s4); // Both valid
}

Here, s3 and s4 each contain their own heap-allocated buffer with the content "world". Because .clone() can be expensive for large data, use it sparingly.

Move: Transfers ownership; the original variable is invalidated.
Clone: Both variables own distinct copies of the data.

6.2.3 Copying Scalar Types

Some types in Rust (e.g., integers, floats, and other fixed-size, stack-only data) are so simple that a bitwise copy suffices. These types implement the Copy trait. When you assign them, they are simply copied, and the original remains valid:

fn main() {
    let x = 5;
    let y = x; // Copy
    println!("x: {}, y: {}", x, y);
}

This mirrors copying basic values in C:

int x = 5;
int y = x; // Copy

Since these types do not manage heap data, there is no risk of double frees or dangling pointers.

Rust for C-Programmers