{"id":5652,"date":"2019-03-13T20:17:42","date_gmt":"2019-03-13T20:17:42","guid":{"rendered":"https:\/\/www.modernescpp.com\/index.php\/c-insights-conversions\/"},"modified":"2023-06-26T10:13:42","modified_gmt":"2023-06-26T10:13:42","slug":"c-insights-conversions","status":"publish","type":"post","link":"https:\/\/www.modernescpp.com\/index.php\/c-insights-conversions\/","title":{"rendered":"C++ Insights – Implicit Conversions"},"content":{"rendered":"

I’m totally happy to announce that this post starts a series of posts to C++ Insights<\/a>. C++ Insights is an awesome tool that I use heavily in my posts and in my classes to show the magic of the C++ compiler.<\/p>\n

<\/p>\n

 <\/p>\n

\"01<\/p>\n

This series is motivated by a brief conversation I had with Andreas<\/a>. I asked him if he has some use case examples which show how C++ Insights<\/a> can be helpful when teaching. I think there are many things. This article is the start of a series of five posts by Andreas which I will publish at Modernes C++ because I think C++ Insights is an invaluable tool to get a deeper insight into the C++ compiler magic. In case, you are new to C++ Insights consider this introductory article<\/a>. Without further ado, Andreas post. When you follow the link near to each example, you can directly analyse the example in C++ Insight.<\/p>\n

Implicit Conversions<\/h2>\n

Let\u2019s start with something simple which happens so often: implicit conversations. Sometimes, they are perceived as cumbersome or hidden, sometimes as powerful. For beginners and even for experts in certain debugging situations it is hard to see where implicit conversations happen.<\/p>\n

A Basic Example<\/h3>\n

Consider this basic example<\/a>:<\/p>\n

void<\/span> UnsignedIntFunction<\/span>(unsigned<\/span> int<\/span>)<\/span> <\/span>{}\r\n\r\nint<\/span> main<\/span>()<\/span>\r\n<\/span>{\r\n    int<\/span> x = 1<\/span>;\r\n    UnsignedIntFunction(x);\r\n}\r\n<\/code><\/pre>\n
With these few lines and knowledge of C++, it is easy to see that UnsignedIntFunction<\/code> takes a unsigned int<\/code> while we are passing an int<\/code>. Aside from the fact that the two types have different ranges on the call side, it works without additional work. This truncation is harder to spot in a bigger codebase. For students, it is even harder in my experience. Using C++ Insights gives you the following output:<\/p>\n
void<\/span> UnsignedIntFunction<\/span>(unsigned<\/span> int<\/span>)<\/span>\r\n<\/span>{\r\n}\r\n\r\n\r\nint<\/span> main<\/span>()<\/span>\r\n<\/span>{\r\n  int<\/span> x = 1<\/span>;\r\n  UnsignedIntFunction(static_cast<\/span><unsigned<\/span> int<\/span>>(x));\r\n}\r\n<\/code><\/pre>\n
You can now show that and where the implicit conversion kicks in. The great benefit of C++ Insights as an online tool is that you can change the signature of UnsignedIntFunction<\/code> to int<\/code> and see the implicit conversion disappear. This is powerful as your students do not just have to believe you, they can see it and experiment with it themselves. I frequently tell my students not to trust me and challenge what I\u2019m telling them. With C++ Insights they easily can. Sadly for me, they sometimes find my mistakes, but that is a different story.<\/p>\n<\/p>\n
Classes<\/h3>\n
Let\u2019s move on to something more complex like classes with conversion operators things get more tricky to spot. At this point, we added operator overloading to the picture. The question is, which overload gets selected when? There was a recent tweet by @walletfox<\/a> illustrating how C++ Insights can help to show which overload  std::cout<\/code> gets selected. Consider this, cout<\/code>-free example<\/a>:<\/p>\n
class<\/span> Foo\r\n{\r\npublic<\/span>:\r\n    Foo(int<\/span> v)\r\n    : mV{v}\r\n    {\r\n    }\r\n\r\n    Foo& operator<\/span>+=(const<\/span> Foo& rhs)\r\n    {\r\n        mV += rhs.mV;\r\n        return<\/span> *this<\/span>;\r\n    }\r\n\r\n    operator<\/span> int<\/span>()<\/span> <\/span>{ return<\/span> mV; }\r\n\r\nprivate<\/span>:\r\n    int<\/span> mV;\r\n};\r\n\r\nint<\/span> main<\/span>()<\/span>\r\n<\/span>{\r\n    Foo t<\/span>(2<\/span>)<\/span><\/span>;\r\n    t = 3<\/span> * 2<\/span>;\r\n\r\n    Foo tt<\/span>(4<\/span>)<\/span><\/span>;\r\n    t += tt * 2<\/span>;\r\n}\r\n<\/code><\/pre>\n
The question is, do you directly spot what happens for t = 3 * 2<\/code> and t += tt * 2<\/code>? Running C++ Insights on it gives the following output:<\/p>\n
class Foo\r\n{\r\npublic:\r\n    inline Foo(int v)\r\n    : mV{v}\r\n    {\r\n    }\r\n    \r\n    \r\n\r\n    inline Foo & operator+=(const Foo & rhs)\r\n    {\r\n      this->mV += rhs.mV;\r\n      return *this;\r\n    }\r\n    \r\n\r\n    using retType = int;\r\n    inline operator retType ()\r\n    {\r\n      return this->mV;\r\n    }\r\n    \r\n\r\nprivate:\r\n    int mV;\r\n\/* public: inline constexpr Foo(const Foo &); *\/\r\n\/* public: inline constexpr Foo(Foo &&); *\/\r\n\/* public: inline Foo & operator=(const Foo &); *\/\r\n\/* public: inline Foo & operator=(Foo &&) noexcept; *\/\r\n\/* public: inline ~Foo() noexcept; *\/\r\n};\r\n\r\nint main()\r\n{\r\n  Foo t = Foo(2);\r\n  t.operator=(Foo(3 * 2));\r\n  Foo tt = Foo(4);\r\n  t.operator+=(Foo(static_cast<int>(tt.operator int()) * 2));\r\n}\r\n<\/code><\/pre>\n
Aside from the question, you can see implicit member functions the compiler adds like copy and move operations as well as the destructor. You also see the answer to the original question; there are implicit conversions. Both times a temporary object of Foo<\/code> is created which then gets passed to operator=(const Foo&)<\/code> and operator+=(const Foo)<\/code>. We did not implement the first one. In addition to all this, the conversion operator operator int()<\/code> is also used to first convert a Foo<\/code> object to an int<\/code> just multiply it by 2 and then pass the result in a temporary Foo<\/code> object.<\/p>\n
Special Member Functions<\/h4>\n
Another thing C++ Insights shows us, you have already seen it, are the special member functions the compiler generates for us. In the example above, we can see the copy and move constructor as well as the copy and move assignment operators. Here is an example demonstrating it even better<\/a>:<\/p>\n
class<\/span> A\r\n{\r\npublic<\/span>:\r\n  A() = default<\/span>;\r\n  A(const<\/span> A&) {}\r\n};\r\n\r\nclass<\/span> B\r\n{\r\npublic<\/span>:\r\n};\r\n\r\nint<\/span> main<\/span>()<\/span>\r\n<\/span>{\r\n  A a;\r\n  A a2;\r\n  \/\/a = a2;<\/span>\r\n  \r\n  B b;\r\n}\r\n<\/code><\/pre>\n
In class A<\/code> we do provide a copy constructor. With that, the compiler does no longer generate the move operations for this class as it does for B<\/code>:<\/p>\n
class<\/span> A\r\n{\r\npublic<\/span>:\r\n  A() = default<\/span>;\r\n  inline<\/span> A<\/span>(const<\/span> A &)<\/span>\r\n  <\/span>{\r\n  }\r\n  \r\n  \r\n\/\/ public: inline constexpr A() noexcept;<\/span>\r\n};\r\n\r\nclass<\/span> B\r\n{\r\npublic<\/span>:\r\n\/\/ public: inline constexpr B() noexcept;<\/span>\r\n\/\/ public: inline constexpr B(const B &);<\/span>\r\n\/\/ public: inline constexpr B(B &&);<\/span>\r\n};\r\n\r\nint<\/span> main<\/span>()<\/span>\r\n<\/span>{\r\n  A a = A();\r\n  A a2 = A();\r\n  B b = B();\r\n}\r\n<\/code><\/pre>\n
What you can see in addition is, that the special members are only generated if needed. In the code as it is, there is no assignment operator. However, if we enable the line a = a2<\/code> we get one:<\/p>\n
class<\/span> A\r\n{\r\npublic<\/span>:\r\n  A() = default<\/span>;\r\n  inline<\/span> A<\/span>(const<\/span> A &)<\/span>\r\n  <\/span>{\r\n  }\r\n  \r\n  \r\n\/\/ public: inline constexpr A() noexcept;<\/span>\r\n\/\/ public: inline constexpr A & operator=(const A &) noexcept;<\/span>\r\n};\r\n\r\nclass<\/span> B\r\n{\r\npublic<\/span>:\r\n\/\/ public: inline constexpr B() noexcept;<\/span>\r\n\/\/ public: inline constexpr B(const B &);<\/span>\r\n\/\/ public: inline constexpr B(B &&);<\/span>\r\n};\r\n\r\nint<\/span> main<\/span>()<\/span>\r\n<\/span>{\r\n  A a = A();\r\n  A a2 = A();\r\n  a.operator<\/span>=(a2);\r\n  B b = B();\r\n}\r\n<\/code><\/pre>\n
I\u2019d like to thank Rainer for the opportunity to share information about C++ Insights on his popular blog!<\/p>\n
Have fun with C++ Insights. You can support the project by becoming a Patreon<\/a> or of course with code contributions<\/a>.<\/p>\n
Stay tuned for more insights about C++ Insights to type deduction \u2026<\/p>\n
Andreas<\/strong><\/p>\n
 <\/p>\n
 <\/p>\n
 <\/p><\/p>\n","protected":false},"excerpt":{"rendered":"
I’m totally happy to announce that this post starts a series of posts to C++ Insights. C++ Insights is an awesome tool that I use heavily in my posts and in my classes to show the magic of the C++ compiler.<\/p>\n","protected":false},"author":21,"featured_media":5651,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[374],"tags":[474],"class_list":["post-5652","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-cppinsight","tag-conversions"],"_links":{"self":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/5652","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=5652"}],"version-history":[{"count":1,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/5652\/revisions"}],"predecessor-version":[{"id":6794,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/5652\/revisions\/6794"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/media\/5651"}],"wp:attachment":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/media?parent=5652"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/categories?post=5652"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/tags?post=5652"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}
I think that the power of C++ Insights is that you can see how a code change on your side affects what the compiler adds or selects. It\u2019s more or less like the brilliant compiler explorer <\/a>except for it spits the result out in a language we all understand well.<\/p>\n