Why is auto_ptr being deprecated?

by

The direct replacement for auto_ptr (or the closest thing to one anyway) is unique_ptr. As far as the “problem” goes, it’s pretty simple: auto_ptr transfers ownership when it’s assigned. unique_ptr also transfers ownership, but thanks to codification of move semantics and the magic of rvalue references, it can do so considerably more naturally. It also “fits” with the rest of the standard library considerably better (though, in fairness, some of that is thanks to the rest of the library changing to accommodate move semantics instead of always requiring copying).

The change in name is also (IMO) a welcome one — auto_ptr doesn’t really tell you much about what it attempts to automate, whereas unique_ptr is a fairly reasonable (if terse) description of what’s provided.

More Related Contents:

  1. std::auto_ptr to std::unique_ptr
  2. What is a smart pointer and when should I use one?
  3. Which kind of pointer do I use when?
  4. Why can I not push_back a unique_ptr into a vector?
  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. How much is the overhead of smart pointers compared to normal pointers in C++?
  9. Is there a non-atomic equivalent of std::shared_ptr? And why isn’t there one in ?
  10. smart pointers and arrays
  11. std::shared_ptr initialization: make_shared() vs shared_ptr(new Foo) [duplicate]
  12. So can unique_ptr be used safely in stl collections?
  13. Passing shared_ptr as shared_ptr
  14. Where is shared_ptr?
  15. Should I delete the move constructor and the move assignment of a smart pointer?
  16. Is auto_ptr deprecated?
  17. unique_ptr and OpenSSL’s STACK_OF(X509)*
  18. Why would I std::move an std::shared_ptr?
  19. C++11: Replace all non-owning raw pointers with std::shared_ptr()?
  20. Why should I use a pointer rather than the object itself?
  21. shared_ptr magic :)
  22. Passing a std::array of unknown size to a function
  23. What are the differences between -std=c++11 and -std=gnu++11?
  24. what is the best modern c++ approach to construct and manipulate a 2d array [closed]
  25. Is C++11’s long long really at least 64 bits?
  26. C++ When is it OK to extend the `std` namespace?
  27. Is the Empty Base Class Optimization now a mandatory optimization (at least for standard-layout classes)?
  28. Why does C++11 have `make_shared` but not `make_unique` [duplicate]
  29. Why isn’t std::array::size static?
  30. In lambda functions syntax, what purpose does a ‘capture list’ serve?

Leave a Comment