What is std move and when should it be used

Question

What is it  What does it do  When should it be used    Good links are appreciated

User · Accepted Answer

Wikipedia Page on C  11 R-value references and move constructors   In C  11  in addition to copy constructors  objects can have move constructors   And in addition to copy assignment operators  they have move assignment operators   The move constructor is used instead of the copy constructor  if the object has type  rvalue-reference   Type  amp  amp    std  move   is a cast that produces an rvalue-reference to an object  to enable moving from it    It s a new C   way to avoid copies  For example  using a move constructor  a std  vector could just copy its internal pointer to data to the new object  leaving the moved object in an moved from state  therefore not copying all the data  This would be C  -valid   Try googling for move semantics  rvalue  perfect forwarding

User · Answer

Q  What is std  move  A  std  move   is a function from the C   Standard Library for casting to a rvalue reference  Simplisticly std  move t  is equivalent to  static cast lt T amp  amp  gt  t    An rvalue is a temporary that does not persist beyond the expression that defines it  such as an intermediate function result which is never stored in a variable  int a   3     3 is a rvalue  does not exist after expression is evaluated int b   a     a is a lvalue  keeps existing after expression is evaluated  An implementation for std  move   is given in N2027   quot A Brief Introduction to Rvalue References quot  as follows  template  lt class T gt  typename remove reference lt T gt   type amp  amp  std  move T amp  amp  a        return a     As you can see  std  move returns T amp  amp  no matter if called with a value  T   reference type  T amp    or rvalue reference  T amp  amp    Q  What does it do  A  As a cast  it does not do anything during runtime  It is only relevant at compile time to tell the compiler that you would like to continue considering the reference as an rvalue  foo 3   5      obviously  you are calling foo with a temporary  rvalue   int a   3   5  foo a          how to tell the compiler to treat  a  as an rvalue  foo std  move a       will call  foo int amp  amp  a   rather than  foo int a   or  foo int amp  a    What it does not do   Make a copy of the argument Call the copy constructor Change the argument object  Q  When should it be used  A  You should use std  move if you want to call functions that support move semantics with an argument which is not an rvalue  temporary expression   This begs the following follow-up questions for me   What is move semantics  Move semantics in contrast to copy semantics is a programming technique in which the members of an object are initialized by  taking over  instead of copying another object s members  Such  take over  makes only sense with pointers and resource handles  which can be cheaply transferred by copying the pointer or integer handle rather than the underlying data   What kind of classes and objects support move semantics  It is up to you as a developer to implement move semantics in your own classes if these would benefit from transferring their members instead of copying them  Once you implement move semantics  you will directly benefit from work from many library programmers who have added support for handling classes with move semantics efficiently   Why can t the compiler figure it out on its own  The compiler cannot just call another overload of a function unless you say so  You must help the compiler choose whether the regular or move version of the function should be called   In which situations would I want to tell the compiler that it should treat a variable as an rvalue  This will most likely happen in template or library functions  where you know that an intermediate result could be salvaged

User · Answer

What is it   and   What does it do   has been explained above   I will give a example of  when it should be used    For example  we have a class with lots of resource like big array in it   class ResHeavy      ResHeavy means heavy resource     public          ResHeavy int len 10   upInt new int len    len len               cout lt  lt  default ctor  lt  lt endl                     ResHeavy const ResHeavy amp  rhs   upInt new int rhs  len    len rhs  len               cout lt  lt  copy ctor  lt  lt endl                     ResHeavy amp  operator  const ResHeavy amp  rhs                upInt reset new int rhs  len                 len   rhs  len              cout lt  lt  operator  ctor  lt  lt endl                     ResHeavy ResHeavy amp  amp  rhs                upInt   std  move rhs  upInt                len   rhs  len              rhs  len   0              cout lt  lt  move ctor  lt  lt endl                    check array valid     bool is up valid            return  upInt    nullptr             private          std  unique ptr lt int   gt   upInt     heavy array resource         int  len     length of int array      Test code   void test std move2        ResHeavy rh     only one int          operator rh         after some operator of rh  it becomes no-use        transform it to other object     ResHeavy rh2   std  move rh      rh becomes invalid         show rh  rh2 it valid     if rh is up valid            cout lt  lt  rh valid  lt  lt endl      else         cout lt  lt  rh invalid  lt  lt endl       if rh2 is up valid            cout lt  lt  rh2 valid  lt  lt endl      else         cout lt  lt  rh2 invalid  lt  lt endl          new ResHeavy object  created by copy ctor     ResHeavy rh3 rh2       two copy of int        if rh3 is up valid            cout lt  lt  rh3 valid  lt  lt endl      else         cout lt  lt  rh3 invalid  lt  lt endl      output as below   default ctor move ctor rh invalid rh2 valid copy ctor rh3 valid   We can see that std  move with move constructor makes transform resource easily   Where else is std  move useful   std  move can also be useful when sorting an array of elements  Many sorting algorithms  such as selection sort and bubble sort  work by swapping pairs of elements  Previously  we   ve had to resort to copy-semantics to do the swapping  Now we can use move semantics  which is more efficient   It can also be useful if we want to move the contents managed by one smart pointer to another   Cited    https   www learncpp com cpp-tutorial 15-4-stdmove

User · Answer

