Performance: Deep vs Shallow Copying

The choice between deep copying and shallow copying can have significant performance implications in C++. Understanding these implications is crucial for writing efficient code, especially when dealing with large objects or frequently copied data structures.

Shallow copying involves copying only the immediate data members of an object. For primitive types and pointers, this means copying the values directly. For pointers, the address is copied, not the pointed-to data.

Performance characteristics:

• Fast: Only copies the direct members of the object.
• Low memory usage: Doesn't duplicate underlying data for pointer members.
• Constant time complexity: $O(1)$ regardless of object size.

Example of shallow copying:

1#include <chrono>
2#include <iostream>
3
4class ShallowPlayer {
5public:
6  ShallowPlayer(int* hp) : health(hp) {}
7  int* health;
8};
9
10int main() {
11  const int numCopies = 1'000'000;
12  int hp = 100;
13
14  auto start =
15    std::chrono::high_resolution_clock::now();
16
17  for (int i = 0; i < numCopies; ++i) {
18    ShallowPlayer original(&hp);
19    // Shallow copy
20    ShallowPlayer copy = original;
21  }
22
23  auto end =
24    std::chrono::high_resolution_clock::now();
25  std::chrono::duration<double> diff = end -
26    start;
27
28  std::cout << "Time to perform " << numCopies
29    << " shallow copies: " << diff.count() << "s";
30}

1Time to perform 1000000 shallow copies: 0.0021545s

Deep copying involves creating a new copy of all data owned by the object, including dynamically allocated memory that the object might be pointing to.

Performance characteristics:

• Slower: Needs to allocate new memory and copy all underlying data.
• Higher memory usage: Duplicates all data, leading to increased memory consumption.
• Linear time complexity: $O(n)$ where n is the size of the underlying data.

Example of deep copying:

1#include <chrono>
2#include <iostream>
3#include <memory>
4
5class DeepPlayer {
6public:
7  DeepPlayer(int hp) : health(
8    std::make_unique<int>(hp)) {}
9
10  DeepPlayer(const DeepPlayer& other)
11    : health(
12      std::make_unique<int>(*other.health)) {}
13
14  std::unique_ptr<int> health;
15};
16
17int main() {
18  const int numCopies = 1'000'000;
19
20  auto start =
21    std::chrono::high_resolution_clock::now();
22
23  for (int i = 0; i < numCopies; ++i) {
24    DeepPlayer original(100);
25    DeepPlayer copy = original; // Deep copy
26  }
27
28  auto end =
29    std::chrono::high_resolution_clock::now();
30  std::chrono::duration<double> diff = end -
31    start;
32
33  std::cout << "Time to perform " << numCopies
34    << " deep copies: " << diff.count() << "s";
35}

1Time to perform 1000000 deep copies: 0.449998s

Running both these programs will show a significant performance difference, with shallow copying being much faster.

• Shallow copying is faster but can lead to issues with shared mutable state.
• Deep copying is safer for managing independent objects but comes with a performance cost.
• The choice depends on your specific use case. Sometimes, a mix of both approaches (like copy-on-write) can be optimal.
• For large objects or collections, the performance difference can be substantial and should be carefully considered in performance-critical code.

Remember, the right choice depends on your specific requirements for correctness, memory usage, and performance. Always profile your code to make informed decisions about copying strategies.