How much is the overhead of smart pointers compared to normal pointers in C++?

by

std::unique_ptr has memory overhead only if you provide it with some non-trivial deleter.

std::shared_ptr always has memory overhead for reference counter, though it is very small.

std::unique_ptr has time overhead only during constructor (if it has to copy the provided deleter and/or null-initialize the pointer) and during destructor (to destroy the owned object).

std::shared_ptr has time overhead in constructor (to create the reference counter), in destructor (to decrement the reference counter and possibly destroy the object) and in assignment operator (to increment the reference counter). Due to thread-safety guarantees of std::shared_ptr, these increments/decrements are atomic, thus adding some more overhead.

Note that none of them has time overhead in dereferencing (in getting the reference to owned object), while this operation seems to be the most common for pointers.

To sum up, there is some overhead, but it shouldn’t make the code slow unless you continuously create and destroy smart pointers.

More Related Contents:

  1. What is a smart pointer and when should I use one?
  2. Which kind of pointer do I use when?
  3. Why can I not push_back a unique_ptr into a vector?
  4. What is the advantage of using forwarding references in range-based for loops?
  5. Differences between std::make_unique and std::unique_ptr with new
  6. Is there any use for unique_ptr with array?
  7. “Downcasting” unique_ptr to unique_ptr
  8. Is there a non-atomic equivalent of std::shared_ptr? And why isn’t there one in ?
  9. smart pointers and arrays
  10. Why is std::unordered_map slow, and can I use it more effectively to alleviate that?
  11. Does a C++11 range-based for loop condition get evaluated every cycle?
  12. Can the use of C++11’s ‘auto’ improve performance?
  13. std::shared_ptr initialization: make_shared() vs shared_ptr(new Foo) [duplicate]
  14. Passing shared_ptr as shared_ptr
  15. Where is shared_ptr?
  16. Should I delete the move constructor and the move assignment of a smart pointer?
  17. Is the ranged based for loop beneficial to performance?
  18. std::auto_ptr to std::unique_ptr
  19. c++11 regex slower than python
  20. Why is auto_ptr being deprecated?
  21. Should I still return const objects in C++11? [duplicate]
  22. unique_ptr and OpenSSL’s STACK_OF(X509)*
  23. Why would I std::move an std::shared_ptr?
  24. C++11: Replace all non-owning raw pointers with std::shared_ptr()?
  25. Does auto deduce the type at compile time or runtime in C++ 11?
  26. Why is this C++ wrapper class not being inlined away?
  27. Move capture in lambda
  28. What do compilers do with compile-time branching?
  29. Why is the new random library better than std::rand()?
  30. What is the purpose of the “final” keyword in C++11 for functions?

Leave a Comment