std::move

Author: goblinhack

Makefile

@@ -1,4 +1,7 @@
-SUBDIRS=unique_ptr shared_ptr shared_ptr_wrapper
+SUBDIRS=std_move \
+	std_unique_ptr \
+	std_shared_ptr \
+	std_shared_ptr_wrapper
 
 #
 # To force clean and avoid "up to date" warning.

README.md

@@ -11,12 +11,214 @@ individually or as a whole.
 Let me know if this is useful to anyone or if there are any areas you want
 covered. This is (probably forever) a work in progress.
 
-[How to use std::unique_ptr](unique_ptr/README.md)
+[How to use std::move](std_move/README.md)
 
-[How to use std::shared_ptr](shared_ptr/README.md)
+[How to use std::unique_ptr](std_unique_ptr/README.md)
 
-[How to make your own wrapper around std::shared_ptr](shared_ptr_wrapper/README.md)
+[How to use std::shared_ptr](std_shared_ptr/README.md)
 
+[How to make your own wrapper around std::shared_ptr](std_shared_ptr_wrapper/README.md)
+
+How to use std::move
+====================
+
+std::move is a nifty way to avoid the use of temporaries when doing copies
+of data. For example if you do:
+
+```C++
+template<class T> void simpleswap(T& a, T& b) {
+    T tmp = b;
+    b = a;
+    a = b;
+}
+```
+
+You will see the copy constructor invoked. Not a huge deal for small classes,
+but if you are dealing with a vector, that could be very expensive.
+
+A better approach is to use std::move e.g.
+
+```C++
+template<class T> void simpleswap(T& a, T& b) {
+    T tmp { std::move(a) }; // invokes move constructor
+    a = std::move(b);       // invokes move assignment
+    b = std::move(tmp);     // invokes move assignment
+}
+```
+
+Now the question is, how do we implement std::move on our own classes.
+To use this you will see a new form of constructor with the "&&" syntax.
+The example below will create our own vector class and then implement
+the move constructor to transfer elements across. The old vector will
+be left empty.
+
+Note that std::vector already does this approach; we're just applying
+the same ideas to a custom class.
+```C++
+#include <iostream>
+#include <string>
+#include <sstream> // std::stringstream
+#include <algorithm> // std::move
+#include "../common/common.h"
+
+template<class T> class MyVector {
+private:
+    T *data;
+    size_t maxlen;
+    size_t currlen;
+public:
+    MyVector<T> () : data (nullptr), maxlen(0), currlen(0) {
+        std::cout << "default constructor " << to_string() << std::endl;
+    }
+    MyVector<T> (int maxlen) : data (new T [maxlen]),
+                               maxlen(maxlen),
+                               currlen(0) {
+        std::cout << "new " << to_string() << std::endl;
+    }
+    MyVector<T> (const MyVector& o) {
+        std::cout << "copy constructor called for " << o.to_string() << std::endl;
+        data = new T [o.maxlen];
+        maxlen = o.maxlen;
+        currlen = o.currlen;
+        std::copy(o.data, o.data + o.maxlen, data);
+        std::cout << "copy constructor result is  " << to_string() << std::endl;
+    }
+    MyVector<T> (MyVector<T>&& o) {
+        std::cout << "std::move called for " << o.to_string() << std::endl;
+        data = o.data;
+        maxlen = o.maxlen;
+        currlen = o.currlen;
+        o.data = nullptr;
+        o.maxlen = 0;
+        o.currlen = 0;
+        std::cout << "std::move result is  " << to_string() << std::endl;
+    }
+    ~MyVector<T> () {
+        std::cout << "delete " << to_string() << std::endl;
+    }
+    void push_back (const T& i) {
+        if (currlen >= maxlen) {
+            maxlen *= 2;
+            auto newdata = new T [maxlen];
+            std::copy(data, data + currlen, newdata);
+            if (data) {
+                delete[] data;
+            }
+            data = newdata;
+        }
+        data[currlen++] = i;
+        std::cout << "push_back called " << to_string() << std::endl;
+    }
+    friend std::ostream& operator<<(std::ostream &os, const MyVector<T>& o) {
+        auto s = o.data;
+        auto e = o.data + o.currlen;;
+        while (s < e) {
+            os << "[" << *s << "]";
+            s++;
+        }
+        return os;
+    }
+    std::string to_string (void) const {
+        auto address = static_cast<const void*>(this);
+        std::stringstream ss;
+        ss << address;
+
+        std::string elems;
+        auto s = data;
+        auto e = data + currlen;;
+        while (s < e) {
+            elems += std::to_string(*s);
+            s++;
+            if (s < e) {
+                elems += ",";
+            }
+        }
+
+        return "MyVector(" + ss.str() +
+                        ", currlen=" + std::to_string(currlen) +
+                        ", maxlen=" + std::to_string(maxlen) +
+                        " elems=[" + elems + "])";
+    }
+};
+
+int main() {
+    // Create a custom vector class:
+    auto vec1 = new MyVector<int>(1);
+    vec1->push_back(10);
+    vec1->push_back(11);
+    std::cout << "vec1: " << *vec1 << std::endl;
+
+    // Create a new copy of vec1, vec2 via copy constructor (&):
+    auto vec2 = *vec1;
+    std::cout << "vec2: " << vec2 << std::endl;
+
+    // Check we can append onto the copied vector:
+    vec2.push_back(12);
+    vec2.push_back(13);
+    std::cout << "vec2: " << vec2 << std::endl;
+
+    // Create a new vector from vec1, vec3 via the move constructor (&&&):
+    auto vec3 = std::move(*vec1);
+    std::cout << "vec3: " << vec3 << std::endl;
+
+    // Check we can append onto the std:move'd vector:
+    vec3.push_back(14);
+    vec3.push_back(15);
+    std::cout << "vec3: " << vec3 << std::endl;
+
+    // Destroy the old vector, vec1. It has no invalid elems:
+    delete vec1;
+
+    // End, expect vec2 and vec3 destroy:
+    // End
+}
+```
+To build:
+<pre>
+cd std_move
+rm -f *.o example
+c++ -std=c++2a -Werror -g -ggdb3 -Wall -c -o main.o main.cpp
+c++ main.o  -o example
+./example
+</pre>
+Expected output:
+<pre>
+
+# Create a custom vector class:
+new MyVector(0x7fbbf64029b0, currlen=0, maxlen=1 elems=[])
+push_back called MyVector(0x7fbbf64029b0, currlen=1, maxlen=1 elems=[10])
+push_back called MyVector(0x7fbbf64029b0, currlen=2, maxlen=2 elems=[10,11])
+vec1: [10][11]
+
+# Create a new copy of vec1, vec2 via copy constructor (&):
+copy constructor called for MyVector(0x7fbbf64029b0, currlen=2, maxlen=2 elems=[10,11])
+copy constructor result is  MyVector(0x7ffeed989688, currlen=2, maxlen=2 elems=[10,11])
+vec2: [10][11]
+
+# Check we can append onto the copied vector:
+push_back called MyVector(0x7ffeed989688, currlen=3, maxlen=4 elems=[10,11,12])
+push_back called MyVector(0x7ffeed989688, currlen=4, maxlen=4 elems=[10,11,12,13])
+vec2: [10][11][12][13]
+
+# Create a new vector from vec1, vec3 via the move constructor (&&&):
+std::move called for MyVector(0x7fbbf64029b0, currlen=2, maxlen=2 elems=[10,11])
+std::move result is  MyVector(0x7ffeed989668, currlen=2, maxlen=2 elems=[10,11])
+vec3: [10][11]
+
+# Check we can append onto the std:move'd vector:
+push_back called MyVector(0x7ffeed989668, currlen=3, maxlen=4 elems=[10,11,14])
+push_back called MyVector(0x7ffeed989668, currlen=4, maxlen=4 elems=[10,11,14,15])
+vec3: [10][11][14][15]
+
+# Destroy the old vector, vec1. It has no invalid elems:
+delete MyVector(0x7fbbf64029b0, currlen=0, maxlen=0 elems=[])
+
+# End, expect vec2 and vec3 destroy:
+
+# End
+delete MyVector(0x7ffeed989668, currlen=4, maxlen=4 elems=[10,11,14,15])
+delete MyVector(0x7ffeed989688, currlen=4, maxlen=4 elems=[10,11,12,13])
+</pre>
 How to use std::shared_ptr
 ==========================
 
