So can unique_ptr be used safely in stl collections?

by

I think it’s more a question of philosophy than technic 🙂

The underlying question is what is the difference between Move and Copy. I won’t jump into technical / standardista language, let’s do it simply:

  • Copy: create another identical object (or at least, one which SHOULD compare equal)
  • Move: take an object and put it in another location

As you said, it is possible to implement Move in term of Copy: create a copy into the new location and discard the original. However there are two issues there. One is of performance, the second is about objects used for RAII: which of the two should have ownership ?

A proper Move constructor solves the 2 issues:

  • It is clear which object has ownership: the new one, since the original will be discarded
  • It is thus unnecessary to copy the resources pointed to, which allows for greater efficiency

The auto_ptr and unique_ptr are a very good illustration of this.

With an auto_ptr you have a screwed Copy semantic: the original and the copy don’t compare equal. You could use it for its Move semantic but there is a risk that you’ll lose the object pointed to somewhere.

On the other hand, the unique_ptr is exactly that: it guarantees a unique owner of the resource, thus avoiding copying and the inevitable deletion issue that would follow. And the no-copy is guaranteed at compile-time too. Therefore, it’s suitable in containers as long as you don’t try to have copy initialization.

typedef std::unique_ptr<int> unique_t;
typedef std::vector< unique_t > vector_t;

vector_t vec1;                           // fine
vector_t vec2(5, unique_t(new Foo));     // Error (Copy)
vector_t vec3(vec1.begin(), vec1.end()); // Error (Copy)
vector_t vec3(make_move_iterator(vec1.begin()), make_move_iterator(vec1.end()));
    // Courtesy of sehe

std::sort(vec1.begin(), vec1.end()); // fine, because using Move Assignment Operator

std::copy(vec1.begin(), vec1.end(), std::back_inserter(vec2)); // Error (copy)

So you can use unique_ptr in a container (unlike auto_ptr), but a number of operations will be impossible because they involve copying which the type does not support.

Unfortunately Visual Studio may be quite lax in the enforcement of the standard and also has a number of extensions that you would need to disable to ensure portability of the code… don’t use it to check the standard 🙂

More Related Contents:

  1. std::auto_ptr to std::unique_ptr
  2. Is std::unique_ptr required to know the full definition of T?
  3. Why can I not push_back a unique_ptr into a vector?
  4. make_unique and perfect forwarding
  5. Returning unique_ptr from functions
  6. How do I pass a unique_ptr argument to a constructor or a function?
  7. How do I use a custom deleter with a std::unique_ptr member?
  8. Differences between unique_ptr and shared_ptr [duplicate]
  9. Is there any use for unique_ptr with array?
  10. How to capture a unique_ptr into a lambda expression?
  11. Copy constructor for a class with unique_ptr
  12. How to implement make_unique function in C++11? [duplicate]
  13. Proper way to create unique_ptr that holds an allocated array
  14. Exception safety and make_unique
  15. std::unique_ptr, deleters and the Win32 API
  16. How does the custom deleter of std::unique_ptr work?
  17. How can I pass std::unique_ptr into a function
  18. Should I use shared_ptr or unique_ptr
  19. error::make_unique is not a member of ‘std’
  20. Why is auto_ptr being deprecated?
  21. shared_ptr is to weak_ptr as unique_ptr is to… what?
  22. Raw pointer lookup for sets of unique_ptrs
  23. unique_ptr and OpenSSL’s STACK_OF(X509)*
  24. How can I compile C++11 code with Orwell Dev-C++?
  25. Why does unique_ptr take two template parameters when shared_ptr only takes one?
  26. Should std::unique_ptr be permitted
  27. stl container with std::unique_ptr’s vs boost::ptr_container
  28. Is there a way to write make_unique() in VS2012?
  29. Does std::bind work with move-only types in general, and std::unique_ptr in particular?
  30. Does C++11 unique_ptr and shared_ptr able to convert to each other’s type?

Leave a Comment