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.
• Both original and clone are fully independent.

1let s1 = String::from("hello");
2let s2 = s1.clone();  // s2 owns 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.
• Only for "trivially copyable" types.
• Must also implement Clone.
• Both variables remain valid.

1let x: i32 = 42;
2let y = x;  // Implicit copy
3println!("{} {}", x, y);  // 42 42
4
5let a = [1, 2, 3];  // [i32; 3] is Copy
6let b = a;

When to use:

• Use clone() for explicit ownership.
• Small Copy types copy automatically.
• Prefer borrowing over cloning.

Common mistakes:

• Cloning when borrowing works — performance hit.
• Thinking String is Copy — it isn't.
• Implementing Copy for heap types — compiler rejects.