Performance of Unique Pointers

The performance overhead of using std::unique_ptr compared to raw pointers in C++ is generally minimal, but it's worth understanding the differences.

Memory Overhead

In terms of memory usage, a std::unique_ptr typically has the same size as a raw pointer on most implementations when using the default deleter. Let's check this:

1#include <iostream>
2#include <memory>
3
4int main() {
5  std::cout << "Size of raw pointer: " << sizeof(int*)
6      << " bytes\n";
7  std::cout << "Size of unique_ptr: "
8      << sizeof(std::unique_ptr<int>) << " bytes\n";
9}

1Size of raw pointer: 8 bytes
2Size of unique_ptr: 8 bytes

However, if you use a custom deleter, the size may increase:

1#include <iostream>
2#include <memory>
3
4int main() {
5  auto customDeleter = [](int* p) { delete p; };
6  std::cout
7    << "Size of unique_ptr with custom deleter: "
8    << sizeof(
9      std::unique_ptr<int, decltype(customDeleter)>
10    ) << " bytes";
11}

1Size of unique_ptr with custom deleter: 16 bytes

Runtime Performance

In terms of runtime performance:

1. Dereferencing: Dereferencing a std::unique_ptr is typically as fast as dereferencing a raw pointer. Modern compilers can often optimize away any overhead.
2. Creation and Destruction: Creating a std::unique_ptr using std::make_unique() is generally as fast as using new. Destruction is also typically as fast as using delete.
3. Move Operations: Moving a std::unique_ptr is very fast, usually just involving pointer assignment.

Here's a simple benchmark to illustrate:

1#include <chrono>
2#include <iostream>
3#include <memory>
4
5const int ITERATIONS = 10000000;
6
7void benchmarkRawPointer() {
8  using namespace std::chrono;
9  auto start = high_resolution_clock::now();
10  for (int i = 0; i < ITERATIONS; ++i) {
11    int* p = new int(i);
12    *p += 1;
13    delete p;
14  }
15  auto end = high_resolution_clock::now();
16  duration<double> diff = end - start;
17  std::cout << "Raw pointer time: " << diff.count()
18      << " s\n";
19}
20
21void benchmarkUniquePtr() {
22  using namespace std::chrono;
23  auto start = high_resolution_clock::now();
24  for (int i = 0; i < ITERATIONS; ++i) {
25    auto p = std::make_unique<int>(i);
26    *p += 1;
27  }
28  auto end = high_resolution_clock::now();
29  duration<double> diff = end - start;
30  std::cout << "Unique pointer time: " << diff.count()
31      << " s\n";
32}
33
34int main() {
35  benchmarkRawPointer();
36  benchmarkUniquePtr();
37}

1Raw pointer time: 1.94922 s
2Unique pointer time: 2.23576 s

The results will vary depending on your system, but they're often very close.

In practice, the small performance overhead of std::unique_ptr is usually outweighed by the benefits of automatic resource management and exception safety. std::unique_ptr helps prevent resource leaks and makes your code safer and easier to reason about, which can lead to better overall performance in complex systems.

Remember, premature optimization is the root of all evil. Always measure before optimizing, and consider the trade-offs between slight performance gains and code safety/maintainability.