@@ -108,7 +310,7 @@ int main (void)
 ```
 To build:
 <pre>
-cd shared_ptr
+cd std_shared_ptr
 rm -f *.o example
 c++ -std=c++2a -Werror -g -ggdb3 -Wall -c -o main.o main.cpp
 c++ main.o  -o example
@@ -118,9 +320,9 @@ Expected output:
 <pre>
 
 # Create a copy constructed class and share it between two pointers:
-new Foo(0x7ffee88d8220, data=foo1)
-copy constructor Foo(0x7fce75600a18, data=)
-delete Foo(0x7ffee88d8220, data=foo1)
+new Foo(0x7ffee18fa220, data=foo1)
+copy constructor Foo(0x7f9d61c029f8, data=)
+delete Foo(0x7ffee18fa220, data=foo1)
 sptr1 ref count now 1
 sptr2 ref count now 2
 
@@ -138,13 +340,13 @@ sptr2 ref count now 2
 
 # Release the shared sptrs, expect foo1 to be destroyed:
 sptr1 ref count now 0
-delete Foo(0x7fce75600a18, data=foo1)
+delete Foo(0x7f9d61c029f8, data=foo1)
 sptr2 ref count now 0
 
 # You can also create shared pointers WITHOUT copy constructor overhead
-new Foo(0x7fce756009d0, data=foo0)
-sptr0 = Foo(0x7fce756009d0, data=foo0)
-delete Foo(0x7fce756009d0, data=foo0)
+new Foo(0x7f9d61c029b0, data=foo0)
+sptr0 = Foo(0x7f9d61c029b0, data=foo0)
+delete Foo(0x7f9d61c029b0, data=foo0)
 </pre>
 How to make your own wrapper around std::shared_ptr
 ===================================================
@@ -275,7 +477,7 @@ int main (void)
 ```
 To build:
 <pre>
