Differentiate shallow copy from deep copy, and give examples of when each is appropriate.

Differentiate shallow copy from deep copy, and give examples of when each is appropriate.

• A. Shallow copy duplicates the object and all referenced objects.
• B. Deep copy duplicates only primitive fields.
• C. Shallow copy duplicates the object but shares referenced objects; deep copy duplicates the entire graph.
• D. Deep copy copies the object but not its references.

Answer: (C)

The main idea here is how copies handle nested objects. A shallow copy creates a new container for the object, but the items inside the container are the same references as in the original. That means changes to those shared nested objects show up in both the original and the copy. A deep copy, on the other hand, recursively duplicates everything reachable from the original object, so the new object and the original do not share any nested objects. This aligns with the statement that a shallow copy duplicates the outer object but shares referenced objects, while a deep copy duplicates the entire graph of objects. It’s the distinction between surface-level duplication and complete isolation. Think of practical use: a shallow copy is appropriate when you want a quick, lightweight copy and you don’t expect to modify the shared sub-objects independently, or when those sub-objects are immutable or intentionally shared to save memory. A deep copy is appropriate when you need full independence between copies, so changes to nested objects in one copy don’t affect others, even for mutable sub-objects. For concrete examples, many languages provide this pattern: in Python, copy.copy performs a shallow copy and copy.deepcopy performs a deep copy; in Java, clone typically yields a shallow copy unless a custom deep-clone is implemented. If you rely on shallow copying, be mindful of potential aliasing; with deep copies, you pay more in time and memory but get complete separation.

The main idea here is how copies handle nested objects. A shallow copy creates a new container for the object, but the items inside the container are the same references as in the original. That means changes to those shared nested objects show up in both the original and the copy. A deep copy, on the other hand, recursively duplicates everything reachable from the original object, so the new object and the original do not share any nested objects.

This aligns with the statement that a shallow copy duplicates the outer object but shares referenced objects, while a deep copy duplicates the entire graph of objects. It’s the distinction between surface-level duplication and complete isolation.

Think of practical use: a shallow copy is appropriate when you want a quick, lightweight copy and you don’t expect to modify the shared sub-objects independently, or when those sub-objects are immutable or intentionally shared to save memory. A deep copy is appropriate when you need full independence between copies, so changes to nested objects in one copy don’t affect others, even for mutable sub-objects.

For concrete examples, many languages provide this pattern: in Python, copy.copy performs a shallow copy and copy.deepcopy performs a deep copy; in Java, clone typically yields a shallow copy unless a custom deep-clone is implemented. If you rely on shallow copying, be mindful of potential aliasing; with deep copies, you pay more in time and memory but get complete separation.