![\"sao](\"https:\/\/www.modernescpp.com\/wp-content\/uploads\/2019\/08\/sao-jorge-1503439_1280.png\")
<\/p>\nDemystifying non-rules and myths in C++ is a laborious but essential job. The goal is simple: use the powerful tool C++ appropriately.<\/p>\n
<\/p>\n
<\/p>\n
By the way, did you notice that my family name qualifies me, in particular, to write about this demystification? Anyway, here are the rules from the C++ core guidelines for today.<\/p>\n
goto exit<\/code><\/a><\/li>\n<\/ul>\nNR.5: Don\u2019t: Don\u2019t do substantive work in a constructor; instead, use two-phase initialization<\/a><\/h3>\nThis is the job of a constructor: After the constructor is executed, you should have a fully initialized object.<\/strong> For that reason, the following code snippet from the guidelines is terrible. <\/p>\n\nclass<\/span> Picture<\/span>\r\n{\r\n int<\/span> mx;\r\n int<\/span> my;\r\n char<\/span> *<\/span> data;\r\npublic:<\/span>\r\n Picture(int<\/span> x, int<\/span> y)\r\n {\r\n mx =<\/span> x,\r\n my =<\/span> y;\r\n data =<\/span> nullptr;\r\n }\r\n\r\n ~<\/span>Picture()\r\n {\r\n Cleanup();\r\n }\r\n\r\n bool<\/span> Init()\r\n {\r\n \/\/ invariant checks<\/span>\r\n if<\/span> (mx <=<\/span> 0<\/span> ||<\/span> my <=<\/span> 0<\/span>) {\r\n return<\/span> false<\/span>;\r\n }\r\n if<\/span> (data) {\r\n return<\/span> false<\/span>;\r\n }\r\n data =<\/span> (char<\/span>*<\/span>) malloc(x*<\/span>y*<\/span>sizeof<\/span>(int<\/span>));\r\n return<\/span> data !=<\/span> nullptr;\r\n }\r\n\r\n void<\/span> Cleanup() \/\/ (2)<\/span>\r\n {\r\n if<\/span> (data) free(data);\r\n data =<\/span> nullptr;\r\n }\r\n};\r\n\r\nPicture picture<\/span>(100<\/span>, 0<\/span>); \/\/ not ready-to-use picture here<\/span>\r\n\/\/ this will fail.. \/\/ (1)<\/span>\r\nif<\/span> (!<\/span>picture.Init()) {\r\n puts(\"Error, invalid picture\"<\/span>);\r\n}\r\n\/\/ now have a invalid picture object instance.<\/span>\r\n<\/pre>\n<\/div>\n <\/p>\n
picture(100, 0)<\/span> is not fully initialized; therefore, all operations on the picture inline (1) operate on an invalid picture. The solution to this problem is as simple as effective: put all initialization into the constructor.<\/p>\n <\/p>\n
\nclass<\/span> Picture<\/span>\r\n{\r\n size_t<\/span> mx;\r\n size_t<\/span> my;\r\n vector<<\/span>char<\/span>><\/span> data;\r\n\r\n static<\/span> size_t<\/span> check_size<\/span>(size_t<\/span> s)\r\n {\r\n \/\/ invariant check<\/span>\r\n Expects(s ><\/span> 0<\/span>);\r\n return<\/span> s;\r\n }\r\n\r\npublic:<\/span>\r\n \/\/ even more better would be a class for a 2D Size as one single parameter<\/span>\r\n Picture(size_t<\/span> x, size_t<\/span> y)\r\n :<\/span> mx(check_size(x))\r\n , my(check_size(y))\r\n \/\/ now we know x and y have a valid size<\/span>\r\n , data(mx *<\/span> my *<\/span> sizeof<\/span>(int<\/span>)) \/\/ will throw std::bad_alloc on error<\/span>\r\n {\r\n \/\/ picture is ready-to-use<\/span>\r\n }\r\n \/\/ compiler generated dtor does the job. (also see C.21)<\/span>\r\n};\r\n<\/pre>\n<\/div>\n <\/p>\n
Additionally, data<\/span> is in the second example a std::vector<\/span> and not a raw pointer. This means the Cleanup<\/span> function (line 2) from the first example is not necessary anymore because the compiler will automatically clean up. Thanks to the static function check_size,<\/span> the constructor can validate its arguments. But this is not the end of the benefits modern C++ gives up. <\/p>\nOften you use constructors to set the default behavior of an object. Please don’t do it. Directly set the default behavior of an object in the class body. For example, compare the following classes Widget<\/span> and WidgetImpro.<\/span><\/p>\n <\/p>\n
\n\/\/ classMemberInitialiserWidget.cpp<\/span>\r\n\r\n#include <iostream><\/span>\r\n\r\nclass<\/span> Widget<\/span>{\r\n public:<\/span>\r\n Widget():<\/span> width(640<\/span>), height(480<\/span>), frame(false<\/span>), visible(true<\/span>) {}\r\n explicit<\/span> Widget(int<\/span> w):<\/span> width(w), height(getHeight(w)), frame(false<\/span>), visible(true<\/span>){}\r\n Widget(int<\/span> w, int<\/span> h):<\/span> width(w), height(h), frame(false<\/span>), visible(true<\/span>){}\r\n\r\n void<\/span> show(){ std::<\/span>cout <<<\/span> std::<\/span>boolalpha <<<\/span> width <<<\/span> \"x\"<\/span> <<<\/span> height\r\n <<<\/span> \", frame: \"<\/span> <<<\/span> frame <<<\/span> \", visible: \"<\/span> <<<\/span> visible\r\n <<<\/span> std::<\/span>endl;\r\n }\r\n private:<\/span>\r\n int<\/span> getHeight(int<\/span> w){ return<\/span> w*<\/span>3<\/span>\/<\/span>4<\/span>; }\r\n int<\/span> width;\r\n int<\/span> height;\r\n bool<\/span> frame;\r\n bool<\/span> visible;\r\n};\r\n\r\nclass<\/span> WidgetImpro<\/span>{\r\n public:<\/span>\r\n WidgetImpro(){}\r\n explicit<\/span> WidgetImpro(int<\/span> w):<\/span> width(w), height(getHeight(w)){}\r\n WidgetImpro(int<\/span> w, int<\/span> h):<\/span> width(w), height(h){}\r\n\r\n void<\/span> show(){ std::<\/span>cout <<<\/span> std::<\/span>boolalpha <<<\/span> width <<<\/span> \"x\"<\/span> <<<\/span> height\r\n <<<\/span> \", frame: \"<\/span> <<<\/span> frame <<<\/span> \", visible: \"<\/span> <<<\/span> visible\r\n <<<\/span> std::<\/span>endl;\r\n }\r\n\r\n private:<\/span>\r\n int<\/span> getHeight(int<\/span> w){ return<\/span> w *<\/span> 3<\/span> \/<\/span> 4<\/span>; }\r\n int<\/span> width =<\/span> 640<\/span>;\r\n int<\/span> height =<\/span> 480<\/span>;\r\n bool<\/span> frame =<\/span> false<\/span>;\r\n bool<\/span> visible =<\/span> true<\/span>;\r\n};\r\n\r\n\r\nint<\/span> main<\/span>(){\r\n\r\n std::<\/span>cout <<<\/span> std::<\/span>endl;\r\n\r\n Widget wVGA;\r\n Widget wSVGA(800<\/span>);\r\n Widget wHD(1280<\/span>, 720<\/span>);\r\n\r\n wVGA.show();\r\n wSVGA.show();\r\n wHD.show();\r\n\r\n std::<\/span>cout <<<\/span> std::<\/span>endl;\r\n\r\n WidgetImpro wImproVGA;\r\n WidgetImpro wImproSVGA(800<\/span>);\r\n WidgetImpro wImproHD(1280<\/span>, 720<\/span>);\r\n\r\n wImproVGA.show();\r\n wImproSVGA.show();\r\n wImproHD.show();\r\n\r\n std::<\/span>cout <<<\/span> std::<\/span>endl;\r\n\r\n}\r\n<\/pre>\n<\/div>\n <\/p>\n
Both classes behave the same.<\/p>\n
![\"classMemberInitialiserWidget\"](\"https:\/\/www.modernescpp.com\/wp-content\/uploads\/2019\/08\/classMemberInitialiserWidget.png\")
<\/p>\n
The difference is that the constructors for the class WidgetImpro<\/span> are way more comfortable to use and extend. When you add a new variable to both classes, in the case of WidgetImpro, you have only to edit one place, but each constructor in the case of the class Widget<\/span> class is affected. Here is the picture I have in mind when I design a new class: Define the default behavior of each object in the class body. Use explicit constructors to vary the default behavior.<\/strong><\/p>\nDone? No!<\/p>\n
Often you use an init function to put standard initialization or validation stuff into one place. You follow the necessary DRY (D<\/strong>on’t R<\/strong>epeat Y<\/strong>ourself<\/a>) principle but automatically break the other important principle that your object should be fully initialized after the constructor call. How can you solve this riddle? Quite easy. Since C++11, we have constructor delegation. This means putting the standard initialization and validation stuff into one intelligent constructor and using the other constructors as a kind of wrapper-constructors. Here is my idea translated to code.<\/p>\n <\/p>\n
\n\/\/ constructorDelegation.cpp<\/span>\r\n\r\n#include <cmath><\/span>\r\n#include <iostream><\/span>\r\n\r\nclass<\/span> Degree<\/span>{\r\npublic:<\/span>\r\n explicit<\/span> Degree(int<\/span> deg){ \/\/ (2)<\/span>\r\n degree =<\/span> deg %<\/span> 360<\/span>;\r\n if<\/span> (degree <<\/span> 0<\/span>) degree +=<\/span> 360<\/span>;\r\n }\r\n \r\n Degree() =<\/span> default<\/span>;\r\n \/\/ (3)<\/span>\r\n explicit<\/span> Degree<\/span>(double<\/span> deg):<\/span>Degree(static_cast<\/span><<\/span>int<\/span>><\/span>(ceil(deg))) {} \r\n\r\n int<\/span> getDegree() const<\/span> { return<\/span> degree; }\r\n\r\n