Here is a full example  using std  move for a  simple  custom vector  Expected output    c   10  11   copy ctor called  copy of c   10  11   move ctor called  moved c   10  11    Compile as     g   -std c  2a -O2 -Wall -pedantic foo cpp   Code    include  lt iostream gt   include  lt algorithm gt   template lt class T gt  class MyVector   private      T  data      size t maxlen      size t currlen  public      MyVector lt T gt       data  nullptr   maxlen 0   currlen 0          MyVector lt T gt   int maxlen    data  new T  maxlen    maxlen maxlen   currlen 0           MyVector lt T gt   const MyVector amp  o            std  cout  lt  lt   copy ctor called   lt  lt  std  endl          data   new T  o maxlen           maxlen   o maxlen          currlen   o currlen          std  copy o data  o data   o maxlen  data              MyVector lt T gt   const MyVector lt T gt  amp  amp  o            std  cout  lt  lt   move ctor called   lt  lt  std  endl          data   o data          maxlen   o maxlen          currlen   o currlen             void push back  const T amp  i            if  currlen  gt   maxlen                maxlen    2              auto newdata   new T  maxlen               std  copy data  data   currlen  newdata               if  data                    delete   data                            data   newdata                    data currlen      i             friend std  ostream amp  operator lt  lt  std  ostream  amp os  const MyVector lt T gt  amp  o            auto s   o data          auto e   o data   o currlen           while  s  lt  e                os  lt  lt       lt  lt   s  lt  lt                   s                      return os            int main         auto c   new MyVector lt int gt  1       c- gt push back 10       c- gt push back 11       std  cout  lt  lt   c     lt  lt   c  lt  lt  std  endl      auto d    c      std  cout  lt  lt   copy of c     lt  lt  d  lt  lt  std  endl      auto e   std  move  c       delete c      std  cout  lt  lt   moved c     lt  lt  e  lt  lt  std  endl

User · Answer

You can use move when you need to  transfer  the content of an object somewhere else  without doing a copy  i e  the content is not duplicated  that s why it could be used on some non-copyable objects  like a unique ptr   It s also possible for an object to take the content of a temporary object without doing a copy  and save a lot of time   with std  move   This link really helped me out     http   thbecker net articles rvalue references section 01 html  I m sorry if my answer is coming too late  but I was also looking for a good link for the std  move  and I found the links above a little bit  austere     This puts the emphasis on r-value reference  in which context you should use them  and I think it s more detailed  that s why I wanted to share this link here

User · Answer

std  move itself doesn t really do much  I thought that it called the moved constructor for an object  but it really just performs a type cast  casting an lvalue variable to an rvalue so that the said variable can be passed as an argument to a move constructor or assignment operator   So std  move is just used as a precursor to using move semantics  Move semantics is essentially an efficient way for dealing with temporary objects  Consider Object A   B   C   D   E   F  This is nice looking code  but E   F produces a temporary object  Then D   temp produces another temporary object and so on  In each normal  quot   quot  operator of a class  deep copies occur  For example Object Object  operator   const Object amp  rhs        Object temp   this          logic for adding     return temp     The creation of the temporary object in this function is useless - these temporary objects will be deleted at the end of the line anyway as they go out of scope  We can rather use move semantics to  quot plunder quot  the temporary objects and do something like  Object amp  Object  operator   Object amp  amp  rhs            logic to modify rhs directly      return rhs      This avoids needless deep copies being made  With reference to the example  the only part where deep copying occurs is now E   F  The rest uses move semantics  The move constructor or assignment operator also needs to be implemented to assign the result to A

User · Answer

1   quot What is it  quot  While std  move    is technically a function - I would say it isn t really a function  It s sort of a converter between ways the compiler considers an expression s value  2   quot What does it do  quot  The first thing to note is that std  move   doesn t actually move anything  It changes an expression from being an lvalue  such as a named variable  to being an xvalue  An xvalue tells the compiler   You can plunder me  move anything I m holding and use it elsewhere  since I m going to be destroyed soon anyway  quot    in other words  when you use std  move x   you re allowing the compiler to cannibalize x  Thus if x has  say  its own buffer in memory - after std  move  ing the compiler can have another object own it instead  You can also move from a prvalue  such as a temporary you re passing around   but this is rarely useful  3   quot When should it be used  quot  Another way to ask this question is  quot What would I cannibalize an existing object s resources for  quot  well  if you re writing application code  you would probably not be messing around a lot with temporary objects created by the compiler  So mainly you would do this in places like constructors  operator methods  standard-library-algorithm-like functions etc  where objects get created and destroyed automagically a lot  Of course  that s just a rule of thumb  A typical use is  moving  resources from one object to another instead of copying    Guillaume links to this page which has a straightforward short example  swapping two objects with less copying  template  lt class T gt  swap T amp  a  T amp  b        T tmp a        we now have two copies of a     a   b          we now have two copies of b    discarded a copy of a      b   tmp        we now have two copies of tmp    discarded a copy of b     using move allows you to swap the resources instead of copying them around  template  lt class T gt  swap T amp  a  T amp  b        T tmp std  move a        a   std  move b          b   std  move tmp      Think of what happens when T is  say  vector lt int gt  of size n  In the first version you read and write 3 n elements  in the second version you basically read and write just the 3 pointers to the vectors  buffers  plus the 3 buffers  sizes  Of course  class T needs to know how to do the moving  your class should have a move-assignment operator and a move-constructor for class T for this to work

User · Answer

std  move itself does nothing rather than a static cast  According to cppreference com  It is exactly equivalent to a static cast to an rvalue reference type   Thus  it depends on the type of the variable you assign to after the move  if the type has constructors or assign operators that takes a rvalue parameter  it may or may not steal the content of the original variable  so  it may leave the original variable to be in an unspecified state   Unless otherwise specified  all standard library objects that have been moved from being placed in a valid but unspecified state   Because there is no special move constructor or move assign operator for built-in literal types such as integers and raw pointers  so  it will be just a simple copy for these types

[c++] What is std::move(), and when should it be used?

Examples related to c++

Examples related to c++11

Examples related to move-semantics

Examples related to c++-faq

Examples related to stdmove