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

clone() — explicit deep copy (can be expensive). Copy — implicit bitwise copy (always cheap).

clone():

• Explicitly called: s1.clone().
• Deep copy — duplicates all owned data (heap allocations).
• Can be expensive for large data (Vec of Strings, etc.).
• Works for any type that implements Clone.
• After cloning, both the original and clone are valid.

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

Copy trait:

• Implicit — happens automatically on assignment or passing to functions.
• Bitwise copy — no heap allocation, just copies bytes.
• Only for "trivially copyable" types (stack-only, no destructors).
• After copying, both variables are fully independent and valid.
• If a type implements Copy, it must also implement Clone.

1let x = 5;          // i32 implements Copy
2let y = x;          // Implicit copy — x is still valid
3println!("{} {}", x, y);  // Both print 5
4
5let a = (1, "hello");  // Tuple of Copy types → Copy
6let b = a;

When to use:

• Use clone() when you need explicit duplication (e.g., before moving).
• Small Copy types (i32, bool, f64) are cheap to copy — don't clone them.
• For large data, prefer borrowing over cloning for performance.

Common mistakes:

• Calling .clone() unnecessarily when borrowing would work.
• Not realizing String doesn't implement Copy — must clone.
• Implementing Copy for types with heap data — compiler rejects it.