-cd shared_ptr_wrapper
+cd std_shared_ptr_wrapper
 rm -f *.o example
 c++ -std=c++2a -Werror -g -ggdb3 -Wall -c -o main.o main.cpp
 c++ main.o  -o example
@@ -285,20 +487,20 @@ Expected output:
 <pre>
 
 # create a class and share it between two pointers:
-new Foo(0x7ffeea47e658, data=foo1-data)
-[foo1]: MySharedPtr::make_shared MySharedPtr(0x7ffeea47e688,Foo(0x7f94894029c8, data=foo1-data))
-delete Foo(0x7ffeea47e658, data=foo1-data)
+new Foo(0x7ffeee280658, data=foo1-data)
+[foo1]: MySharedPtr::make_shared MySharedPtr(0x7ffeee280688,Foo(0x7f8d564029c8, data=foo1-data))
+delete Foo(0x7ffeee280658, data=foo1-data)
 sptr1 ref count now 1
 sptr2 ref count now 2
 
 # release the shared sptrs, expect foo1 to be destroyed:
-[foo1]: MySharedPtr::reset MySharedPtr(0x7ffeea47e688,Foo(0x7f94894029c8, data=foo1-data))
+[foo1]: MySharedPtr::reset MySharedPtr(0x7ffeee280688,Foo(0x7f8d564029c8, data=foo1-data))
 sptr1 ref count now 0
