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

clone() — explicit deep copy (duplicates all data). Copy — implicit bitwise copy (always cheap).

clone():

• Explicitly called via .clone() method.
• Deep copy — duplicates all owned data including heap.
• Can be expensive for large data structures.
• Works for any type implementing Clone trait.
• Both original and clone are fully independent after.

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

Copy trait:

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

1let x: i32 = 42;
2let y = x;  // Implicit copy — x still valid
3println!("{} {}", x, y);  // 42 42
4
5let point = (1, 2);  // Tuple of Copy types → Copy
6let point2 = point;

When to use:

• Use clone() when you need explicit ownership.
• Small Copy types (i32, bool, f64) copy automatically.
• Prefer borrowing over cloning for performance.

Common mistakes:

• Cloning when borrowing would work — performance hit.
• Thinking String implements Copy — it doesn't.
• Implementing Copy for heap types — compiler rejects it.