{"id":6239,"date":"2021-10-21T10:58:11","date_gmt":"2021-10-21T10:58:11","guid":{"rendered":"https:\/\/www.modernescpp.com\/index.php\/automatic-return-type-c-11-14-20\/"},"modified":"2023-06-26T09:24:26","modified_gmt":"2023-06-26T09:24:26","slug":"automatic-return-type-c-11-14-20","status":"publish","type":"post","link":"https:\/\/www.modernescpp.com\/index.php\/automatic-return-type-c-11-14-20\/","title":{"rendered":"Automatic Return Type (C++11\/14\/20)"},"content":{"rendered":"

I started my discussion about the  “Automatic Return Type (C++98)<\/a>” in my last post. Today, I’m faced with the same challenge but solve it with C++11, C++14, and C++20.<\/p>\n

<\/p>\n

 \"AutomaticReturnType\"<\/p>\n

To remind you: Here is the challenge I want to solve.<\/p>\n

<\/p>\n

\n
template<\/span> <<\/span>typename<\/span> T, typename<\/span> T2><\/span>\r\n???<\/span> sum(T t, T2 t2) {\r\n    return<\/span> t +<\/span> t2;\r\n}\r\n<\/pre>\n<\/div>\n
 <\/p>\n
When you have a function template <\/code>with at least two type parameters, you can not decide in general the return type of the function. Of course, sum <\/code>should return the type the arithmetic operation t + t2 <\/code>returns.<\/p>\n
<\/p>\n
\n
std::<\/span>cout <<<\/span> typeid<\/span>(5.5<\/span> +<\/span> 5.5<\/span>).name();    \/\/ double<\/span>\r\nstd::<\/span>cout <<<\/span> typeid<\/span>(5.5<\/span> +<\/span> true<\/span>).name();   \/\/ double<\/span>\r\nstd::<\/span>cout <<<\/span> typeid<\/span>(true<\/span> +<\/span> 5.5<\/span>).name();   \/\/ double<\/span>\r\nstd::<\/span>cout <<<\/span> typeid<\/span>(true<\/span> +<\/span> false<\/span>).name(); \/\/ int<\/span>\r\n<\/pre>\n<\/div>\n
 <\/p>\n
When you want to read the full story, read my previous post “Automatic Return Type (C++98)<\/a>“. Now, I jump to C++11.<\/p>\n
C++11<\/h2>\n
In C++11, there are essentially two ways to solve this issue: type-traits or auto<\/code> combination with decltype<\/code>.<\/p>\n
Type-Traits<\/h3>\n
The Type-traits library has the function std::common_type<\/code><\/a>. This function determines at compile time the common type of an arbitrary number of types. The common type is that type among all types to which all types can be implicitly converted. If this type is not available, you get a compile-time error.<\/p>\n
 <\/p>\n
<\/p>\n
\n
\/\/ automaticReturnTypeTypeTraits.cpp<\/span>\r\n\r\n#include <iostream><\/span>\r\n#include <typeinfo><\/span>\r\n#include <type_traits><\/span>\r\n\r\ntemplate<\/span> <<\/span>typename<\/span> T, typename<\/span> T2><\/span>\r\ntypename<\/span> std::<\/span>common_type<<\/span>T, T2>::<\/span>type sum(T t, T2 t2) {\r\n    return<\/span> t +<\/span> t2;\r\n}\r\n\r\n\r\nint<\/span> main() {\r\n\r\n    std::<\/span>cout <<<\/span> '\\n'<\/span>;\r\n\r\n    std::<\/span>cout <<<\/span> typeid<\/span>(sum(5.5<\/span>, 5.5<\/span>)).name() <<<\/span> '\\n'<\/span>;     \/\/ double<\/span>\r\n    std::<\/span>cout <<<\/span> typeid<\/span>(sum(5.5<\/span>, true<\/span>)).name() <<<\/span> '\\n'<\/span>;    \/\/ double<\/span>\r\n    std::<\/span>cout <<<\/span> typeid<\/span>(sum(true<\/span>, 5.5<\/span>)).name() <<<\/span> '\\n'<\/span>;    \/\/ double<\/span>\r\n    std::<\/span>cout <<<\/span> typeid<\/span>(sum(true<\/span>, false<\/span>)).name() <<<\/span> '\\n'<\/span>;  \/\/ bool<\/span>\r\n\r\n    std::<\/span>cout <<<\/span> '\\n'<\/span>;\r\n\r\n}\r\n<\/pre>\n<\/div>\n
 <\/p>\n
For simplicity reasons, I display the string representation of the type in the source code. I used the MSVC compiler. The GCC or Clang compiler would return single characters such as d for double<\/code> and b for bool.<\/p>\n
There is one subtle difference between std::common_type<\/code> and all other variants I presented in the last post and this post: std::common_type<\/code> returns the common type, but my traits solution in the last post, “Automatic Return Type (C++98)<\/a>“, and the solutions based on auto <\/code>in this post returns the type to which the expression t + t2<\/code> evaluates to.<\/p>\n
auto<\/code> in Combination with decltype<\/code><\/h3>\n
Using auto<\/code> to deduce the return type of a function in C++11 is way too verbose.<\/p>\n
First, you have to use the so-called trailing return type, and second, you have to specify the return type in a decltype<\/code> expression.<\/p>\n
 <\/p>\n
<\/p>\n
\n
\/\/ automaticReturnTypeTypeAutoDecltype.cpp<\/span>\r\n\r\n#include <iostream><\/span>\r\n#include <typeinfo><\/span>\r\n#include <type_traits><\/span>\r\n\r\ntemplate<\/span> <<\/span>typename<\/span> T, typename<\/span> T2><\/span>\r\nauto<\/span> sum(T t, T2 t2) -><\/span> decltype(t +<\/span> t2) {\r\n    return<\/span> t +<\/span> t2;\r\n}\r\n\r\n\r\nint<\/span> main() {\r\n\r\n    std::<\/span>cout <<<\/span> '\\n'<\/span>;\r\n\r\n    std::<\/span>cout <<<\/span> typeid<\/span>(sum(5.5<\/span>, 5.5<\/span>)).name() <<<\/span> '\\n'<\/span>;     \/\/ double<\/span>\r\n    std::<\/span>cout <<<\/span> typeid<\/span>(sum(5.5<\/span>, true<\/span>)).name() <<<\/span> '\\n'<\/span>;    \/\/ double<\/span>\r\n    std::<\/span>cout <<<\/span> typeid<\/span>(sum(true<\/span>, 5.5<\/span>)).name() <<<\/span> '\\n'<\/span>;    \/\/ double<\/span>\r\n    std::<\/span>cout <<<\/span> typeid<\/span>(sum(true<\/span>, false<\/span>)).name() <<<\/span> '\\n'<\/span>;  \/\/ int<\/span>\r\n\r\n    std::<\/span>cout <<<\/span> '\\n'<\/span>;\r\n\r\n}\r\n<\/pre>\n<\/div>\n
 <\/p>\n
 You have to read the expression auto sum(T t, T2 t2)  -> decltype(t + t2)<\/code> in the following way. You express with auto<\/code> that you don’t know the type and promise that you specify the type later. This specification happens in the decltype<\/code> expression: decltype(t + t2)<\/code>. The return type of the function template sum<\/code> is that type to which the arithmetic expression evaluates. Here is what I don’t like about this C++11 syntax: You have to use two times the same expression t + t2<\/code>. This is error-prone and redundant. The trailing return type syntax is in general optional but required for automatic return type deduction in C++11 and lambdas.<\/p>\n
Let’s see if C++14 simplifies the use of the automatic return type.<\/p>\n<\/p>\n
C++14<\/h2>\n
With C++14, we got the convenient syntax for automatic return type deduction without redundancy.<\/p>\n
<\/p>\n
\n
\/\/ automaticReturnTypeTypeAuto.cpp<\/span>\r\n\r\n#include <iostream><\/span>\r\n#include <typeinfo><\/span>\r\n#include <type_traits><\/span>\r\n\r\ntemplate<\/span> <<\/span>typename<\/span> T, typename<\/span> T2><\/span>\r\nauto<\/span> sum(T t, T2 t2) {\r\n    return<\/span> t +<\/span> t2;\r\n}\r\n\r\n\r\nint<\/span> main() {\r\n\r\n    std::<\/span>cout <<<\/span> '\\n'<\/span>;\r\n\r\n    std::<\/span>cout <<<\/span> typeid<\/span>(sum(5.5<\/span>, 5.5<\/span>)).name() <<<\/span> '\\n'<\/span>;     \/\/ double<\/span>\r\n    std::<\/span>cout <<<\/span> typeid<\/span>(sum(5.5<\/span>, true<\/span>)).name() <<<\/span> '\\n'<\/span>;    \/\/ double<\/span>\r\n    std::<\/span>cout <<<\/span> typeid<\/span>(sum(true<\/span>, 5.5<\/span>)).name() <<<\/span> '\\n'<\/span>;    \/\/ double<\/span>\r\n    std::<\/span>cout <<<\/span> typeid<\/span>(sum(true<\/span>, false<\/span>)).name() <<<\/span> '\\n'<\/span>;  \/\/ int<\/span>\r\n\r\n    std::<\/span>cout <<<\/span> '\\n'<\/span>;\r\n\r\n}\r\n<\/pre>\n<\/div>\n
 <\/p>\n
In C++14, you can just use auto<\/code> as a return type.<\/p>\n
Let’s make the last jump to C++20.<\/p>\n
C++20<\/h2>\n
In C++20, you should use instead of an unconstrained placeholder a constrained placeholder, aka concept. Defining and using the concept Arithmetic<\/code> expresses explicitly my intent. Only arithmetic<\/a> types are allowed in the function template sum<\/code>.<\/p>\n
<\/code><\/p>\n
<\/p>\n
\n
\/\/ automaticReturnTypeTypeConcepts.cpp<\/span>\r\n\r\n#include <iostream><\/span>\r\n#include <typeinfo><\/span>\r\n#include <type_traits><\/span>\r\n\r\ntemplate<\/span><<\/span>typename<\/span> T><\/span>\r\nconcept Arithmetic =<\/span> std::<\/span>is_arithmetic<<\/span>T>::<\/span>value;\r\n\r\nArithmetic auto<\/span> sum<\/span>(Arithmetic auto<\/span> t, Arithmetic auto<\/span> t2) {\r\n    return<\/span> t +<\/span> t2;\r\n}\r\n\r\n\r\nint<\/span> main<\/span>() {\r\n\r\n    std::<\/span>cout <<<\/span> '\\n'<\/span>;\r\n\r\n    std::<\/span>cout <<<\/span> typeid<\/span>(sum(5.5<\/span>, 5.5<\/span>)).name() <<<\/span> '\\n'<\/span>;     \/\/ double<\/span>\r\n    std::<\/span>cout <<<\/span> typeid<\/span>(sum(5.5<\/span>, true<\/span>)).name() <<<\/span> '\\n'<\/span>;    \/\/ double<\/span>\r\n    std::<\/span>cout <<<\/span> typeid<\/span>(sum(true<\/span>, 5.5<\/span>)).name() <<<\/span> '\\n'<\/span>;    \/\/ double<\/span>\r\n    std::<\/span>cout <<<\/span> typeid<\/span>(sum(true<\/span>, false<\/span>)).name() <<<\/span> '\\n'<\/span>;  \/\/ int<\/span>\r\n\r\n    std::<\/span>cout <<<\/span> '\\n'<\/span>;\r\n\r\n}\r\n<\/pre>\n<\/div>\n
 <\/p>\n
I’m defining the concept Arithmetic<\/code> by directly using the type-traits function std::is_arithmetic<\/code><\/a>. The function std::is_arithmetic<\/code> is a so-called compile-time predicate. A compile-time function is a function that returns at compile-time a boolean<\/code>.<\/p>\n
If you want to read more about concepts, read my previous posts about concepts<\/a>.<\/p>\n
What’s next?<\/h2>\n
Template metaprogramming, or programming at compile time using templates, is a potent C++ technique with a bad reputation. The functions of the type-traits library, such as std::common_type<\/code> or std::is_arithmetic<\/code> are examples of template metaprogramming in C++. In my next post, I will elaborate more on template metaprogramming.<\/p>\n
C++20 Training for Meeting C++<\/h2>\n
Next Tuesday (02.11.2021), I will give a one-day training about the big four in C++20<\/a> (Concepts, Ranges, Modules, and Coroutines). You will also get a coupon for my C++20 book when you book my training.<\/p>\n
 <\/p>\n
I’m happy to see you,<\/p>\n
\"RainerGrimmSmall\"<\/p>\n
 <\/p>\n
 <\/p>\n
 <\/p>\n
 <\/p>\n
 <\/p><\/p>\n","protected":false},"excerpt":{"rendered":"
I started my discussion about the  “Automatic Return Type (C++98)” in my last post. Today, I’m faced with the same challenge but solve it with C++11, C++14, and C++20.<\/p>\n","protected":false},"author":21,"featured_media":6233,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[376],"tags":[436,415,437],"class_list":["post-6239","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-templates","tag-auto","tag-concepts","tag-decltype"],"_links":{"self":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/6239","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=6239"}],"version-history":[{"count":1,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/6239\/revisions"}],"predecessor-version":[{"id":6695,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/6239\/revisions\/6695"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/media\/6233"}],"wp:attachment":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/media?parent=6239"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/categories?post=6239"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/tags?post=6239"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}