Is there a non-atomic equivalent of std::shared_ptr? And why isn’t there one in ?

by

1. I’m wondering if there is a non-atomic version of std::shared_ptr available

Not provided by the standard. There may well be one provided by a “3rd party” library. Indeed, prior to C++11, and prior to Boost, it seemed like everyone wrote their own reference counted smart pointer (including myself).

2. My second question is why wasn’t a non-atomic version of std::shared_ptr provided in C++11?

This question was discussed at the Rapperswil meeting in 2010. The subject was introduced by a National Body Comment #20 by Switzerland. There were strong arguments on both sides of the debate, including those you provide in your question. However, at the end of the discussion, the vote was overwhelmingly (but not unanimous) against adding an unsynchronized (non-atomic) version of shared_ptr.

Arguments against included:

  • Code written with the unsynchronized shared_ptr may end up being used in threaded code down the road, ending up causing difficult to debug problems with no warning.

  • Having one “universal” shared_ptr that is the “one way” to traffic in reference counting has benefits: From the original proposal:

    Has the same object type regardless of features used, greatly facilitating interoperability between libraries, including third-party libraries.

  • The cost of the atomics, while not zero, is not overwhelming. The cost is mitigated by the use of move construction and move assignment which do not need to use atomic operations. Such operations are commonly used in vector<shared_ptr<T>> erase and insert.

  • Nothing prohibits people from writing their own non-atomic reference-counted smart pointer if that’s really what they want to do.

The final word from the LWG in Rapperswil that day was:

Reject CH 20. No consensus to make a change at this time.

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. Differences between std::make_unique and std::unique_ptr with new
  5. Is there any use for unique_ptr with array?
  6. “Downcasting” unique_ptr to unique_ptr
  7. How much is the overhead of smart pointers compared to normal pointers in C++?
  8. smart pointers and arrays
  9. std::shared_ptr initialization: make_shared() vs shared_ptr(new Foo) [duplicate]
  10. Passing shared_ptr as shared_ptr
  11. Where is shared_ptr?
  12. Should I delete the move constructor and the move assignment of a smart pointer?
  13. std::auto_ptr to std::unique_ptr
  14. Why is auto_ptr being deprecated?
  15. unique_ptr and OpenSSL’s STACK_OF(X509)*
  16. Why would I std::move an std::shared_ptr?
  17. C++11: Replace all non-owning raw pointers with std::shared_ptr()?
  18. C++ Runtime Terminates std::out_of_range [closed]
  19. What does T&& (double ampersand) mean in C++11?
  20. How is Meyers’ implementation of a Singleton actually a Singleton
  21. Is it a conforming compiler extension to treat non-constexpr standard library functions as constexpr?
  22. How does std::forward work? [duplicate]
  23. order of evaluation of operands
  24. Why are lambda expressions not allowed in an unevaluated operands but allowed in the unevaluated portions of constant expressions?
  25. How can I use Standard Library (STL) classes in my dll interface or ABI?
  26. May std::vector make use of small buffer optimization?
  27. Is a constexpr array necessarily odr-used when subscripted?
  28. Returning a void?
  29. “What happened to my SFINAE” redux: conditional template class members?
  30. Concatenate compile-time strings in a template at compile time?

Leave a Comment