Copy and Clone

Why do numbers not move?

You may have noticed that this works fine: let a = 5; let b = a; println!("{a} {b}");. If a String moves, why does a number not move? Because an i32 lives entirely on the stack and has nothing on the heap to free. Copying its 4 bytes is as cheap as moving them, and there is no risk of a double free. So Rust simply copies it.

The Copy trait

A trait is a label that says a type has some ability (module 7 covers traits fully). Types with the Copy trait are copied on assignment instead of moved. The old variable stays valid.

let x = 10;
let y = x;                  // copied
println!("{x} {y}");        // 10 10: x is still valid

let t = (1, 'a');
let u = t;                  // copied: both parts are Copy
println!("{:?} {:?}", t, u);

let p = (1, String::from("a"));
let q = p;                  // MOVED: one part is a String
// println!("{:?}", p);     // error: borrow of moved value

Clone: a deliberate deep copy

Sometimes you really need two independent Strings. Call .clone(). It allocates new heap memory and copies every byte. Each copy has its own owner and is dropped on its own.

let a = String::from("Ravi");
let b = a.clone();

  STACK                    HEAP
  a: ptr ------------->  R a v i
  b: ptr ------------->  R a v i   (a separate copy)

Rust makes cloning visible on purpose. In some languages, copying a big list happens silently and slows a program without anyone noticing. In Rust, every expensive copy has .clone() written in the code, so you can find it and ask "is this needed?"

Copy versus Clone

Every Copy type is also Clone, so calling .clone() on an i32 works; it just does the same cheap copy.

Your own types

Structs you define (module 5) are moved by default. If all their fields are Copy and the type is small, you can make it Copy with a derive line. Derive asks the compiler to write the trait code for you.

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

fn main() {
    let a = Point { x: 1, y: 2 };
    let b = a;                     // copied
    println!("{:?} {:?}", a, b);
}

Common mistakes

• Sprinkling .clone() everywhere to silence the compiler. It works, but it can make code slow and hides a design problem. First try borrowing (module 4).
• Expecting a struct to be copied like a number. Structs move unless they derive Copy.
• Trying to derive Copy on a struct with a String field. The compiler refuses: String is not Copy.