How do I pass a unique_ptr argument to a constructor or a function?

by

Here are the possible ways to take a unique pointer as an argument, as well as their associated meaning.

(A) By Value

Base(std::unique_ptr<Base> n)
  : next(std::move(n)) {}

In order for the user to call this, they must do one of the following:

Base newBase(std::move(nextBase));
Base fromTemp(std::unique_ptr<Base>(new Base(...));

To take a unique pointer by value means that you are transferring ownership of the pointer to the function/object/etc in question. After newBase is constructed, nextBase is guaranteed to be empty. You don’t own the object, and you don’t even have a pointer to it anymore. It’s gone.

This is ensured because we take the parameter by value. std::move doesn’t actually move anything; it’s just a fancy cast. std::move(nextBase) returns a Base&& that is an r-value reference to nextBase. That’s all it does.

Because Base::Base(std::unique_ptr<Base> n) takes its argument by value rather than by r-value reference, C++ will automatically construct a temporary for us. It creates a std::unique_ptr<Base> from the Base&& that we gave the function via std::move(nextBase). It is the construction of this temporary that actually moves the value from nextBase into the function argument n.

(B) By non-const l-value reference

Base(std::unique_ptr<Base> &n)
  : next(std::move(n)) {}

This has to be called on an actual l-value (a named variable). It cannot be called with a temporary like this:

Base newBase(std::unique_ptr<Base>(new Base)); //Illegal in this case.

The meaning of this is the same as the meaning of any other use of non-const references: the function may or may not claim ownership of the pointer. Given this code:

Base newBase(nextBase);

There is no guarantee that nextBase is empty. It may be empty; it may not. It really depends on what Base::Base(std::unique_ptr<Base> &n) wants to do. Because of that, it’s not very evident just from the function signature what’s going to happen; you have to read the implementation (or associated documentation).

Because of that, I wouldn’t suggest this as an interface.

(C) By const l-value reference

Base(std::unique_ptr<Base> const &n);

I don’t show an implementation, because you cannot move from a const&. By passing a const&, you are saying that the function can access the Base via the pointer, but it cannot store it anywhere. It cannot claim ownership of it.

This can be useful. Not necessarily for your specific case, but it’s always good to be able to hand someone a pointer and know that they cannot (without breaking rules of C++, like no casting away const) claim ownership of it. They can’t store it. They can pass it to others, but those others have to abide by the same rules.

(D) By r-value reference

Base(std::unique_ptr<Base> &&n)
  : next(std::move(n)) {}

This is more or less identical to the “by non-const l-value reference” case. The differences are two things.

  1. You can pass a temporary:

    Base newBase(std::unique_ptr<Base>(new Base)); //legal now..

  2. You must use std::move when passing non-temporary arguments.

The latter is really the problem. If you see this line:

Base newBase(std::move(nextBase));

You have a reasonable expectation that, after this line completes, nextBase should be empty. It should have been moved from. After all, you have that std::move sitting there, telling you that movement has occurred.

The problem is that it hasn’t. It is not guaranteed to have been moved from. It may have been moved from, but you will only know by looking at the source code. You cannot tell just from the function signature.

Recommendations

  • (A) By Value: If you mean for a function to claim ownership of a unique_ptr, take it by value.
  • (C) By const l-value reference: If you mean for a function to simply use the unique_ptr for the duration of that function’s execution, take it by const&. Alternatively, pass a & or const& to the actual type pointed to, rather than using a unique_ptr.
  • (D) By r-value reference: If a function may or may not claim ownership (depending on internal code paths), then take it by &&. But I strongly advise against doing this whenever possible.

How to manipulate unique_ptr

You cannot copy a unique_ptr. You can only move it. The proper way to do this is with the std::move standard library function.

If you take a unique_ptr by value, you can move from it freely. But movement doesn’t actually happen because of std::move. Take the following statement:

std::unique_ptr<Base> newPtr(std::move(oldPtr));

This is really two statements:

std::unique_ptr<Base> &&temporary = std::move(oldPtr);
std::unique_ptr<Base> newPtr(temporary);

(note: The above code does not technically compile, since non-temporary r-value references are not actually r-values. It is here for demo purposes only).

The temporary is just an r-value reference to oldPtr. It is in the constructor of newPtr where the movement happens. unique_ptr‘s move constructor (a constructor that takes a && to itself) is what does the actual movement.

If you have a unique_ptr value and you want to store it somewhere, you must use std::move to do the storage.

More Related Contents:

  1. Is std::unique_ptr required to know the full definition of T?
  2. Why can I not push_back a unique_ptr into a vector?
  3. make_unique and perfect forwarding
  4. Differences between std::make_unique and std::unique_ptr with new
  5. How do I use a custom deleter with a std::unique_ptr member?
  6. Differences between unique_ptr and shared_ptr [duplicate]
  7. Is there any use for unique_ptr with array?
  8. How to capture a unique_ptr into a lambda expression?
  9. “Downcasting” unique_ptr to unique_ptr
  10. Copy constructor for a class with unique_ptr
  11. How to implement make_unique function in C++11? [duplicate]
  12. How do I use unique_ptr for pimpl?
  13. Proper way to create unique_ptr that holds an allocated array
  14. So can unique_ptr be used safely in stl collections?
  15. Exception safety and make_unique
  16. std::unique_ptr, deleters and the Win32 API
  17. std::auto_ptr to std::unique_ptr
  18. How does the custom deleter of std::unique_ptr work?
  19. Should I use shared_ptr or unique_ptr
  20. error::make_unique is not a member of ‘std’
  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