![\"\"](\"https:\/\/www.modernescpp.com\/wp-content\/uploads\/2018\/04\/athlete-bicycle-bike-12838.jpg\")
<\/p>\nIn this post, I continue my journey through the rules to performance in the C++ Core Guidelines. I will mainly write about design for optimization.<\/p>\n
<\/p>\n
<\/p>\n
Here are the two rules for today. <\/p>\n
When I read this title, I immediately have to think about move semantics. Why? Because you should write your algorithms with move semantics and not with copy semantics. You will automatically get a few benefits. <\/p>\n
Understood! Let me implement a generic swap<\/span> algorithm that uses move semantics.<\/p>\n <\/p>\n Fine. That was it. No! My coworker gave me his type BigArray<\/span>. BigArray<\/span> has a few flaws. I will write about the copy assignment operator (1) later. First of all, I have a more serious concern. BigArray<\/span> does not support move semantics but only copy semantics. What will happen if I swap the BigArrays<\/span> in line (2)? My swap<\/span> algorithm uses move semantic (3) under the hood. Let’s try it out.<\/p>\n <\/p>\n Nothing bad will happen. Traditional copy semantics will kick in, and you will get the classical behavior. Copy semantics is a kind of fallback to move semantics. You can see it the other way around. The move is an optimized copy. <\/p>\n How is that possible? I asked for a move operation in my swap<\/span> algorithm. The reason is that std::move<\/span> returns a rvalue. A const lvalue reference can bind to an rvalue, and the copy constructor or a copy assignment operator takes a const lvalue reference. If BigArray<\/span> had a move constructor or a move assignment operator taking rvalue references, both would have higher priority than the copy pendants. <\/p>\n Implementing your algorithms with move semantic means that move semantic will automatically kick in if your data types support it. If not, copy semantics will be used as a fallback. In the worst case, you will have classical behavior.<\/p>\n I said the copy assignment operator has a few flaws. Here are they:<\/p>\n <\/p>\n You can overcome these flaws by implementing your swap function. This is already suggested by the C++ Core Guidelines: C.83: For value-like types, consider providing a <\/p>\n The swap function inline (1) is not a member; therefore, a call swap(bigArray1, bigArray2)<\/span> uses it. The signature of the copy assignment operator in line (2) may surprise you. Because of the copy, no self-assignment test is necessary. Additionally, the strong exception guarantee holds, and there is no code duplication. This technique is called the copy-and-swap idiom<\/a>.<\/p>\n There are a lot of overloaded versions of std::swap<\/span> available. The C++ standard provides about 50 overloads. <\/p>\n<\/p>\n This is a kind of meta-rule in C++. Catch errors at compile-time. I can make my explanation of this rule relatively short because I have already written a few articles on this critical topic:<\/p>\n\n\/\/ swap.cpp<\/span>\r\n\r\n#include <algorithm><\/span>\r\n#include <cstddef> <\/span>\r\n#include <iostream><\/span>\r\n#include <vector><\/span>\r\n\r\ntemplate<\/span> <<\/span>typename<\/span> T><\/span> \/\/ (3)<\/span>\r\nvoid<\/span> swap(T&<\/span> a, T&<\/span> b) noexcept {\r\n T tmp(std::<\/span>move(a));\r\n a =<\/span> std::<\/span>move(b);\r\n b =<\/span> std::<\/span>move(tmp);\r\n}\r\n\r\nclass<\/span> BigArray<\/span>{\r\n\r\npublic:<\/span>\r\n BigArray(std::<\/span>size_t<\/span> sz):<\/span> size(sz), data(new<\/span> int<\/span>[size]){}\r\n\r\n BigArray(const<\/span> BigArray&<\/span> other):<\/span> size(other.size), data(new<\/span> int<\/span>[other.size]){\r\n std::<\/span>cout <<<\/span> \"Copy constructor\"<\/span> <<<\/span> std::<\/span>endl;\r\n std::<\/span>copy(other.data, other.data +<\/span> size, data);\r\n }\r\n \r\n BigArray&<\/span> operator<\/span>=<\/span>(const<\/span> BigArray&<\/span> other){ \/\/ (1)<\/span>\r\n std::<\/span>cout <<<\/span> \"Copy assignment\"<\/span> <<<\/span> std::<\/span>endl;\r\n if<\/span> (this<\/span> !=<\/span> &<\/span>other){\r\n delete<\/span> [] data;\r\n data =<\/span> nullptr;\r\n\t\t\t\r\n size =<\/span> other.size;\r\n data =<\/span> new<\/span> int<\/span>[size];\r\n std::<\/span>copy(other.data, other.data +<\/span> size, data);\r\n }\r\n return<\/span> *<\/span>this<\/span>;\r\n }\r\n \r\n ~<\/span>BigArray(){\r\n delete<\/span>[] data;\r\n }\r\nprivate:<\/span>\r\n std::<\/span>size_t<\/span> size;\r\n int<\/span>*<\/span> data;\r\n};\r\n\r\nint<\/span> main<\/span>(){\r\n\r\n std::<\/span>cout <<<\/span> std::<\/span>endl;\r\n\r\n BigArray bigArr1(2011<\/span>);\r\n BigArray bigArr2(2017<\/span>);\r\n swap(bigArr1, bigArr2); \/\/ (2)<\/span>\r\n\r\n std::<\/span>cout <<<\/span> std::<\/span>endl;\r\n\r\n};\r\n<\/pre>\n<\/div>\n![\"swap\"](\"https:\/\/www.modernescpp.com\/wp-content\/uploads\/2018\/04\/swap.png\")
<\/p>\n\nBigArray&<\/span> operator<\/span>=<\/span>(const<\/span> BigArray&<\/span> other){ \r\n if<\/span> (this<\/span> !=<\/span> &<\/span>other){ \/\/ (1)<\/span>\r\n delete<\/span> [] data; \r\n data =<\/span> nullptr;\r\n\t\t\t\r\n size =<\/span> other.size;\r\n data =<\/span> new<\/span> int<\/span>[size]; \/\/ (2)<\/span>\r\n std::<\/span>copy(other.data, other.data +<\/span> size, data); \/\/ (3)<\/span>\r\n }\r\n return<\/span> *<\/span>this<\/span>;\r\n}\r\n<\/pre>\n<\/div>\n\n
noexcept<\/code> swap function<\/a>. Here is the new BigArray<\/span> having a non-member swap<\/span> function and a copy assignment operator using the swap<\/span> function. <\/p>\n\nclass<\/span> BigArray<\/span>{\r\n\r\npublic:<\/span>\r\n BigArray(std::<\/span>size_t<\/span> sz):<\/span> size(sz), data(new<\/span> int<\/span>[size]){}\r\n\r\n BigArray(const<\/span> BigArray&<\/span> other):<\/span> size(other.size), data(new<\/span> int<\/span>[other.size]){\r\n std::<\/span>cout <<<\/span> \"Copy constructor\"<\/span> <<<\/span> std::<\/span>endl;\r\n std::<\/span>copy(other.data, other.data +<\/span> size, data);\r\n }\r\n\t\r\n BigArray&<\/span> operator<\/span> =<\/span> (BigArray other){ \/\/ (2)<\/span>\r\n swap(*<\/span>this<\/span>, other); \r\n return<\/span> *<\/span>this<\/span>;\r\n }\r\n \r\n ~<\/span>BigArray(){\r\n delete<\/span>[] data;\r\n }\r\n\t\r\n friend<\/span> void<\/span> swap(BigArray&<\/span> first, BigArray&<\/span> second){ \/\/ (1)<\/span>\r\n std::<\/span>swap(first.size, second.size);\r\n std::<\/span>swap(first.data, second.data);\r\n }\r\n\t\r\nprivate:<\/span>\r\n std::<\/span>size_t<\/span> size;\r\n int<\/span>*<\/span> data;\r\n};\r\n<\/pre>\n<\/div>\nPer.10: Rely on the static type system<\/a><\/h3>\n
\n
\n
What’s next?<\/h2>\n