![\"dragon](\"https:\/\/www.modernescpp.com\/wp-content\/uploads\/2019\/08\/dragon-4417431_1280.png\")
<\/h2>\nToday, I conclude my story to your myths about C++. These myths are around function parameters, the initialisation of class members, and pointer versus references.<\/p>\n
<\/p>\n
<\/h2>\nYou have two options when a function takes its parameter and doesn’t want to modify it.<\/p>\n
This was the correctness perspective, but what can be said about the performance? The C++ core guidelines are specific about performance. Let’s look at the following example.<\/p>\n
void<\/span> f1<\/span>(const<\/span> string&<\/span> s); \/\/ OK: pass by reference to const; always cheap<\/span>\r\n\r\nvoid<\/span> f2<\/span>(string s); \/\/ bad: potentially expensive<\/span>\r\n\r\nvoid<\/span> f3<\/span>(int<\/span> x); \/\/ OK: Unbeatable<\/span>\r\n\r\nvoid<\/span> f4<\/span>(const<\/span> int<\/span>&<\/span> x); \/\/ bad: overhead on access in f4()<\/span>\r\n<\/pre>\n<\/div>\n <\/p>\n
Presumably, based on experience, the guidelines state a rule of thumb:<\/p>\n
\n- You should take a parameter p by const reference if sizeof(p) > 4 * sizeof(int)<\/span><\/strong><\/li>\n
- You should copy a parameter p<\/span> if sizeof(p) < 3 * sizeof(int)<\/span><\/strong><\/li>\n<\/ul>\n
Okay, now you should know how big your data types are. The program sizeofArithmeticTypes.cpp<\/span> gives the answers for arithmetic types.<\/p>\n\n\/\/ sizeofArithmeticTypes.cpp<\/span>\r\n\r\n#include <iostream><\/span>\r\n\r\nint<\/span> main<\/span>(){\r\n \r\n std::<\/span>cout <<<\/span> std::<\/span>endl;\r\n \r\n std::<\/span>cout <<<\/span> \"sizeof(void*): \"<\/span> <<<\/span> sizeof<\/span>(void<\/span>*<\/span>) <<<\/span> std::<\/span>endl; \r\n \r\n std::<\/span>cout <<<\/span> std::<\/span>endl;\r\n \r\n std::<\/span>cout <<<\/span> \"sizeof(5): \"<\/span> <<<\/span> sizeof<\/span>(5<\/span>) <<<\/span> std::<\/span>endl;\r\n std::<\/span>cout <<<\/span> \"sizeof(5l): \"<\/span> <<<\/span> sizeof<\/span>(5l<\/span>) <<<\/span> std::<\/span>endl;\r\n std::<\/span>cout <<<\/span> \"sizeof(5ll): \"<\/span> <<<\/span> sizeof<\/span>(5ll<\/span>) <<<\/span> std::<\/span>endl;\r\n \r\n std::<\/span>cout <<<\/span> std::<\/span>endl;\r\n \r\n std::<\/span>cout <<<\/span> \"sizeof(5.5f): \"<\/span> <<<\/span> sizeof<\/span>(5.5f<\/span>) <<<\/span> std::<\/span>endl;\r\n std::<\/span>cout <<<\/span> \"sizeof(5.5): \"<\/span> <<<\/span> sizeof<\/span>(5.5<\/span>) <<<\/span> std::<\/span>endl; \r\n std::<\/span>cout <<<\/span> \"sizeof(5.5l): \"<\/span> <<<\/span> sizeof<\/span>(5.5<\/span>l) <<<\/span> std::<\/span>endl; \r\n \r\n std::<\/span>cout <<<\/span> std::<\/span>endl;\r\n \r\n}\r\n<\/pre>\n<\/div>\n <\/p>\n
sizeof(void*)<\/span> returns if it is a 32-bit or a 64-bit system. Thanks to an online compiler rextester<\/a>, I can execute the program with GCC, Clang, and cl.exe (Windows). Here are the numbers for all 64-bit systems.<\/p>\n<\/p>\nGCC<\/h3>\n
![\"sizeofGCC\"](\"https:\/\/www.modernescpp.com\/wp-content\/uploads\/2019\/08\/sizeofGCC.png\")
<\/p>\n
Clang<\/h3>\n
![\"sizeofClang\"](\"https:\/\/www.modernescpp.com\/wp-content\/uploads\/2019\/08\/sizeofClang.png\")
<\/p>\n
cl.exe (Windows)<\/h3>\n
![\"sizeofVC\"](\"https:\/\/www.modernescpp.com\/wp-content\/uploads\/2019\/08\/sizeofVC.png\")
<\/p>\n
cl.exe behaves differently from GCC and Clang. A long int<\/span> has only 4 bytes, and a long double<\/span> has 8 bytes. On GCC and Clang, long int<\/span> and long double have<\/span> double size.<\/p>\nDeciding when to take the parameter by value or by const reference is just math. If you want to know the exact performance numbers for your architecture, there is only one answer: measure<\/strong>.<\/p>\nInitialization and Assignment in the Constructor are equivalent (Gunter K\u00f6nigsmann)<\/h2>\n
First, let me show you initialization and assignment in the constructor.<\/p>\n
\nclass<\/span> Good<\/span>{ \r\n int i;\r\npublic:<\/span>\r\n Good(int i_):<\/span> i{i_<\/span>}{} \r\n};\r\n\r\nclass<\/span> Bad<\/span>{ \r\n int i;\r\npublic:<\/span>\r\n Bad(int i_):<\/span> { i = i_<\/span><\/span>; } \r\n};\r\n<\/pre>\n<\/div>\n <\/p>\n
The class Good<\/span> uses initialization but the class Bad<\/span> assignment. The consequences are:<\/p>\n\n- The variable i<\/span> is directly initialized in the class Good<\/span><\/li>\n
- The variable i<\/span> is default constructed and then assigned to the class Bad<\/span><\/li>\n<\/ul>\n
The constructor initialization is, on the one hand, slower but does not work on the other hand for const members, references, or members which can not be default-constructed possible.<\/p>\n
\n\/\/ constructorAssignment.cpp<\/span>\r\n\r\nstruct<\/span> NoDefault{\r\n NoDefault(int<\/span>){};\r\n};\r\n\r\nclass<\/span> Bad<\/span>{\r\n const<\/span> int<\/span> constInt;\r\n int<\/span>&<\/span> refToInt;\r\n NoDefault noDefault;\r\npublic:<\/span>\r\n Bad(int<\/span> i, int<\/span>&<\/span> iRef){\r\n constInt =<\/span> i;\r\n refToInt =<\/span> iRef;\r\n }\r\n \/\/ Bad(int i, int& iRef): constInt(i), refToInt(iRef), noDefault{i} {}<\/span>\r\n};\r\n\r\nint<\/span> main<\/span>(){\r\n \r\n int<\/span> i =<\/span> 10<\/span>;\r\n int<\/span>&<\/span> j =<\/span> i;\r\n \r\n Bad bad(i, j);\r\n \r\n}\r\n<\/pre>\n<\/div>\n <\/p>\n
When I try to compile the program, I get three different errors.<\/p>\n
\n- constInt<\/span> is not initialized and can not be assigned in the constructor.<\/li>\n
- refToIn<\/span>t is not initialized.<\/li>\n
- The class NoDefault<\/span> has no default constructor because I implemented one constructor for int<\/span>. When implementing a constructor, the compiler will not automatically generate a default constructor.<\/li>\n<\/ol>\n
<\/p>\n
![\"constructorAssignment\"](\"https:\/\/www.modernescpp.com\/wp-content\/uploads\/2019\/08\/constructorAssignment.png\")
<\/p>\n
In the second successful compilation, I used the second commented-out constructor, which uses initialization instead of assignment.<\/p>\n
The example used references instead of raw pointers for a good reason.<\/p>\n
You need Raw Pointers in your Code (Thargon110<\/span><\/span>)<\/h2>\nMotivated by a comment from Thargon110, I want to be dogmatic: NNN. What? I mean N<\/strong>o Na<\/strong>ked N<\/strong>ew. From an application perspective, there is no reason to use raw pointers. If you need a pointer like semantic, put your pointer into an smart pointer (You see: NNN), and you are done.<\/p>\nIn essence, C++11 has a std::unique_ptr<\/span> for exclusive ownership and a std::shared_ptr<\/span> for shared ownership. Consequently, when you copy a std::shared_ptr<\/span>, the reference counter is incremented, and when you delete the std::shared_ptr,<\/span> the reference counter is decremented. Ownership means that the smart pointer keeps track of the underlying memory and releases the memory if it is not necessary anymore. The memory is not necessary any more in the case of the std::shared_ptr when the reference counter becomes 0.<\/p>\nSo memory leaks are gone with modern C++. Now I hear your complaints. I’m happy to destroy them.<\/p>\n
\n- Cycles of std::shared_ptr<\/span> can create a memory leak because the reference counter will not become 0. Right, put a std::weak_ptr<\/span> in-between to break the cyclic reference: std::weak_ptr. <\/a><\/li>\n
- A std::shared_ptr<\/span> has a management overhead and is, therefore, more expensive than a raw pointer. Right, use a std::unique_ptr.<\/span><\/a><\/li>\n
- A std::unique_ptr<\/span> is not comfortable enough because it can’t be copied. Right, but a std::unique_ptr<\/span> can be moved.<\/li>\n<\/ul>\n
The last complaint is quite dominant. A small example should make my point:<\/p>\n
<\/p>\n
\n\/\/ moveUniquePtr.cpp<\/span>\r\n\r\n#include <algorithm><\/span>\r\n#include <iostream><\/span>\r\n#include <memory><\/span>\r\n#include <utility><\/span>\r\n#include <vector><\/span>\r\n\r\nvoid<\/span> takeUniquePtr<\/span>(std::<\/span>unique_ptr<<\/span>int<\/span>><\/span> uniqPtr){ \/\/ (1)<\/span>\r\n std::<\/span>cout <<<\/span> \"*uniqPtr: \"<\/span> <<<\/span> *<\/span>uniqPtr <<<\/span> std::<\/span>endl;\r\n}\r\n\r\nint<\/span> main<\/span>(){\r\n \r\n std::<\/span>cout <<<\/span> std::<\/span>endl;\r\n \r\n auto<\/span> uniqPtr1 =<\/span> std::<\/span>make_unique<<\/span>int<\/span>><\/span>(2014<\/span>);\r\n \r\n takeUniquePtr(std::<\/span>move(uniqPtr1)); \/\/ (1)<\/span>\r\n \r\n auto<\/span> uniqPtr2 =<\/span> std::<\/span>make_unique<<\/span>int<\/span>><\/span>(2017<\/span>);\r\n auto<\/span> uniqPtr3 =<\/span> std::<\/span>make_unique<<\/span>int<\/span>><\/span>(2020<\/span>);\r\n auto<\/span> uniqPtr4 =<\/span> std::<\/span>make_unique<<\/span>int<\/span>><\/span>(