{"id":4972,"date":"2016-10-06T20:07:00","date_gmt":"2016-10-06T20:07:00","guid":{"rendered":"https:\/\/www.modernescpp.com\/index.php\/automatically-inititialized\/"},"modified":"2023-06-26T12:40:17","modified_gmt":"2023-06-26T12:40:17","slug":"automatically-inititialized","status":"publish","type":"post","link":"https:\/\/www.modernescpp.com\/index.php\/automatically-inititialized\/","title":{"rendered":"auto-matically inititialized"},"content":{"rendered":"

Probably the most frequently used feature of C++11 is auto<\/span>. Thanks to auto, the compiler determines the type of a variable from its initializer. But what is the point of safety-critical software? <\/p>\n

<\/p>\n

 <\/p>\n

The facts about auto<\/span><\/h2>\n

Automatic type deduction with auto is exceptionally convenient. First, you save a lot of unnecessary typing, particularly with challenging template expressions; second, the compiler is never wrong – in opposition to the programmer. <\/p>\n

I compare, in the following listing, the explicit and the deduced types.<\/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<\/pre>\n<\/td>\n
\n
#include <vector><\/span>\r\n\r\nint<\/span> myAdd(int<\/span> a,int<\/span> b){ return<\/span> a+b; }\r\n\r\nint<\/span> main(){\r\n\r\n  \/\/ define an int-value<\/span>\r\n  int<\/span> i= 5;                                  \/\/ explicit<\/span>\r\n  auto<\/span> i1= 5;                                \/\/ auto<\/span>\r\n \r\n  \/\/ define a reference to an int<\/span>\r\n  int<\/span>& b= i;                                 \/\/ explicit<\/span>\r\n  auto<\/span>& b1= i;                               \/\/ auto<\/span>\r\n \r\n  \/\/ define a pointer to a function<\/span>\r\n  int<\/span> (*add)(int<\/span>,int<\/span>)= myAdd;               \/\/ explicit<\/span>\r\n  auto<\/span> add1= myAdd;                         \/\/ auto<\/span>\r\n  \r\n  \/\/ iterate through a vector<\/span>\r\n  std::vector<int<\/span>> vec;\r\n  for<\/span> (std::vector<int<\/span>>::iterator it= vec.begin(); it != vec.end(); ++it){} \r\n  for<\/span> (auto<\/span> it1= vec.begin(); it1 != vec.end(); ++it1) {}\r\n\r\n}\r\n<\/pre>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n
 <\/p>\n
The compiler uses the rules for template argument deduction <\/a>to get the variable type. Therefore, the outer const <\/span>or volatile<\/span> qualifier and references are removed. The following example shows this behavior for constant and references. <\/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<\/pre>\n<\/td>\n
\n
int<\/span> main(){\r\n  \r\n  int<\/span> i= 2011;\r\n  const<\/span> int<\/span> i2= 2014;\r\n  const<\/span> int<\/span>& i3= i2;\r\n  \r\n  auto<\/span> a2= i2;     \/\/ int<\/span>\r\n  auto<\/span> a3= i3;     \/\/ int<\/span>\r\n  \r\n}\r\n<\/pre>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n
 <\/p>\n
But how can I be sure that a2<\/span> or a<\/span>3 is of type int<\/span>, although I used a variable of type const int<\/span> or const int&<\/span> to initialize them? Sometimes I deduce it wrong. The answer is simple. The compiler knows the truth. The only declared class template GetType helps me a lot. <\/p>\n
<\/p>\n
\n
template<\/span> <typename<\/span> T>\r\nclass<\/span> GetType<\/span>; \r\n<\/pre>\n<\/div>\n
 <\/p>\n
The compiler will immediately complain if I use only the declared class template. The definition is missing. That is the characteristic I need. The compiler tells me exactly the type of class template, which can not be instantiated. At first, to the extended source code. I disabled the following source code the try to instantiate the only declared class template.<\/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<\/pre>\n<\/td>\n
\n
#include <get_type.hpp><\/span>\r\n\r\nint<\/span> main(){\r\n  \r\n  int<\/span> i= 2011;\r\n  const<\/span> int<\/span> i2= 2014;\r\n  \/\/ GetType<decltype(i2)> myType;<\/span>\r\n  const<\/span> int<\/span>& i3= i2;\r\n  \/\/ GetType<decltype(i3)> myType;<\/span>\r\n  \r\n  auto<\/span> a2= i2; \r\n  \/\/ GetType<decltype(a2)> myType;<\/span>\r\n  auto<\/span> a3= i3;\r\n  \/\/ GetType<decltype(a3)> myType;<\/span>\r\n  \r\n}\r\n<\/pre>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n
 <\/p>\n
The GetType call in lines 7,9, 12, and 14 uses the specifier decltype,<\/span> which gives you the exact type of the declared variable. The rest is only hard work. I successively commented on each GetType<\/span> expression. A deep look into the error messages of the g++ compilers is very interesting.<\/p>\n
 <\/p>\n
 \"autoGetType\"<\/p>\n
 <\/p>\n
The critical expressions of the error message have a red line. Impressed? But once more. What is the point of safety-critical software?<\/p>\n<\/p>\n
Initialize me!<\/h2>\n
auto<\/span> determines its type from an initializer. That means. Without an initializer, there is no type and, therefore, no variable. To say it positively. The compiler takes care that each type is initialized. That is a nice side effect of auto<\/span> that is mentioned too rarely. <\/p>\n
Whether you forgot to initialize a variable or didn’t make it because of a wrong understanding of the language makes no difference. The result is simply the same: undefined behavior. With auto<\/span> you can overcome these nasty errors. Be honest. Do you know all rules for the initialization of a variable? If yes, congratulations. If not, read the article’s default initialization<\/a> and all referenced articles in this article. I have no clue why they used the following statement: “objects with automatic storage duration (and their subobjects) are initialized to indeterminate values”. This formulation causes more harm than good. Local variables will not be default initialized.<\/p>\n
I modified the second program of default initialization <\/a>to make the undefined behavior more obvious.<\/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<\/pre>\n<\/td>\n
\n
\/\/ init.cpp<\/span>\r\n\r\n#include <iostream><\/span>\r\n#include <string><\/span>\r\n \r\nstruct<\/span> T1 {};\r\n \r\nstruct<\/span> T2{\r\n    int<\/span> mem;     \/\/ Not ok: indeterminate value<\/span>\r\n public:\r\n    T2() {} \r\n};\r\n \r\nint<\/span> n;          \/\/  ok: initialized to 0<\/span>\r\n \r\nint<\/span> main(){\r\n  \r\n  std::cout << std::endl;\r\n  \r\n  int<\/span> n;               \/\/ Not ok: indeterminate value<\/span>\r\n  std::string s;       \/\/ ok: Invocation of the default constructor; initialized to \"\" <\/span>\r\n  T1 t1;               \/\/ ok: Invocation of the default constructor <\/span>\r\n  T2 t2;               \/\/ ok: Invocation of the default constructor<\/span>\r\n    \r\n  std::cout << \"::n \"<\/span> << ::n << std::endl;\r\n  std::cout << \"n: \"<\/span> << n << std::endl;\r\n  std::cout << \"s: \"<\/span> << s << std::endl;\r\n  std::cout << \"T2().mem: \"<\/span> << T2().mem << 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
At first, to the scope resolutions operator::<\/span> in line 25. :<\/span>: addresses the global scope. In our case, the variable n in line 14. Curiously enough, the automatic variable n<\/span> in line 25 has the value 0. n<\/span> has an undefined value, and therefore the program has undefined behavior. That will not hold for the variable mem<\/span> of the class T2<\/span>. mem<\/span> returns an undefined value.<\/p>\n
 \"init\"<\/p>\n
Now, I rewrite the program with the help of auto<\/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<\/pre>\n<\/td>\n
\n
\/\/ initAuto.cpp<\/span>\r\n\r\n#include <iostream><\/span>\r\n#include <string><\/span>\r\n \r\nstruct<\/span> T1 {};\r\n \r\nstruct<\/span> T2{\r\n    int<\/span> mem= 0;  \/\/ auto mem= 0 is an error<\/span>\r\n public:\r\n    T2() {}\r\n};\r\n \r\nauto<\/span> n= 0;\r\n \r\nint<\/span> main(){\r\n  \r\n  std::cout << std::endl;\r\n  \r\n  using<\/span> namespace<\/span> std::string_literals;\r\n  \r\n  auto<\/span> n= 0;\r\n  auto<\/span> s=\"\"<\/span>s;      \r\n  auto<\/span> t1= T1();               \r\n  auto<\/span> t2= T2();\r\n    \r\n  std::cout << \"::n \"<\/span> << ::n << std::endl;\r\n  std::cout << \"n: \"<\/span> << n << std::endl;\r\n  std::cout << \"s: \"<\/span> << s << std::endl;\r\n  std::cout << \"T2().mem: \"<\/span> << T2().mem << 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
Two lines in the source code are especially interesting. First, line 9. The current standard forbids it to initialize non-constant members of a class with auto. Therefore, I have to use the explicit type. This is, from my perspective, contra-intuitive. Here is a discussion of the C++ standardization committee about this issue: article 3897.pdf.<\/a> Second, line 23. C++14 gets C++ string literals. You build them by using a C string literal (“”<\/span>) and adding the suffix s (“”s<\/span>). For convenience, I imported the in line 20: using namespace std::string_literals<\/span>. <\/p>\n
The output of the program is not so thrilling, only for completeness. T2().mem<\/span> has the value 0. <\/p>\n
 \"initAuto\"<\/p>\n
Refactorization<\/h2>\n
Just now, I want to conclude the post a new use case of auto<\/span> comes to my mind. auto<\/span> very well supports the refactorization of your code. First, it’s very easy to restructure your code if there is no type of information. Second, the compiler automatically takes care of the right types. What does that mean? I answer in the form of a code snippet. At first, the code was without auto<\/span>.<\/p>\n
<\/p>\n
\n
int<\/span> a= 5;\r\nint<\/span> b= 10;\r\nint<\/span> sum=  a * b * 3;\r\nint<\/span> res= sum + 10; \r\n<\/pre>\n<\/div>\n
 <\/p>\n
When I replace the variable b of type in with a double 10.5, I have to adjust all dependent types. That is laborious and dangerous. I have to use the right types and take care of narrowing and other intelligent phenomenons<\/em> in C++.<\/p>\n
 <\/p>\n
<\/p>\n
\n
int<\/span> a2= 5;\r\ndouble<\/span> b2= 10.5;\r\ndouble<\/span> sum2= a2 * b2 * 3;\r\ndouble<\/span> res2= sum2 * 10.5;\r\n<\/pre>\n<\/div>\n
 <\/p>\n
This danger is not present in the case of auto.<\/span> Everything happens auto<\/span>-matically.<\/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<\/pre>\n<\/td>\n
\n
\/\/ refactAuto.cpp<\/span>\r\n\r\n#include <typeinfo><\/span>\r\n#include <iostream><\/span>\r\n\r\nint<\/span> main(){\r\n  \r\n  std::cout << std::endl;\r\n\r\n  auto<\/span> a= 5;\r\n  auto<\/span> b= 10;\r\n  auto<\/span> sum=  a * b * 3;\r\n  auto<\/span> res= sum + 10; \r\n  std::cout << \"typeid(res).name(): \"<\/span> << typeid<\/span>(res).name() << std::endl;\r\n  \r\n  auto<\/span> a2= 5;\r\n  auto<\/span> b2= 10.5;\r\n  auto<\/span> sum2= a2 * b2 * 3;\r\n  auto<\/span> res2= sum2 * 10;  \r\n  std::cout << \"typeid(res2).name(): \"<\/span> << typeid<\/span>(res2).name() << std::endl;\r\n  \r\n  auto<\/span> a3= 5;\r\n  auto<\/span> b3= 10;\r\n  auto<\/span> sum3= a3 * b3 * 3.1f;\r\n  auto<\/span> res3= sum3 * 10;  \r\n  std::cout << \"typeid(res3).name(): \"<\/span> << typeid<\/span>(res3).name() << 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
The slight variations of the code snippet always determine the right type of res, res2, or res3. That’s the job of the compiler. The variable b2 in line 17 is of type double<\/span> and therefore also res2;<\/span> the variable sum3<\/span> in line 24 becomes due to the multiplication with the float<\/span> literal 3.1f a float type and the final result res3.<\/span> To get the type from the compiler, I use the typeid<\/span> operator defined in the header typeinfo.<\/span><\/p>\n
Here you get the results in black on yellow.<\/p>\n
 <\/p>\n
 \"autoRefact\"<\/p>\n
Impressed? Me too.<\/p>\n
What’s next?<\/h2>\n
The initialization with curly braces {} has much in common with auto. It is used similarly often, helps to read the code, and makes your code safer. How? You will see it in the next post.<\/a><\/p>\n
 <\/p>\n
 <\/p>\n
 <\/p><\/p>\n","protected":false},"excerpt":{"rendered":"
Probably the most frequently used feature of C++11 is auto. Thanks to auto, the compiler determines the type of a variable from its initializer. But what is the point of safety-critical software? <\/p>\n","protected":false},"author":21,"featured_media":4968,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[364],"tags":[460],"class_list":["post-4972","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-embedded","tag-initialization"],"_links":{"self":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/4972","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/users\/21"}],"replies":[{"embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/comments?post=4972"}],"version-history":[{"count":1,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/4972\/revisions"}],"predecessor-version":[{"id":6939,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/4972\/revisions\/6939"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/media\/4968"}],"wp:attachment":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/media?parent=4972"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/categories?post=4972"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/tags?post=4972"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}