{"id":5095,"date":"2016-12-22T18:19:09","date_gmt":"2016-12-22T18:19:09","guid":{"rendered":"https:\/\/www.modernescpp.com\/index.php\/move-semantic-tow-nice-properties\/"},"modified":"2023-06-26T12:31:05","modified_gmt":"2023-06-26T12:31:05","slug":"move-semantic-tow-nice-properties","status":"publish","type":"post","link":"https:\/\/www.modernescpp.com\/index.php\/move-semantic-tow-nice-properties\/","title":{"rendered":"Move Semantis: Two Nice Properties"},"content":{"rendered":"

I will talk about two nice properties of the move semantic in this post that is not so often mentioned. Containers of the standard template library (STL) can have non-copyable elements. The copy semantic is the fallback for the move semantic. Irritated? I hope so!<\/p>\n

<\/p>\n

 <\/p>\n

Moving Instead of Copying<\/h2>\n

Do you remember the program packagedTask.cpp<\/span> from the post Asynchronous callable wrappers<\/a>? Of course, not. Here, once more.<\/p>\n

Moving elements in a container<\/h3>\n
\n\n\n\n
\n
 1\r\n 2\r\n 3\r\n 4\r\n 5\r\n 6\r\n 7\r\n 8\r\n 9\r\n10\r\n11\r\n12\r\n13\r\n14\r\n15\r\n16\r\n17\r\n18\r\n19\r\n20\r\n21\r\n22\r\n23\r\n24\r\n25\r\n26\r\n27\r\n28\r\n29\r\n30\r\n31\r\n32\r\n33\r\n34\r\n35\r\n36\r\n37\r\n38\r\n39\r\n40\r\n41\r\n42\r\n43\r\n44\r\n45\r\n46\r\n47\r\n48\r\n49\r\n50\r\n51\r\n52\r\n53\r\n54\r\n55\r\n56\r\n57\r\n58\r\n59\r\n60\r\n61\r\n62\r\n63\r\n64\r\n65\r\n66\r\n67<\/pre>\n<\/td>\n
\n
\/\/ packagedTask.cpp<\/span>\r\n\r\n#include <utility><\/span>\r\n#include <future><\/span>\r\n#include <iostream><\/span>\r\n#include <thread><\/span>\r\n#include <deque><\/span>\r\n\r\nclass<\/span> SumUp<\/span>{\r\n  public:\r\n    int<\/span> operator<\/span>()(int<\/span> beg, int<\/span> end){\r\n      long<\/span> long<\/span> int<\/span> sum{0};\r\n      for<\/span> (int<\/span> i= beg; i < end; ++i ) sum += i;\r\n      return<\/span> sum;\r\n    }\r\n};\r\n\r\nint<\/span> main(){\r\n\r\n  std::cout << std::endl;\r\n\r\n  SumUp sumUp1;\r\n  SumUp sumUp2;\r\n  SumUp sumUp3;\r\n  SumUp sumUp4;\r\n\r\n  \/\/ define the tasks<\/span>\r\n  std::packaged_task<int<\/span>(int<\/span>,int<\/span>)> sumTask1(sumUp1);\r\n  std::packaged_task<int<\/span>(int<\/span>,int<\/span>)> sumTask2(sumUp2);\r\n  std::packaged_task<int<\/span>(int<\/span>,int<\/span>)> sumTask3(sumUp3);\r\n  std::packaged_task<int<\/span>(int<\/span>,int<\/span>)> sumTask4(sumUp4);\r\n\r\n  \/\/ get the futures<\/span>\r\n  std::future<int<\/span>> sumResult1= sumTask1.get_future();\r\n  std::future<int<\/span>> sumResult2= sumTask2.get_future();\r\n  std::future<int<\/span>> sumResult3= sumTask3.get_future();\r\n  std::future<int<\/span>> sumResult4= sumTask4.get_future();\r\n\r\n  \/\/ push the tasks on the container<\/span>\r\n  std::deque< std::packaged_task<int<\/span>(int<\/span>,int<\/span>)> > allTasks;\r\n  allTasks.push_back(std::move(sumTask1));\r\n  allTasks.push_back(std::move(sumTask2));\r\n  allTasks.push_back(std::move(sumTask3));\r\n  allTasks.push_back(std::move(sumTask4));\r\n  \r\n  int<\/span> begin{1};\r\n  int<\/span> increment{2500};\r\n  int<\/span> end= begin + increment;\r\n\r\n  \/\/ execute each task in a separate thread<\/span>\r\n  while<\/span> ( not allTasks.empty() ){\r\n    std::packaged_task<int<\/span>(int<\/span>,int<\/span>)> myTask= std::move(allTasks.front());\r\n    allTasks.pop_front();\r\n    std::thread<\/span> sumThread(std::move(myTask),begin,end);\r\n    begin= end;\r\n    end += increment;\r\n    sumThread.detach();\r\n  }\r\n\r\n  \/\/ get the results<\/span>\r\n  auto<\/span> sum= sumResult1.get() + sumResult2.get() + sumResult3.get() + sumResult4.get();\r\n\r\n  std::cout << \"sum of 0 .. 10000 = \"<\/span> << sum << std::endl;\r\n\r\n  std::cout << std::endl;\r\n\r\n}\r\n<\/pre>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n
 <\/p>\n
I’m not interested in the program that calculates the sum of the numbers from 0 .. 10000 in four threads.<\/p>\n
I’m interested in a completely different property of std:::packaged_task. std::packaged_task<\/span> is not copyable. The reason is simple. The copy constructor and copy assignment operator are set to delete<\/span>. You can read the details here: cppreference.com<\/a>.<\/p>\n
How is it possible to use std::package_task<\/span> as an element in a container of the STL? Containers of the STL want to own their elements. Therefore, I move via std::move<\/span> the std::package_task<\/span> objects (lines 41 – 44) into the container std::deque.<\/span> Consequently, I must use the move semantic in lines 52 and 54 because I can not copy the std::package_task.<\/span><\/p>\n
But that is not the end of the story. If an algorithm of the STL uses, under the hood, no copy semantics, you can apply it to containers with non-copyable elements. You will get a compiler error if the algorithm uses internal copy semantics.<\/p>\n<\/p>\n
The algorithm on only moveable elements <\/h3>\n
In the next example, I make it very simple. I define a simple wrapper MyInt<\/span> for natural numbers.
<\/span><\/span><\/p>\n
<\/p>\n
\n\n\n\n
\n
 1\r\n 2\r\n 3\r\n 4\r\n 5\r\n 6\r\n 7\r\n 8\r\n 9\r\n10\r\n11\r\n12\r\n13\r\n14\r\n15\r\n16\r\n17\r\n18\r\n19\r\n20\r\n21\r\n22\r\n23\r\n24\r\n25\r\n26\r\n27\r\n28\r\n29\r\n30\r\n31\r\n32\r\n33\r\n34\r\n35\r\n36\r\n37\r\n38\r\n39\r\n40\r\n41\r\n42\r\n43\r\n44\r\n45\r\n46<\/pre>\n<\/td>\n
\n
\/\/ moveAlgorithm.cpp<\/span>\r\n#include <numeric> <\/span>\r\n#include <algorithm> <\/span>\r\n#include <iostream><\/span>\r\n#include <utility><\/span>\r\n#include <vector><\/span>\r\n \r\nclass<\/span> MyInt<\/span>{\r\npublic:\r\n    MyInt(int<\/span> i_):i(i_){}\r\n    \r\n    \/\/ copy semantic<\/span>\r\n    MyInt(const<\/span> MyInt&)= delete<\/span>;\r\n    MyInt& operator<\/span>= (const<\/span> MyInt&)= delete<\/span>;\r\n    \r\n    \/\/ move semantic<\/span>\r\n    MyInt(MyInt&&)= default<\/span>;\r\n    MyInt& operator<\/span>= (MyInt&&)= default<\/span>;\r\n    \r\n    int<\/span> getVal() const<\/span> {\r\n        return<\/span> i;\r\n    }\r\nprivate:\r\n    int<\/span> i;\r\n};\r\n\r\nint<\/span> main(){\r\n    \r\n    std::cout << std::endl;\r\n    \r\n    std::vector<MyInt> vecMyInt;\r\n    for<\/span> (auto<\/span> i= 1; i <= 10; ++i){\r\n        vecMyInt.push_back(std::move(MyInt(i)));\r\n    }\r\n    \r\n    std::for_each(vecMyInt.begin(), vecMyInt.end(), [](MyInt& myInt){ std::cout << myInt.getVal() << \" \"<\/span>; });\r\n    \r\n    std::cout << std::endl;\r\n    \r\n    auto<\/span> myInt= MyInt(std::accumulate(vecMyInt.begin(), vecMyInt.end(),MyInt(1),[](MyInt& f, MyInt& s){ return<\/span> f.getVal() * s.getVal(); }));\r\n    \r\n    std::cout << \"myInt.getVal(): \"<\/span> << myInt.getVal() << std::endl;\r\n    \r\n    std::cout << std::endl;\r\n    \r\n}\r\n<\/pre>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n
 <\/p>\n
I only declaratively use delete<\/span> (lines 13 and 14) for the copy semantic and default<\/span> (lines 17 and 18) for the move semantic. Therefore, the compiler will do the right job for me. I implement only the constructor and the getter getVal<\/span> (lines 20 – 22). Although my type is non-copyable, I use it in a std::for_each<\/span> (line 36) and std::accumulate<\/span> (line 40) algorithm of the STL.<\/p>\n
There are no big surprises.<\/p>\n
\"moveAlgorithm\"<\/p>\n
The program will not compile with cl.exe<\/h4>\n
Unfortunately, the program will not compile with a recent cl.exe Compiler (19.10.24807.0 (x86)). Microsoft std::accumulate <\/span>versions use, under the hood, copy semantics. This is opposite to recent GCC or clang compilers, which use move semantics. But cl.exe is right. std::accumulate <\/a> requires that T must be copied, assignable, and copy constructible. This will not hold for MyInt<\/span>. This issue is still under discussion: https:\/\/gcc.gnu.org\/onlinedocs\/libstdc%2B%2B\/ext\/lwg-active.html<\/a><\/p>\n
 <\/p>\n
The copy semantic is a fallback for the move semantic. What does that mean?<\/p>\n
Copy Semantics as a Fallback for Move Semantics<\/h2>\n
If I write an algorithm that internally uses move semantics, I can apply that algorithm to non-copyable types. I have only to change my type MyInt.<\/span><\/p>\n
 <\/p>\n
<\/p>\n
\n\n\n\n
\n
 1\r\n 2\r\n 3\r\n 4\r\n 5\r\n 6\r\n 7\r\n 8\r\n 9\r\n10\r\n11\r\n12\r\n13\r\n14\r\n15\r\n16\r\n17\r\n18\r\n19\r\n20\r\n21\r\n22\r\n23\r\n24\r\n25\r\n26\r\n27\r\n28\r\n29\r\n30\r\n31\r\n32\r\n33\r\n34\r\n35\r\n36\r\n37\r\n38\r\n39\r\n40\r\n41\r\n42\r\n43\r\n44\r\n45\r\n46\r\n47\r\n48\r\n49\r\n50\r\n51\r\n52\r\n53\r\n54<\/pre>\n<\/td>\n
\n
\/\/ copyFallbackMove.cpp<\/span>\r\n\r\n#include <iostream><\/span>\r\n#include <type_traits><\/span>\r\n#include <utility><\/span>\r\n\r\ntemplate<\/span> <typename<\/span> T>\r\nvoid<\/span> swapMove(T& a, T& b){\r\n    T tmp(std::move(a));\r\n    a= std::move(b);\r\n    b= std::move(tmp);\r\n}\r\n\r\nclass<\/span> MyInt<\/span>{\r\npublic:\r\n    MyInt(int<\/span> i_):i(i_){}\r\n    \r\n    \/\/ copy semantic<\/span>\r\n    MyInt(const<\/span> MyInt& myInt):i(myInt.getVal()){}\r\n    MyInt& operator<\/span>= (const<\/span> MyInt& myInt){\r\n        i= myInt.getVal();\r\n        return<\/span> *this<\/span>;\r\n    }\r\n        \r\n    int<\/span> getVal() const<\/span> {\r\n        return<\/span> i;\r\n    }\r\nprivate:\r\n    int<\/span> i;\r\n};\r\n\r\nint<\/span> main(){\r\n    \r\n    std::cout << std::endl;\r\n    MyInt myInt1(1);\r\n    MyInt myInt2(2);\r\n    \r\n    std::cout << std::boolalpha;\r\n    \r\n    std::cout << \"std::is_trivially_move_constructible<MyInt>::value \"<\/span> << std::is_trivially_move_constructible<MyInt>::value << std::endl;\r\n    std::cout << \"std::is_trivially_move_assignable<MyInt>::value \"<\/span> << std::is_trivially_move_assignable<MyInt>::value << std::endl;\r\n    \r\n    std::cout << \"myInt1.getVal() :\"<\/span> << myInt1.getVal() << std::endl;\r\n    std::cout << \"myInt2.getVal() :\"<\/span> << myInt2.getVal() << std::endl;\r\n    \r\n    swapMove(myInt1,myInt2);\r\n    std::cout << std::endl;\r\n    \r\n    std::cout << \"myInt1.getVal() :\"<\/span> << myInt1.getVal() << std::endl;\r\n    std::cout << \"myInt2.getVal() :\"<\/span> << myInt2.getVal() << std::endl;\r\n    \r\n    std::cout << std::endl;\r\n    \r\n}\r\n<\/pre>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n
 <\/p>\n
MyInt <\/span>has a user-defined copy constructor and copy assignment operator. Therefore, the compiler will not automatically generate a move constructor or move assignment operator. You can read the details here (move semantic<\/a>) or ask the type traits library (lines 40 and 41) for help. Sadly, my GCC doesn’t support this function of the type traits library. So I have to use a more recent GCC 5.2. The critical point is that instances of MyInt<\/span> can be used in the function template swapMove<\/span> (lines 7 – 12), although these instances don’t support move semantics. <\/p>\n
 <\/p>\n
\"copyFallbackMove\"<\/p>\n
 <\/p>\n
The reason is: A rvalue can be bound to<\/p>\n