What does T double ampersand mean in C 11

Question

I ve been looking into some of the new features of C  11 and one I ve noticed is the double ampersand in declaring variables  like T amp  amp  var   For a start  what is this beast called  I wish Google would allow us to search for punctuation like this   What exactly does it mean   At first glance  it appears to be a double reference  like the C-style double pointers T   var   but I m having a hard time thinking of a use case for that

User · Answer

The term for T amp  amp  when used with type deduction  such as for perfect forwarding  is known colloquially as a forwarding reference   The term  universal reference  was coined by Scott Meyers in this article  but was later changed   That is because it may be either r-value or l-value   Examples are      template template lt class T gt  foo T amp  amp  t              auto auto amp  amp  t            typedef typedef     T  T amp  amp  t            decltype decltype      amp  amp  t          More discussion can be found in the answer for  Syntax for universal references

User · Answer

It declares an rvalue reference  standards proposal doc    Here s an introduction to rvalue references     Here s a fantastic in-depth look at rvalue references by one of Microsoft s standard library developers      CAUTION  the linked article on MSDN   Rvalue References  C  0x Features in VC10  Part 2   is a very clear introduction to Rvalue references  but makes statements about Rvalue references that were once true in the draft C  11 standard  but are not true for the final one  Specifically  it says at various points that rvalue references can bind to lvalues  which was once true  but was changed  e g  int x  int  amp  amp rrx   x  no longer compiles in GCC      drewbarbs Jul 13  14 at 16 12   The biggest difference between a C  03 reference  now called an lvalue reference in C  11  is that it can bind to an rvalue like a temporary without having to be const   Thus  this syntax is now legal   T amp  amp  r   T      rvalue references primarily provide for the following   Move semantics   A move constructor and move assignment operator can now be defined that takes an rvalue reference instead of the usual const-lvalue reference   A move functions like a copy  except it is not obliged to keep the source unchanged  in fact  it usually modifies the source such that it no longer owns the moved resources   This is great for eliminating extraneous copies  especially in standard library implementations   For example  a copy constructor might look like this   foo foo const amp  other        this- gt length   other length      this- gt ptr   new int other length       copy other ptr  other ptr   other length  this- gt ptr       If this constructor was passed a temporary  the copy would be unnecessary because we know the temporary will just be destroyed  why not make use of the resources the temporary already allocated   In C  03  there s no way to prevent the copy as we cannot determine we were passed a temporary   In C  11  we can overload a move constructor   foo foo amp  amp  other       this- gt length   other length     this- gt ptr   other ptr     other length   0     other ptr   nullptr      Notice the big difference here  the move constructor actually modifies its argument   This would effectively  move  the temporary into the object being constructed  thereby eliminating the unnecessary copy   The move constructor would be used for temporaries and for non-const lvalue references that are explicitly converted to rvalue references using the std  move function  it just performs the conversion    The following code both invoke the move constructor for f1 and f2   foo f1  foo         Move a temporary into f1  temporary becomes  empty  foo f2   std  move f1      Move f1 into f2  f1 is now  empty    Perfect forwarding   rvalue references allow us to properly forward arguments for templated functions   Take for example this factory function   template  lt typename T  typename A1 gt  std  unique ptr lt T gt  factory A1 amp  a1        return std  unique ptr lt T gt  new T a1        If we called factory lt foo gt  5   the argument will be deduced to be int amp   which will not bind to a literal 5  even if foo s constructor takes an int   Well  we could instead use A1 const amp   but what if foo takes the constructor argument by non-const reference   To make a truly generic factory function  we would have to overload factory on A1 amp  and on A1 const amp    That might be fine if factory takes 1 parameter type  but each additional parameter type would multiply the necessary overload set by 2   That s very quickly unmaintainable   rvalue references fix this problem by allowing the standard library to define a std  forward function that can properly forward lvalue rvalue references   For more information about how std  forward works  see this excellent answer   This enables us to define the factory function like this   template  lt typename T  typename A1 gt  std  unique ptr lt T gt  factory A1 amp  amp  a1        return std  unique ptr lt T gt  new T std  forward lt A1 gt  a1         Now the argument s rvalue lvalue-ness is preserved when passed to T s constructor   That means that if factory is called with an rvalue  T s constructor is called with an rvalue   If factory is called with an lvalue  T s constructor is called with an lvalue   The improved factory function works because of one special rule      When the function parameter type is of   the form T amp  amp  where T is a template   parameter  and the function argument   is an lvalue of type A  the type A amp  is   used for template argument deduction    Thus  we can use factory like so   auto p1   factory lt foo gt  foo        calls foo foo amp  amp   auto p2   factory lt foo gt   p1        calls foo foo const amp     Important rvalue reference properties    For overload resolution  lvalues prefer binding to lvalue references and rvalues prefer binding to rvalue references   Hence why temporaries prefer invoking a move constructor   move assignment operator over a copy constructor   assignment operator  rvalue references will implicitly bind to rvalues and to temporaries that are the result of an implicit conversion   i e  float f   0f  int amp  amp  i   f  is well formed because float is implicitly convertible to int  the reference would be to a temporary that is the result of the conversion  Named rvalue references are lvalues   Unnamed rvalue references are rvalues   This is important to understand why the std  move call is necessary in  foo amp  amp  r   foo    foo f   std  move r

