Returning unique ptr from functions

Question

unique ptr lt T gt  does not allow copy construction  instead it supports move semantics  Yet  I can return a unique ptr lt T gt  from a function and assign the returned value to a variable    include  lt iostream gt   include  lt memory gt   using namespace std   unique ptr lt int gt  foo       unique ptr lt int gt  p  new int 10        return p                       1     return move  p               2    int main       unique ptr lt int gt  p   foo       cout  lt  lt   p  lt  lt  endl    return 0      The code above compiles and works as intended  So how is it that line 1 doesn t invoke the copy constructor and result in compiler errors  If I had to use line 2 instead it d make sense  using line 2 works as well  but we re not required to do so    I know C  0x allows this exception to unique ptr since the return value is a temporary object that will be destroyed as soon as the function exits  thus guaranteeing the uniqueness of the returned pointer  I m curious about how this is implemented  is it special cased in the compiler or is there some other clause in the language specification that this exploits

User · Answer

I would like to mention one case where you must use std::move() otherwise it will give an error. Case: If the return type of the function differs from the type of the local variable.

class Base { ... };
class Derived : public Base { ... };
...
std::unique_ptr<Base> Foo() {
     std::unique_ptr<Derived> derived(new Derived());
     return std::move(derived); //std::move() must
}

Reference: https://www.chromium.org/developers/smart-pointer-guidelines

User · Answer

I think it s perfectly explained in item 25 of Scott Meyers  Effective Modern C    Here s an excerpt        The part of the Standard blessing the RVO goes on to say that if the conditions for the RVO are met  but compilers choose not to perform copy elision  the object being returned must be treated as an rvalue  In effect  the Standard requires that when the RVO is permitted  either copy elision takes place or std  move is implicitly applied to local objects being returned    Here  RVO refers to return value optimization  and if the conditions for the RVO are met means returning the local object declared inside the function that you would expect to do the RVO  which is also nicely explained in item 25 of his book by referring to the standard  here the local object includes the temporary objects created by the return statement   The biggest take away from the excerpt is either copy elision takes place or std  move is implicitly applied to local objects being returned  Scott mentions in item 25 that std  move is implicitly applied when the compiler choose not to elide the copy and the programmer should not explicitly do so   In your case  the code is clearly a candidate for RVO as it returns the local object p and the type of p is the same as the return type  which results in copy elision  And if the compiler chooses not to elide the copy  for whatever reason  std  move would ve kicked in to line 1

User · Answer

This is in no way specific to std  unique ptr  but applies to any class that is movable  It s guaranteed by the language rules since you are returning by value  The compiler tries to elide copies  invokes a move constructor if it can t remove copies  calls a copy constructor if it can t move  and fails to compile if it can t copy   If you had a function that accepts std  unique ptr as an argument you wouldn t be able to pass p to it  You would have to explicitly invoke move constructor  but in this case you shouldn t use variable p after the call to bar     void bar std  unique ptr lt int gt  p                  int main         unique ptr lt int gt  p   foo        bar p      error  can t implicitly invoke move constructor on lvalue     bar std  move p       OK but don t use p afterwards     return 0

User · Answer

One thing that i didn t see in other answers is To clarify another answers that there is a difference between returning std  unique ptr that has been created within a function  and one that has been given to that function   The example could be like this   class Test  int i    std  unique ptr lt Test gt  foo1         std  unique ptr lt Test gt  res new Test       return res    std  unique ptr lt Test gt  foo2 std  unique ptr lt Test gt  amp  amp  t           return t      this will produce an error      return std  move t            auto test1 foo1    auto test2 foo2 std  unique ptr lt Test gt  new Test

User · Answer

unique ptr doesn t have the traditional copy constructor  Instead it has a  move constructor  that uses rvalue references   unique ptr  unique ptr unique ptr  amp  amp  src     An rvalue reference  the double ampersand  will only bind to an rvalue  That s why you get an error when you try to pass an lvalue unique ptr to a function  On the other hand  a value that is returned from a function is treated as an rvalue  so the move constructor is called automatically    By the way  this will work correctly   bar unique ptr lt int gt  new int 44      The temporary unique ptr here is an rvalue

User · Answer

is there some other clause in the language specification that this exploits    Yes  see 12 8   34 and   35      When certain criteria are met  an implementation is allowed to omit the copy move construction of a class object         This elision of copy move operations  called copy elision  is permitted         in a return statement in a function with a class return type  when the expression is the name of   a non-volatile automatic object with the same cv-unqualified type as the function return type            When the criteria for elision of a copy operation are met and the object to be copied is designated by an lvalue    overload resolution to select the constructor for the copy is first performed as if the object were designated by an rvalue      Just wanted to add one more point that returning by value should be the default choice here because a named value in the return statement in the worst case  i e  without elisions in C  11  C  14 and C  17 is treated as an rvalue   So for example the following function compiles with the -fno-elide-constructors flag  std  unique ptr lt int gt  get unique       auto ptr   std  unique ptr lt int gt  new int 2        lt - 1   return ptr      lt - 2  moved into the to be returned unique ptr         auto int uptr   get unique        lt - 3   With the flag set on compilation there are two moves  1 and 2  happening in this function and then one move later on  3

[c++] Returning unique_ptr from functions

Examples related to c++

Examples related to c++11

Examples related to unique-ptr