Rust Copy Trait

Rust copy trait

Created By: chatGPT

Rust's Copy Trait is a special marker trait that indicates a type can be duplicated simply by copying bits. This is typically applicable to types that are small and have a fixed size, like primitive types (e.g., integers, booleans) and other types composed entirely of them. Using the Copy trait allows for efficient value copying without needing to deal with ownership and the borrowing rules characteristic of Rust.

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

fn main() {
    let p1 = Point { x: 10, y: 20 };
    let p2 = p1; // p1 is copied to p2 since Point implements Copy

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

When a type implements the Copy trait, assignments and function arguments proceed with bitwise copying rather than transferring ownership. In contrast, types that do not implement Copy will move their value, and the original data will no longer be accessible.

struct Complex {
    real: f64,
    imag: f64,
}

// Complex does not implement Copy
// fn takes ownership of c
fn process_complex(c: Complex) {
    // Do something with c
}

fn main() {
    let c1 = Complex { real: 1.0, imag: 2.0 };
    process_complex(c1);
    // println!("Real part: {}", c1.real); // This would cause a compile error
}

If you attempt to implement Copy for a type that contains non-Copy types, Rust will raise a compile-time error. For instance, a struct containing a String (which does not implement Copy) cannot derive Copy. Alternatively, you can implement Clone for complex types, which allows for explicit duplication instead of implicit copying.

#[derive(Clone)]
struct StringContainer {
    data: String,
}

fn main() {
    let sc1 = StringContainer { data: String::from("Hello") };
    let sc2 = sc1.clone(); // Explicitly cloning sc1
    println!("StringContainer 1: {}", sc1.data);
    println!("StringContainer 2: {}", sc2.data);
}