User · Answer

An rvalue reference is a type that behaves much like the ordinary reference X amp   with several exceptions  The most important one is that when it comes to function overload resolution  lvalues prefer old-style lvalue references  whereas rvalues prefer the new rvalue references   void foo X amp  x       lvalue reference overload void foo X amp  amp  x      rvalue reference overload  X x  X foobar     foo x             argument is lvalue  calls foo X amp   foo foobar        argument is rvalue  calls foo X amp  amp     So what is an rvalue  Anything that is not an lvalue  An lvalue being  an expression that refers to a memory location and allows us to take the address of that memory location via the  amp  operator    It is almost easier to understand first what rvalues accomplish with an example     include  lt cstring gt   class Sample     int  ptr     large block of memory   int size   public    Sample int sz 0    ptr sz    0   new int sz    nullptr   size sz            if  ptr    nullptr  memset ptr  0  sz            copy constructor that takes lvalue    Sample const Sample amp  s    ptr s size    0   new int s size           nullptr   size s size           if  ptr    nullptr  memcpy ptr  s ptr  s size        std  cout  lt  lt   copy constructor called on lvalue n             move constructor that take rvalue   Sample Sample amp  amp  s           steal s s resources      ptr   s ptr       size   s size               s ptr   nullptr     destructive write      s size   0       cout  lt  lt   Move constructor called on rvalue    lt  lt  std  endl               normal copy assignment operator taking lvalue   Sample amp  operator  const Sample amp  s         if this     amp s          delete    ptr     free current pointer       size   s size         if  size    0            ptr   new int s size           memcpy ptr  s ptr  s size           else           ptr   nullptr              cout  lt  lt   Copy Assignment called on lvalue    lt  lt  std  endl       return  this              overloaded move assignment operator taking rvalue  Sample amp  operator  Sample amp  amp  lhs        if this     amp s          delete    ptr    don t let ptr be orphaned        ptr   lhs ptr      but now  steal  lhs  don t clone it        size   lhs size         lhs ptr   nullptr     lhs s new  stolen  state       lhs size   0          cout  lt  lt   Move Assignment called on rvalue   lt  lt  std  endl     return  this          snip           The constructor and assignment operators have been overloaded with versions that take rvalue references  Rvalue references allow a function to branch at compile time  via overload resolution  on the condition  Am I being called on an lvalue or an rvalue    This allowed us to create more efficient constructor and assignment operators above that move resources rather copy them    The compiler automatically branches at compile time  depending on the whether it is being invoked for an lvalue or an rvalue  choosing whether the move constructor or move assignment operator should be called   Summing up  rvalue references allow move semantics  and perfect forwarding  discussed in the article link below     One practical easy-to-understand example is the class template std  unique ptr  Since a unique ptr maintains exclusive ownership of its underlying raw pointer  unique ptr s can t be copied  That would violate their invariant of exclusive ownership  So they do not have copy constructors  But they do have move constructors   template lt class T gt  class unique ptr          snip  unique ptr unique ptr amp  amp    u  noexcept     move constructor      std  unique ptr lt int   pt1 new int 10       std  unique ptr lt int   gt  ptr2 ptr1     compile error  no copy ctor         So we must first cast ptr1 to an rvalue   std  unique ptr lt int   gt  ptr2 std  move ptr1       std  unique ptr lt int   gt  TakeOwnershipAndAlter std  unique ptr lt int   gt  param    int size            for  auto i   0  i  lt  size    i         param i     10        return param     implicitly calls unique ptr unique ptr amp  amp         Now use function      unique ptr lt int   gt  ptr new int 10        first cast ptr from lvalue to rvalue unique ptr lt int   gt  new owner   TakeOwnershipAndAlter              static cast lt unique ptr lt int   gt  amp  amp  gt  ptr   10    cout  lt  lt   output  n    for auto i   0  i lt  10    i       cout  lt  lt  new owner i   lt  lt           output  10  10  10  10  10  10  10  10  10  10     static cast lt unique ptr lt int   gt  amp  amp  gt  ptr  is usually done using std  move     first cast ptr from lvalue to rvalue unique ptr lt int   gt  new owner   TakeOwnershipAndAlter std  move ptr  0     An excellent article explaining all this and more  like how rvalues allow perfect forwarding and what that means  with lots of good examples is Thomas Becker s C   Rvalue References Explained  This post relied heavily on his article    A shorter introduction is A Brief Introduction to Rvalue References by Stroutrup  et  al

