Rust: What is the difference between clone() and copy?

clone() — explicit deep copy (can duplicate heap data). Copy — implicit bitwise copy (always cheap).

clone():

• Explicitly called: .clone() method.
• Deep copy — duplicates all owned data including heap allocations.
• Can be expensive for large data structures.
• Works for any type implementing Clone trait.
• After cloning, both original and clone are fully independent.

1let s1 = String::from("hello");
2let s2 = s1.clone();  // s2 owns its own copy of "hello"
3println!("{} {}", s1, s2);  // Both valid
4
5let v1 = vec![1, 2, 3];
6let v2 = v1.clone();  // v2 is a separate Vec

Copy trait:

• Implicit — happens on assignment, function calls, closures.
• Bitwise copy — just copies bytes, no heap allocation.
• Only for "trivially copyable" types (no destructors, no heap).
• Both variables remain valid after the copy.
• Must also implement Clone if implementing Copy.

1let x: i32 = 42;  // i32 implements Copy
2let y = x;        // Implicit copy — x still valid
3println!("{} {}", x, y);  // 42 42
4
5let tuple = (1, 2.0, true);  // All Copy → tuple is Copy
6let copy = tuple;

When to use:

• Use clone() when you need explicit ownership (before moving).
• Small Copy types (i32, bool, f64) copy automatically.
• For large data, prefer borrowing over cloning.

Common mistakes:

• Calling .clone() when borrowing would work — performance hit.
• Thinking String implements Copy — it doesn't (heap data).
• Implementing Copy for heap types — compiler rejects it.