Why isn’t there a std::shared_ptr specialisation?

by

The LWG (Library Working Group of the C++ committee) briefly considered the possibility but the idea wasn’t without controversy. Though the controversy was mainly about a feature added to the shared_ptr<T[]> proposal that could have been jettisoned (arithmetic on shared_ptr<T[]>).

But ultimately the real real reason is that though it was discussed, there was never an actual written proposal in front of the LWG to do this. It never bubbled up anyone’s priority list (including my own) sufficiently to put the time into writing a proposal.

Informal conversations have recently begun anew on this topic among a few LWG members, and I have personally prototyped it. But there is still no written proposal for it. I think it would be a decent additional tool in the toolbox. Whether it will ever actually happen or not is anyone’s guess.

Update

Array support for shared_ptr now has a draft TS:

http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n4077.html

Update (2017)

This is now supported in C++17. See case 3 of shared_ptr::shared_ptr()

More Related Contents:

  1. How do I call ::std::make_shared on a class with only protected or private constructors?
  2. shared_ptr to an array : should it be used?
  3. Difference in make_shared and normal shared_ptr in C++
  4. Differences between unique_ptr and shared_ptr [duplicate]
  5. Why do std::shared_ptr work
  6. Should we pass a shared_ptr by reference or by value?
  7. Passing shared pointers as arguments
  8. std::shared_ptr initialization: make_shared() vs shared_ptr(new Foo) [duplicate]
  9. Passing shared_ptr as shared_ptr
  10. Where is shared_ptr?
  11. std::shared_ptr thread safety explained
  12. Should I use shared_ptr or unique_ptr
  13. What is the difference between an empty and a null std::shared_ptr in C++?
  14. How do shared pointers work?
  15. Why would I std::move an std::shared_ptr?
  16. shared_ptr and weak_ptr differences
  17. Why does unique_ptr take two template parameters when shared_ptr only takes one?
  18. weak_ptr, make_shared and memory deallocation
  19. Does C++11 unique_ptr and shared_ptr able to convert to each other’s type?
  20. Using paragraphs 8.5.3p4 and p5 in the C++11 Standard, how do I prove that the snippet below doesn’t compile?
  21. How do I terminate a thread in C++11?
  22. Why does this C++ snippet compile (non-void function does not return a value) [duplicate]
  23. How to specialize std::hash::operator() for user-defined type in unordered containers?
  24. C++11 allows in-class initialization of non-static and non-const members. What changed?
  25. c++ access static members using null pointer
  26. Is string::c_str() no longer null terminated in C++11?
  27. how to initialize a constexpr reference
  28. What happens when you call data() on a std::vector?
  29. std::is_base_of for template classes
  30. std::tuple memory alignment

Leave a Comment