Copy Traits in Rust

In Rust, memory management plays a crucial role in ensuring safety and efficiency. The Copy trait is an important marker trait that allows certain types to be duplicated simply by copying their bits. Unlike types that require ownership transfer, Copy types do not involve moves, making them lightweight and predictable. This article explores the concept of the Copy trait, its usage, and how it interacts with Rust’s ownership system.

01. Understanding the `Copy` Trait

The Copy trait is a marker trait in Rust that enables types to be copied instead of moved. Types implementing Copy do not require ownership transfers, making them suitable for scenarios where multiple copies of a value are needed.


fn main() {
    let x: i32 = 10;
    let y = x; // `x` is copied, not moved
    
    println!("x: {}, y: {}", x, y);
}

Since i32 implements Copy, the value of x is duplicated in y.
x remains valid even after assigning y = x, avoiding ownership issues.

02. Implementing the `Copy` Trait

Custom types can derive the Copy trait, but only if they contain fields that also implement Copy. The Clone trait must also be implemented.


#[derive(Copy, Clone)]
struct Point {
    x: i32,
    y: i32,
}

fn main() {
    let p1 = Point { x: 5, y: 10 };
    let p2 = p1; // `p1` is copied, not moved

    println!("p1: ({}, {}), p2: ({}, {})", p1.x, p1.y, p2.x, p2.y);
}

The Point struct derives Copy and Clone, making it copyable.
The assignment p2 = p1 results in a bitwise copy instead of moving ownership.

03. Copy vs Move Semantics

Types that do not implement Copy are moved instead of copied. This prevents unintended shallow copies for heap-allocated types like String and Vec.


fn main() {
    let s1 = String::from("Rust");
    let s2 = s1; // Move occurs, `s1` is no longer valid

    // println!("{}", s1); // ERROR: `s1` has been moved
    println!("{}", s2);
}

String does not implement Copy because it manages heap-allocated memory.
The ownership of s1 is transferred to s2, making s1 invalid.

04. When to Use the `Copy` Trait

Types that are small and store their data entirely on the stack are ideal candidates for the Copy trait. The following types implement Copy by default:

All primitive types (e.g., i32, f64, bool).
Arrays and tuples (if all elements implement Copy).
Immutable references &T (not &mut T).


fn main() {
    let a: (i32, char) = (42, 'R');
    let b = a; // `b` is a copy of `a`

    println!("a: {:?}, b: {:?}", a, b);
}

Since both i32 and char implement Copy, the tuple is also copyable.
The assignment b = a results in a bitwise copy instead of moving ownership.

05. Copy Trait Restrictions

Not all types can implement Copy. The following types are ineligible:

Types that implement Drop (e.g., String, Vec).
Structs containing heap-allocated data.


struct Data {
    value: String, // String does not implement Copy
}

// ERROR: Copy cannot be derived for `Data`
// #[derive(Copy, Clone)]
struct ValidData {
    number: i32,
}

Since String has a destructor, the Copy trait cannot be applied.
Only types with fully stack-allocated values can derive Copy.

06. Using Copy with Function Parameters

Passing Copy types as function arguments allows them to be used even after function calls.


fn duplicate(x: i32) {
    println!("x inside function: {}", x);
}

fn main() {
    let num = 100;
    duplicate(num); // `num` is copied
    println!("x in main: {}", num); // Still accessible
}

The i32 type implements Copy, so the function receives a copy instead of ownership.
The original variable remains accessible after the function call.

07. Conclusion

The Copy trait is a fundamental feature in Rust that enables lightweight duplication of values. By understanding when and how to use it, developers can optimize memory usage while maintaining safe ownership semantics. Types that implement Copy avoid unnecessary moves, making them ideal for stack-allocated, small-sized values.