-[foo1]: MySharedPtr::reset MySharedPtr(0x7ffeea47e608,Foo(0x7f94894029c8, data=foo1-data))
-delete Foo(0x7f94894029c8, data=foo1-data)
+[foo1]: MySharedPtr::reset MySharedPtr(0x7ffeee280608,Foo(0x7f8d564029c8, data=foo1-data))
+delete Foo(0x7f8d564029c8, data=foo1-data)
 sptr2 ref count now 0
-[foo1]: MySharedPtr::delete MySharedPtr(0x7ffeea47e608)
-[foo1]: MySharedPtr::delete MySharedPtr(0x7ffeea47e688)
+[foo1]: MySharedPtr::delete MySharedPtr(0x7ffeee280608)
+[foo1]: MySharedPtr::delete MySharedPtr(0x7ffeee280688)
 </pre>
 How to use std::unique_ptr
 ==========================
@@ -370,7 +572,7 @@ int main (void)
 ```
 To build:
 <pre>
-cd unique_ptr
+cd std_unique_ptr
 rm -f *.o example
 c++ -std=c++2a -Werror -g -ggdb3 -Wall -c -o main.o main.cpp
 c++ main.o  -o example
@@ -380,21 +582,21 @@ Expected output:
 <pre>
 
 # NOTE: make_unique creates a new ptr and will invoke foo1's copy constructor:
-new Foo(0x7ffee3843088, data=foo1)
-copy constructor Foo(0x7fc4255028a0, data=)
-delete Foo(0x7ffee3843088, data=foo1)
+new Foo(0x7ffee7c08088, data=foo1)
+copy constructor Foo(0x7f9258c029e0, data=)
+delete Foo(0x7ffee7c08088, data=foo1)
 
 # NOTE: to avoid the copy, do this:
-new Foo(0x7fc4255028c0, data=foo2)
+new Foo(0x7f9258c02a00, data=foo2)
 
 # As you cannot copy unique pointers, reassign it with move
 
 # Let's print all the unique ptrs now
-uptr1 = Foo(0x7fc4255028a0, data=foo1)
+uptr1 = Foo(0x7f9258c029e0, data=foo1)
 uptr2 = nullptr
-uptr3 = Foo(0x7fc4255028c0, data=foo2)
+uptr3 = Foo(0x7f9258c02a00, data=foo2)
 
 # Expect the unique ptr data to be destroyed now
-delete Foo(0x7fc4255028c0, data=foo2)
-delete Foo(0x7fc4255028a0, data=foo1)
+delete Foo(0x7f9258c02a00, data=foo2)
+delete Foo(0x7f9258c029e0, data=foo1)
 </pre>

README.md.template

@@ -11,9 +11,11 @@ individually or as a whole.
 Let me know if this is useful to anyone or if there are any areas you want
 covered. This is (probably forever) a work in progress.
 
-[How to use std::unique_ptr](unique_ptr/README.md)
+[How to use std::move](std_move/README.md)
 
-[How to use std::shared_ptr](shared_ptr/README.md)
+[How to use std::unique_ptr](std_unique_ptr/README.md)
 
-[How to make your own wrapper around std::shared_ptr](shared_ptr_wrapper/README.md)
+[How to use std::shared_ptr](std_shared_ptr/README.md)
+
+[How to make your own wrapper around std::shared_ptr](std_shared_ptr_wrapper/README.md)
 

RUNME

@@ -3,10 +3,13 @@
 # This is a wrapper script to build all examples and update the documents
 #
 . common/common.sh
-for i in \
-    unique_ptr \
-    shared_ptr \
-    shared_ptr_wrapper
+
+SUBDIRS="std_move \
+         std_unique_ptr \
+         std_shared_ptr \
+         std_shared_ptr_wrapper"
+
+for i in $SUBDIRS
 do
     echo
     log $i: