{"id":5657,"date":"2019-03-28T06:17:25","date_gmt":"2019-03-28T06:17:25","guid":{"rendered":"https:\/\/www.modernescpp.com\/index.php\/c-insights-template-instantiation\/"},"modified":"2019-03-28T06:17:25","modified_gmt":"2019-03-28T06:17:25","slug":"c-insights-template-instantiation","status":"publish","type":"post","link":"https:\/\/www.modernescpp.com\/index.php\/c-insights-template-instantiation\/","title":{"rendered":"C++ Insights – Template Instantiation"},"content":{"rendered":"

Today’s post from Andreas is about template instantiation. C++ Insights helps you a lot to get a deeper insight into this automatic process.<\/p>\n

<\/p>\n

 <\/p>\n

\"03<\/p>\n

 <\/p>\n

 <\/p>\n

The future of C++ speaks templates. It is, therefore, a good idea to get a better view of templates.<\/p>\n

Template Instantiation<\/h2>\n

I\u2019d like to start with a disclaimer at this point. There are other tools to do this job. I saw a preview of Visual Studio which can show you the instantiated template. The same applies to cevelop. It\u2019s not an unique feature that C++ Insights provides here. Except for one difference: it shows you the transformations for all the code you type in at once. Everything! Not just templates.<\/p>\n

What I\u2019m talking about is a situation I believe many of us had at least once. There is this function template, a bigger one. We\u2019d like to know for which types it gets instantiated and from where. An easy thing for C++ Insights, the compiler must know this and so does C++ Insights.<\/p>\n

Being able to show the code, which effectively runs, is valuable while teaching. I experienced that it helped students a lot if they could see what is going on rather than have to believe me.<\/p>\n<\/p>\n

The Laziness of Template Instantiation<\/h3>\n

One nice thing C++ Insights shows you is what it doesn\u2019t show. The compiler, at least Clang in which C++ Insights runs, is eager to give us the most efficient code. When it comes to templates, the compiler generates code only for functions or methods which are actually used. You can have a class template with a certain method which is never called. Like here:<\/p>\n

template<\/span><typename<\/span> T>\r\nclass<\/span> Apple\r\n{\r\npublic<\/span>:\r\n  Apple() = default<\/span>;\r\n  \r\n  bool<\/span> IsGreen<\/span>()<\/span> const<\/span> <\/span>{ return<\/span> false<\/span>; }\r\n  bool<\/span> IsRed<\/span>()<\/span> const<\/span> <\/span>{ return<\/span> true<\/span>; }\r\n};\r\n\r\nint<\/span> main<\/span>()<\/span>\r\n<\/span>{\r\n  Apple<int<\/span>> apple;\r\n  \r\n  if<\/span>( apple.IsRed()) {}\r\n}\r\n<\/code><\/pre>\n
In this case, the compiler doesn\u2019t generate the method body of that instantiation (Apple<int>) as you can see in C++ Insights<\/a>:<\/p>\n
template<\/span><typename<\/span> T>\r\nclass<\/span> Apple\r\n{\r\npublic<\/span>:\r\n  Apple() = default<\/span>;\r\n  \r\n  bool<\/span> IsGreen<\/span>()<\/span> const<\/span> <\/span>{ return<\/span> false<\/span>; }\r\n  bool<\/span> IsRed<\/span>()<\/span> const<\/span> <\/span>{ return<\/span> true<\/span>; }\r\n};\r\n\r\n\/* First instantiated from: insights.cpp:13 *\/<\/span>\r\n#ifdef<\/span> INSIGHTS_USE_TEMPLATE<\/span>\r\ntemplate<\/span><>\r\nclass<\/span> Apple<int<\/span>>\r\n{  \r\n  public<\/span>: \r\n  \/\/ inline constexpr Apple() noexcept = default;<\/span>\r\n  inline<\/span> bool<\/span> IsGreen<\/span>()<\/span> const<\/span><\/span>;\r\n  \r\n  inline<\/span> bool<\/span> IsRed<\/span>()<\/span> const<\/span><\/span>;\r\n  \r\n  \/\/ inline constexpr Apple(const Apple<int> &) = default;<\/span>\r\n  \/\/ inline constexpr Apple(Apple<int> &&) = default;<\/span>\r\n};\r\n\r\n#endif<\/span><\/span>\r\n\r\n\r\nint<\/span> main<\/span>()<\/span>\r\n<\/span>{\r\n  Apple<int<\/span>> apple = Apple<int<\/span>>();\r\n}\r\n<\/code><\/pre>\n
template<\/span><typename<\/span> T>\r\nclass<\/span> Apple\r\n{\r\npublic<\/span>:\r\n  Apple() = default<\/span>;\r\n  \r\n  bool<\/span> IsGreen<\/span>()<\/span> const<\/span> <\/span>{ return<\/span> false<\/span>; }\r\n  bool<\/span> IsRed<\/span>()<\/span> const<\/span> <\/span>{ return<\/span> true<\/span>; }\r\n};\r\n\r\n\/* First instantiated from: insights.cpp:13 *\/<\/span>\r\n#ifdef<\/span> INSIGHTS_USE_TEMPLATE<\/span>\r\ntemplate<\/span><>\r\nclass<\/span> Apple<int<\/span>>\r\n{  \r\n  public<\/span>: \r\n  \/\/ inline constexpr Apple() noexcept = default;<\/span>\r\n  inline<\/span> bool<\/span> IsGreen<\/span>()<\/span> const<\/span><\/span>;\r\n  \r\n  inline<\/span> bool<\/span> IsRed<\/span>()<\/span> const<\/span><\/span>;\r\n  \r\n  \/\/ inline constexpr Apple(const Apple<int> &) = default;<\/span>\r\n  \/\/ inline constexpr Apple(Apple<int> &&) = default;<\/span>\r\n};\r\n\r\n#endif<\/span><\/span>\r\n\r\n\r\n\/* First instantiated from: insights.cpp:14 *\/<\/span>\r\n#ifdef<\/span> INSIGHTS_USE_TEMPLATE<\/span>\r\ntemplate<\/span><>\r\nclass<\/span> Apple<char<\/span>>\r\n{  \r\n  public<\/span>: \r\n  \/\/ inline constexpr Apple() noexcept = default;<\/span>\r\n  inline<\/span> bool<\/span> IsGreen<\/span>()<\/span> const<\/span>\r\n  <\/span>{\r\n    return<\/span> false<\/span>;\r\n  }\r\n  \r\n  inline<\/span> bool<\/span> IsRed<\/span>()<\/span> const<\/span><\/span>;\r\n  \r\n  \/\/ inline constexpr Apple(const Apple<char> &) = default;<\/span>\r\n  \/\/ inline constexpr Apple(Apple<char> &&) = default;<\/span>\r\n};\r\n\r\n#endif<\/span><\/span>\r\n\r\n\r\nint<\/span> main<\/span>()<\/span>\r\n<\/span>{\r\n  Apple<int<\/span>> apple = Apple<int<\/span>>();\r\n  Apple<char<\/span>> cApple = Apple<char<\/span>>();\r\n  cApple.IsGreen();\r\n}\r\n<\/code><\/pre>\n
This is brilliant because the compiler helps us to generate small binaries. Another view is that it can help to debug, for example, which constructor is used.<\/p>\n
What we can also see with C++ Insights is which line in the original code caused the instantiation. This can be helpful if you do not expect a certain instantiation.<\/p>\n
Class Template Argument Deduction<\/h3>\n
When using C++17 and CTAD (class template argument deduction) it can sometimes be less obvious what types you got. Assume this code (I know there it is probably easy to see):<\/p>\n
#include<\/span> <vector><\/span><\/span>\r\n\r\nint<\/span> main<\/span>()<\/span>\r\n<\/span>{\r\n  std<\/span>::vector<\/span> v{1<\/span>,2<\/span>,3<\/span>};\r\n  std<\/span>::vector<\/span> vd{1.0<\/span>,2.0<\/span>,3.0<\/span>};\r\n\r\n  \/\/v = vd; \/\/ does not compile<\/span>\r\n}\r\n<\/code><\/pre>\n
#include<\/span> <vector><\/span><\/span>\r\n\r\nint<\/span> main<\/span>()<\/span>\r\n<\/span>{\r\n  std<\/span>::vector<\/span><int<\/span>, std<\/span>::allocator<int<\/span>> > v = std<\/span>::vector<\/span><int<\/span>, std<\/span>::allocator<int<\/span>> >{std<\/span>::initializer_list<int<\/span>>{1<\/span>, 2<\/span>, 3<\/span>}, std<\/span>::allocator<int<\/span>>()};\r\n  std<\/span>::vector<\/span><double<\/span>, std<\/span>::allocator<double<\/span>> > vd = std<\/span>::vector<\/span><double<\/span>, std<\/span>::allocator<double<\/span>> >{std<\/span>::initializer_list<double<\/span>>{1.0<\/span>, 2.0<\/span>, 3.0<\/span>}, std<\/span>::allocator<double<\/span>>()};\r\n}\r\n<\/code><\/pre>\n
There you can see what type vector really has.<\/p>\n
constexpr if<\/span><\/h3>\n
While we are talking about C++17, there is another new feature: constexpr if<\/code>. Let\u2019s have a look at what C++<\/ins> Insights can do there for us. In the example below we have a stringify <\/code>template which makes a std::string<\/code> from the parameter passed to the function<\/a>:<\/p>\n
#include<\/span> <string><\/span><\/span>\r\n#include<\/span> <type_traits><\/span><\/span>\r\n\r\ntemplate<\/span> <typename<\/span> T>\r\nstd<\/span>::string<\/span> stringify<\/span>(T&& t)<\/span>\r\n<\/span>{\r\n  if<\/span> constexpr<\/span>(std<\/span>::is_same_v<T, std<\/span>::string<\/span>>)<\/span> <\/span>{\r\n    return<\/span> t;\r\n  } else<\/span> {\r\n    return<\/span> std<\/span>::to_string(t);\r\n  }\r\n}\r\n\r\nint<\/span> main<\/span>()<\/span>\r\n<\/span>{\r\n  auto<\/span> x = stringify(2<\/span>);\r\n  auto<\/span> y = stringify(std<\/span>::string<\/span>{\"Hello\"<\/span>});\r\n}\r\n<\/code><\/pre>\n
Of course, if we pass in a std::string<\/code> it just returns this string. The constexpr if<\/code> helps us to make this entire function template possible. Because there is no to_string<\/code> function which takes a std::string<\/code>. With a normal, if <\/code>this code would not compile.<\/p>\n
Now, what happens, if we pass in a c-string? Like here:<\/p>\n
#include<\/span> <string><\/span><\/span>\r\n#include<\/span> <type_traits><\/span><\/span>\r\n\r\ntemplate<\/span> <typename<\/span> T>\r\nstd<\/span>::string<\/span> stringify<\/span>(T&& t)<\/span>\r\n<\/span>{\r\n  if<\/span> constexpr<\/span>(std<\/span>::is_same_v<T, std<\/span>::string<\/span>>)<\/span> <\/span>{\r\n    return<\/span> t;\r\n  } else<\/span> {\r\n    return<\/span> std<\/span>::to_string(t);\r\n  }\r\n}\r\n\r\nint<\/span> main<\/span>()<\/span>\r\n<\/span>{\r\n  auto<\/span> x = stringify(2<\/span>);\r\n  auto<\/span> y = stringify(\"hello\"<\/span>);\r\n}\r\n<\/code><\/pre>\n
#include<\/span> <string><\/span><\/span>\r\n#include<\/span> <type_traits><\/span><\/span>\r\n\r\ntemplate<\/span> <typename<\/span> T>\r\nstd<\/span>::string<\/span> stringify<\/span>(T&& t)<\/span>\r\n<\/span>{\r\n  if<\/span> constexpr<\/span>(std<\/span>::is_same_v<T, std<\/span>::string<\/span>>)<\/span> <\/span>{\r\n    return<\/span> t;\r\n  } else<\/span> if<\/span> constexpr<\/span>(std<\/span>::is_array_v< std<\/span>::remove_reference_t<T> >)<\/span> <\/span>{\r\n    return<\/span> std<\/span>::string<\/span>{t};\r\n  } else<\/span> {\r\n    return<\/span> std<\/span>::to_string(t);\r\n  }\r\n}\r\n\r\nint<\/span> main<\/span>()<\/span>\r\n<\/span>{\r\n  auto<\/span> x = stringify(2<\/span>);\r\n  auto<\/span> y = stringify(\"hello\"<\/span>);\r\n}\r\n<\/code><\/pre>\n
Now it compiles. What C++ Insights shows you are the template instantiations for the two types. But there is more. It also shows which if<\/code>-branch is used in that instantiation. If you look closely you can spot something else. C++ Insights shows you also that there is no else if<\/code> in C++. There is just an if<\/code> and a else<\/code>. Why is this important? Because we need to apply the constexpr<\/code> to all if<\/code>-branches. Otherwise, we end up with a run-time if in a constexpr if<\/code> else-branch.<\/p>\n
I\u2019d like to thank Rainer for the opportunity to share information about C++ Insights on his popular blog!<\/p>\n
Stay tuned for more insights about C++ Insights. The next post is about Variadic Templates.<\/p>\n
Andreas<\/strong><\/p>\n
 <\/p>\n
 <\/p>\n
 <\/p>\n
 <\/p>\n","protected":false},"excerpt":{"rendered":"
Today’s post from Andreas is about template instantiation. C++ Insights helps you a lot to get a deeper insight into this automatic process.<\/p>\n","protected":false},"author":21,"featured_media":5656,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[374],"tags":[],"class_list":["post-5657","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-cppinsight"],"_links":{"self":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/5657","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=5657"}],"version-history":[{"count":0,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/5657\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/media\/5656"}],"wp:attachment":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/media?parent=5657"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/categories?post=5657"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/tags?post=5657"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}
Have fun with C++ Insights. You can support the project by becoming a Patreon<\/a> or
of course with code contributions<\/a>.<\/p>\n
It will not compile. The reason is, there is also no to_string<\/code> for a char-array. We can fix this by providing an additional if<\/code> for this case<\/a>:<\/p>\n
We have two std::vectors which each gets three numbers assigned. Despite the fact that these two vectors really look equal we cannot assign vd to v. It might be obvious here, v is of type int while vd is of type double. A fairly easy thing for C++ Insights<\/a>:<\/p>\n
Even if the method is used with a different instantiation (Apple<char><\/code>), there will be no code for the int variant. Of course, the method is present for Apple<char><\/code>. See for yourself in C++ Insights<\/a>:<\/p>\n