User · Answer

It denotes an rvalue reference  Rvalue references will only bind to temporary objects  unless explicitly generated otherwise  They are used to make objects much more efficient under certain circumstances  and to provide a facility known as perfect forwarding  which greatly simplifies template code   In C  03  you can t distinguish between a copy of a non-mutable lvalue and an rvalue   std  string s  std  string another s                calls std  string const std  string amp    std  string more std  string s       calls std  string const std  string amp      In C  0x  this is not the case   std  string s  std  string another s                calls std  string const std  string amp    std  string more std  string s       calls std  string std  string amp  amp      Consider the implementation behind these constructors  In the first case  the string has to perform a copy to retain value semantics  which involves a new heap allocation  However  in the second case  we know in advance that the object which was passed in to our constructor is immediately due for destruction  and it doesn t have to remain untouched  We can effectively just swap the internal pointers and not perform any copying at all in this scenario  which is substantially more efficient  Move semantics benefit any class which has expensive or prohibited copying of internally referenced resources  Consider the case of std  unique ptr- now that our class can distinguish between temporaries and non-temporaries  we can make the move semantics work correctly so that the unique ptr cannot be copied but can be moved  which means that std  unique ptr can be legally stored in Standard containers  sorted  etc  whereas C  03 s std  auto ptr cannot   Now we consider the other use of rvalue references- perfect forwarding  Consider the question of binding a reference to a reference   std  string s  std  string amp  ref   s   std  string amp   amp  anotherref   ref     usually expressed via template   Can t recall what C  03 says about this  but in C  0x  the resultant type when dealing with rvalue references is critical  An rvalue reference to a type T  where T is a reference type  becomes a reference of type T    std  string amp   amp  amp  ref    ref is std  string amp   const std  string amp   amp  amp  ref    ref is const std  string amp   std  string amp  amp   amp  amp  ref    ref is std  string amp  amp   const std  string amp  amp   amp  amp  ref    ref is const std  string amp  amp    Consider the simplest template function- min and max  In C  03 you have to overload for all four combinations of const and non-const manually  In C  0x it s just one overload  Combined with variadic templates  this enables perfect forwarding   template lt typename A  typename B gt  auto min A amp  amp  aref  B amp  amp  bref           for example  if you pass a const std  string amp  as first argument         then A becomes const std  string amp  and by extension  aref becomes        const std  string amp   completely maintaining it s type information      if  std  forward lt A gt  aref   lt  std  forward lt B gt  bref           return std  forward lt A gt  aref       else         return std  forward lt B gt  bref       I left off the return type deduction  because I can t recall how it s done offhand  but that min can accept any combination of lvalues  rvalues  const lvalues

[c++] What does T&& (double ampersand) mean in C++11?

Examples related to c++

Examples related to c++11

Examples related to rvalue-reference

Examples related to c++-faq

Examples related to perfect-forwarding