![\"creation](\"https:\/\/www.modernescpp.com\/wp-content\/uploads\/2018\/01\/creation-of-man.png\")
<\/p>\nLet’s continue our tour through the rules for expressions and statements in the C++ core guidelines. This post will be about declarations and initializations. <\/p>\n
<\/p>\n
<\/p>\n
<\/p>\n
<\/p>\n
To be honest, most of the rules in this post are quite obvious but they often provide one or the other very interesting insight; therefore, I will mainly write in this post about these special aspects. Here are the rules for today:<\/p>\n
auto<\/code> to avoid redundant repetition of type names<\/a><\/li>\n- ES.12: Do not reuse names in nested scopes<\/a><\/li>\n
- ES.20: Always initialize an object<\/a><\/li>\n
- ES.21: Don\u2019t introduce a variable (or constant) before you need to use it<\/a><\/li>\n
- ES.22: Don\u2019t declare a variable until you have a value to initialize it with<\/a><\/li>\n
- ES.23: Prefer the
{}<\/code>-initializer syntax<\/a><\/li>\n- <\/a>ES.24: Use a
unique_ptr<T><\/code> to hold pointers<\/a><\/li>\n<\/ul>\nHere are the details. <\/p>\n
ES.11: Use auto<\/code> to avoid redundant repetition of type names<\/a><\/h3>\nThe example from the guidelines is not promising to me. So, let me give you another one. Changing your code may become a piece of cake if you use auto<\/span>. <\/p>\nThe following example is based on auto<\/span>. You do have not to think about the types; therefore, you can not make an error. This means the type of res<\/span> will be int<\/span> at the end.<\/p>\n\nauto<\/span> a =<\/span> 5<\/span>;\r\nauto<\/span> b =<\/span> 10<\/span>;\r\nauto<\/span> sum =<\/span> a *<\/span> b *<\/span> 3<\/span>;\r\nauto<\/span> res =<\/span> sum +<\/span> 10<\/span>; \r\nstd::<\/span>cout <<<\/span> typeid<\/span>(res).name(); \/\/ i<\/span>\r\n<\/pre>\n<\/div>\n <\/p>\n
If you decide to change the literal b<\/span> from int<\/span> to double<\/span> (2) or use in (3) a float<\/span> literal instead of the int<\/span> literal. No problem. It will be automatically handled for you. <\/p>\n <\/p>\n
\nauto<\/span> a =<\/span> 5<\/span>;\r\nauto<\/span> b =<\/span> 10.5<\/span>; \/\/ (1)<\/span>\r\nauto<\/span> sum =<\/span> a *<\/span> b *<\/span> 3<\/span>;\r\nauto<\/span> res =<\/span> sum *<\/span> 10<\/span>; \r\nstd::<\/span>cout <<<\/span> typeid<\/span>(res).name(); \/\/ d<\/span>\r\n \r\nauto<\/span> a =<\/span> 5<\/span>;\r\nauto<\/span> b =<\/span> 10<\/span>;\r\nauto<\/span> sum =<\/span> a *<\/span> b *<\/span> 3.1f<\/span>; \/\/ (2)<\/span>\r\nauto<\/span> res =<\/span> sum *<\/span> 10<\/span>; \r\nstd::<\/span>cout <<<\/span> typeid<\/span>(res).name(); \/\/ f<\/span>\r\n<\/pre>\n<\/div>\n <\/p>\n<\/p>\n
ES.12: Do not reuse names in nested scopes<\/a><\/h3>\nThis is one of these quite apparent rules. You should not reuse names in nested scopes for readability and maintenance reasons.<\/p>\n
\n\/\/ shadow.cpp<\/span>\r\n\r\n#include <iostream><\/span>\r\n\r\nint<\/span> shadow<\/span>(bool<\/span> cond){\r\n int<\/span> d =<\/span> 0<\/span>;\r\n if<\/span> (cond){\r\n d =<\/span> 1<\/span>;\r\n }\r\n else<\/span> {\r\n int<\/span> d =<\/span> 2<\/span>;\r\n d =<\/span> 3<\/span>;\r\n }\r\n return<\/span> d;\r\n}\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> shadow(true<\/span>) <<<\/span> std::<\/span>endl; \r\n std::<\/span>cout <<<\/span> shadow(false<\/span>) <<<\/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
What will be the output of the program? Confused by the d’s? Here is the result.<\/p>\n
![\"shadowD\"](\"https:\/\/www.modernescpp.com\/wp-content\/uploads\/2018\/01\/shadowD.png\")
<\/p>\n
This was easy! Right? But the same phenomenon is quite surprising in class hierarchies.<\/p>\n
\n\/\/ shadowClass.cpp<\/span>\r\n\r\n#include <iostream><\/span>\r\n#include <string><\/span>\r\n\r\nstruct<\/span> Base{\r\n void<\/span> shadow(std::<\/span>string){ \/\/ 2<\/span>\r\n std::<\/span>cout <<<\/span> \"Base::shadow\"<\/span> <<<\/span> std::<\/span>endl; \r\n }\r\n};\r\n\r\nstruct<\/span> Derived:<\/span> Base{\r\n void<\/span> shadow<\/span>(int<\/span>){ \/\/ 3<\/span>\r\n std::<\/span>cout <<<\/span> \"Derived::shadow\"<\/span> <<<\/span> std::<\/span>endl; \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 Derived derived;\r\n \r\n derived.shadow(std::<\/span>string{}); \/\/ 1<\/span>\r\n derived.shadow(int<\/span>{}); \r\n \r\n std::<\/span>cout <<<\/span> std::<\/span>endl;\r\n \r\n}\r\n<\/pre>\n<\/div>\n <\/p>\n
Both structs Base<\/span> and Derived<\/span> have a method shadow<\/span>. The one in the base accepts a std:<\/span>:string (2) and the other one an int<\/span> (3). When I invoke the object derived<\/span> with a default-constructed std::string <\/span>(1), I may assume that the base version will be called. Wrong! Because the method shadow<\/span> is implemented in the class Derived<\/span>, the methods of the base class will not be considered during name resolution. Here is the output of my Gcc.<\/p>\n![\"shadowClass\"](\"https:\/\/www.modernescpp.com\/wp-content\/uploads\/2018\/01\/shadowClass.png\")
<\/p>\n
To fix this issue, shadow<\/span> must be known to Derived<\/span>. <\/p>\n\nstruct<\/span> Derived:<\/span> Base{\r\n using<\/span> Base::<\/span>shadow; \/\/ 1<\/span>\r\n void<\/span> shadow<\/span>(int<\/span>){\r\n std::<\/span>cout <<<\/span> \"Derived::shadow\"<\/span> <<<\/span> std::<\/span>endl; \r\n }\r\n};\r\n<\/pre>\n<\/div>\n <\/p>\n
You have to put a Base::shadow<\/span> (1) into Derived.<\/span> Now the program behaves as expected.<\/p>\n![\"shadowClassFixed\"](\"https:\/\/www.modernescpp.com\/wp-content\/uploads\/2018\/01\/shadowClassFixed.png\")
<\/p>\n
ES.20: Always initialize an object<\/a><\/h3>\nThe rules on which object will be initialized or not are pretty tricky to get right in C++. Here is a simple example.<\/p>\n
\nstruct<\/span> T1 {};\r\nclass<\/span> T2<\/span>{\r\n public:<\/span>\r\n T2() {} \r\n};\r\n\r\nint<\/span> n; \/\/ OK<\/span>\r\n\r\nint<\/span> main<\/span>(){\r\n int<\/span> n2; \/\/ ERROR<\/span>\r\n std::<\/span>string s; \/\/ OK<\/span>\r\n T1 t1; \/\/ OK<\/span>\r\n T2 t2; \/\/ OK <\/span>\r\n}\r\n<\/pre>\n<\/div>\n <\/p>\n
n is a global variable, which will be initialized to 0. This will not hold for n2 because it is a local variable and will not be initialized. But they will be initialized if you use a user-defined type such as std::string, T1, or T2 in a local scope.<\/p>\n
If that is too difficult for you, I have a simple fix. Use auto.<\/span> Now, you can not forget to initialize the variable. The compiler will check this.<\/p>\n\nstruct<\/span> T1 {};\r\nclass<\/span> T2<\/span>{\r\n public:<\/span>\r\n T2() {}\r\n};\r\n\r\nauto<\/span> n =<\/span> 0<\/span>;\r\n\r\nint<\/span> main<\/span>(){\r\n auto<\/span> n2 =<\/span> 0<\/span>;\r\n auto<\/span> s =<\/span> \"\"<\/span>s; \r\n auto<\/span> t1 =<\/span> T1(); \r\n auto<\/span> t2 =<\/span> T2();\r\n}\r\n<\/pre>\n<\/div>\n <\/p>\n
ES.21: Don\u2019t introduce a variable (or constant) before you need to use it<\/a><\/h3>\nI think this is trivial. We program C++, not C.<\/p>\n
ES.22: Don\u2019t declare a variable until you have a value to initialize it with<\/a><\/h3>\nYou may have a so-called used-before-set error if you don’t follow this rule. Have a look at the guidelines.<\/p>\n
<\/p>\n
\nint var; \r\n\r\nif<\/span> (cond) \/\/ some non-trivial condition<\/span>\r\n Set(&<\/span>var);\r\nelse<\/span>