In C++11, a function must specify its return type in one of the following two ways:<\/p>\n
int aFunction(int arg) {<\/p>\n
\u00a0 \u00a0 return arg * 2;<\/p>\n
}<\/p>\n
(or)<\/strong><\/p>\n auto aFunction(int arg) -> int {<\/p>\n \u00a0 \u00a0 return arg * 2;<\/p>\n }<\/p>\n The first is the classic function definition syntax. The second form was introduced in C++11, and is useful if, for example, the return type depends on the argument types. This situation arises sometimes in the case of template functions:<\/p>\n template<typename T1, typename T2><\/p>\n auto aTemplateFunction(T1 arg1, T1 arg2, T2 arg3) -> decltype(arg2 * arg3) {<\/p>\n \u00a0 \u00a0 return arg2 * (arg3 – 1);<\/p>\n }<\/p>\n Here the decltype<\/strong><\/em> specifier comes in handy to determine the type of the return expression.<\/p>\n In C++14, the compiler is supposed to deduce the return type automatically, so the following is acceptable:<\/p>\n auto aFunction(int arg) {<\/p>\n \u00a0 \u00a0 return arg * 2;<\/p>\n }<\/p>\n and even this:<\/p>\n template<typename T1, typename T2><\/p>\n auto aTemplateFunction(T1 arg1, T1 arg2, T2 arg3)\u00a0 {<\/p>\n \u00a0 \u00a0 return arg2 * arg3 + 8;<\/p>\n }<\/p>\n The requirement is that the return value must be of the same type<\/strong><\/em> along every<\/strong><\/em> return path in the function body.<\/p>\n The following will trigger compilation error:<\/p>\n auto badFunction(int arg) {<\/p>\n \u00a0 \u00a0 if (arg > 0)<\/p>\n \u00a0 \u00a0 \u00a0 \u00a0 return arg; \/\/ \u2018int\u2019 return type<\/p>\n \u00a0 \u00a0 return arg * 1.2; \/\/ \u2018double\u2019<\/p>\n }<\/p>\n This automatic return type deduction will work for recursive functions too, as long as there is a return<\/strong><\/em> preceding the recursive call.<\/p>\n \/\/ Precondition: N >= 0<\/p>\n auto factorial(int N)<\/p>\n {<\/p>\n \u00a0 \u00a0 if(N == 0 || N == 1)<\/p>\n \u00a0 \u00a0 \u00a0 \u00a0 return 1;<\/p>\n \u00a0 \u00a0 return N * factorial (N – 1);<\/p>\n }<\/p>\n The above works as expected, but the following is not valid:<\/p>\n \/\/ Precondition: N >= 0<\/p>\n auto factorial2(int N)<\/p>\n {<\/p>\n \u00a0 \u00a0 if(N > 1)<\/p>\n \u00a0 \u00a0 \u00a0 \u00a0 return N * factorial2 (N – 1); \/\/ No previous return to deduce type<\/p>\n \u00a0 \u00a0 return 1;<\/p>\n }<\/p>\n This automatic return type deduction feature is quite useful for the following reasons:<\/p>\n 1) In many\u00a0cases, we\u00a0will have to type less (compared to the actual return type)!<\/p>\n 2) During development phase, we tend to refactor the code, possibly resulting in different return types at different times. With auto<\/strong><\/em>, we need not worry about keeping the return type declaration in sync with what is actually returned. The compiler does it for us.<\/p>\n 3) Some return types can be pretty verbose (without proper typedef). Using auto<\/strong><\/em> promotes readability in such cases. A simple example is pointer to functions.<\/p>\n 4) What if the returned value is a lambda, or worse still, a function that returns a lambda (and so on\u2026)? Let the compiler figure it out!<\/p>\n auto getLambda(int delta) {<\/p>\n \u00a0 \u00a0 return [=](int arg) {return arg + delta;};<\/p>\n }<\/p>\n auto getFunctionThatReturnsLambda() {<\/p>\n \u00a0 \u00a0 return getLambda;<\/p>\n }<\/p>\n Compare the above to what we\u00a0would have to do in case auto<\/strong><\/em> was not allowed for the return type:<\/p>\n std::function<int(int)><\/strong><\/p>\n getLambda(int delta) {<\/p>\n \u00a0 \u00a0 return [=](int arg) {return arg + delta;};<\/p>\n }<\/p>\n std::function<std::function<int(int)>(int)><\/strong><\/p>\n getFunctionThatReturnsLambda() {<\/p>\n \u00a0 \u00a0 return getLambda;<\/p>\n }<\/p>\n Here we use the std::function<><\/strong><\/em> template defined in <functional><\/strong><\/em> STL header.\u00a0Obviously, auto<\/strong><\/em> makes things much easier.<\/p>\n Overall, the auto<\/strong><\/em>\u00a0return type specification\u00a0introduced in C++14 is a very useful feature, something that every C++ programmer would use everyday. With Visual Studio 2015 Update 2<\/strong><\/em> adding support for C++14, Windows programmers will be a happy lot!<\/p>\n","protected":false},"excerpt":{"rendered":" In C++11, a function must specify its return type in one of the following two ways: int aFunction(int arg) { \u00a0 \u00a0 return arg * 2; } (or) auto aFunction(int arg) -> int { \u00a0 \u00a0 return arg * 2; } The first is the classic function definition syntax. The second form was introduced in […]<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"advanced_seo_description":"","jetpack_seo_html_title":"","jetpack_seo_noindex":false,"jetpack_post_was_ever_published":false,"_jetpack_newsletter_access":"","_jetpack_dont_email_post_to_subs":false,"_jetpack_newsletter_tier_id":0,"_jetpack_memberships_contains_paywalled_content":false,"_jetpack_memberships_contains_paid_content":false,"footnotes":"","jetpack_publicize_message":"","jetpack_publicize_feature_enabled":true,"jetpack_social_post_already_shared":false,"jetpack_social_options":{"image_generator_settings":{"template":"highway","default_image_id":0,"font":"","enabled":false},"version":2}},"categories":[49,17],"tags":[50,51],"class_list":["post-198","post","type-post","status-publish","format-standard","hentry","category-c","category-programming","tag-c14","tag-return-type-deduction"],"jetpack_publicize_connections":[],"jetpack_featured_media_url":"","jetpack_sharing_enabled":true,"jetpack_shortlink":"https:\/\/wp.me\/p9OLnF-3c","jetpack-related-posts":[{"id":1973,"url":"https:\/\/www.rangakrish.com\/index.php\/2020\/04\/26\/stdis_base_of\/","url_meta":{"origin":198,"position":0},"title":"std::is_base_of","author":"admin","date":"April 26, 2020","format":false,"excerpt":"In our on-going series on C++ Type Traits, today's topic is about the trait std::is_base_of<>. For the official description, see this. std::is_base_of