![\"templatesNew\"](\"https:\/\/www.modernescpp.com\/wp-content\/uploads\/2021\/05\/templatesNew.png\")
<\/p>\nA function template is a family of functions. In this post, I want to dive deeper into function templates.<\/p>\n
<\/p>\n
<\/p>\n
Here is a short reminder to get you on the same page.<\/p>\n
When you instantiate a function template such as <\/p>\n Okay, now I can dive into the details. What happens when function templates and non-template functions (in short functions) overload?<\/p>\n<\/p>\n Let me use the function Here is my following example:<\/p>\n <\/p>\n You may guess my question. What happens in lines (1) and (2)? Here are a few questions?<\/p>\n The answer to questions is pretty intuitive and follows the general rule in C++. The compiler chooses the best-fitting function.<\/p>\n As before, C++ Insights<\/a> helps to visualize this process.<\/p>\n The screenshot shows it explicitly. Only the use of the function template Let’s go further in our journey through the basics of function templates.<\/p>\n First disclaimer: I ignore concepts <\/a>in this post.<\/p>\n Let me use my function template <\/p>\n Let’s try it out on C++ Insights<\/a>:<\/p>\n Wow! What is happening here? Why is the Second disclaimer: I simplified the process of template argument deduction. I will write an additional post about template argument deduction for function templates and class templates in a future post.<\/p>\n Of course, we want to compare values of different types.<\/p>\n The solution seems to be straightforward. I introduce a second type parameter.<\/p>\n <\/p>\n This is easy! Right? But there is a severe problem. Do you see the three question marks as return type? This problem typically occurs when your function template has more than one type parameter. What should be the return type?<\/p>\n In this concrete case, should the return type be T, T2, or a Type R derived from T and T2? This task was challenging before C++11, but it is pretty easy with C++11.<\/p>\n Here are a few solutions I have in mind:<\/p>\n <\/p>\n <\/p>\n The first two versions max<\/code> for int<\/code><\/code> and double<\/code><\/code><\/code> <\/code><\/p>\n\ntemplate<\/span> <<\/span>typename<\/span> T><\/span>\r\nT max(T lhs,T rhs) {\r\n return<\/span> (lhs ><\/span> rhs)?<\/span> lhs :<\/span> rhs;\r\n}\r\n\r\nint<\/span> main() {\r\n \r\n max(10<\/span>, 5<\/span>);\r\n max(10.5<\/span>, 5.5<\/span>);\r\n \r\n}\r\n<\/pre>\n<\/div>\n<\/code>the compiler generates a fully specialized function template for int and double<\/code>: max<int><\/strong><\/code> and max<double><\/code>. The generic part is, in both cases, empty: template<><\/code> Thanks to C++ Insights, here are the insights.<\/p>\n![\"functionTempateIntDouble\"](\"https:\/\/www.modernescpp.com\/wp-content\/uploads\/2021\/05\/functionTempateIntDouble.png\")
<\/p>\nOverloading of Function Templates and Functions<\/h2>\n
max<\/code> once more. This time I instantiate it for float<\/code> and double,<\/code> and I provide a function max<\/code> also taking doubles.<\/p>\n\ntemplate<\/span> <<\/span>typename<\/span> T><\/span>\r\nT max(T lhs,T rhs) {\r\n return<\/span> (lhs ><\/span> rhs)?<\/span> lhs :<\/span> rhs;\r\n}\r\n\r\ndouble<\/span> max(double<\/span> lhs, double<\/span> rhs) {\r\n return<\/span> (lhs ><\/span> rhs)?<\/span> lhs :<\/span> rhs;\r\n}\r\n\r\nint<\/span> main() {\r\n \r\n max(10.5f<\/span>, 5.5f<\/span>); \/\/ (1)<\/span>\r\n max(10.5<\/span>, 5.5<\/span>); \/\/ (2)<\/span>\r\n \r\n}\r\n<\/pre>\n<\/div>\n\n
float<\/code> to double<\/code>.<\/li>\n\n
![\"functionTemplateFloatDouble\"](\"https:\/\/www.modernescpp.com\/wp-content\/uploads\/2021\/05\/functionTemplateFloatDoubleCircle.png\")
<\/p>\nmax<\/code> with float<\/code> (line 2) triggers the instantiations of the function template.<\/p>\nDifferent Template Arguments<\/h2>\n
max<\/code> with two values having different types.<\/p>\n\ntemplate<\/span> <<\/span>typename<\/span> T><\/span>\r\nT max(T lhs,T rhs) {\r\n return<\/span> (lhs ><\/span> rhs)?<\/span> lhs :<\/span> rhs;\r\n}\r\n\r\nint<\/span> main() {\r\n \r\n max(10.5f<\/span>, 5.5<\/span>);\r\n \r\n}\r\n<\/pre>\n<\/div>\n![\"functionTemplatesFloatDoubleError\"](\"https:\/\/www.modernescpp.com\/wp-content\/uploads\/2021\/05\/functionTemplatesFloatDoubleError.png\")
<\/p>\nfloat<\/code> not promoted to a double<\/code>? Honestly, the compiler thinks differently, and let me explain how.<\/p>\n\n
10.5f<\/code> the compiler deduces float <\/code>for T,<\/code> for 5.5<\/code> the compiler deduces double<\/code> for T<\/code>.<\/li>\nfloat<\/code> and double<\/code> at the same time. Because of this ambiguity, the compilation failed.<\/li>\n<\/ul>\nTwo Type Parameters<\/h3>\n
\ntemplate<\/span> <<\/span>typename<\/span> T, typename<\/span> T2><\/span>\r\n???<\/span> max(T lhs,T2 rhs) {\r\n return<\/span> (lhs ><\/span> rhs)?<\/span> lhs :<\/span> rhs;\r\n}\r\n\r\nint<\/span> main() {\r\n \r\n max(10.5f<\/span>, 5.5<\/span>);\r\n \r\n}\r\n<\/pre>\n<\/div>\n\n\/\/ automaticReturnTypeDeduction.cpp<\/span>\r\n\r\n#include <type_traits><\/span>\r\n\r\ntemplate<\/span> <<\/span>typename<\/span> T1, typename<\/span> T2><\/span> \/\/ (1)<\/span>\r\ntypename<\/span> std::<\/span>conditional<<\/span>(sizeof<\/span>(T1) ><\/span> sizeof<\/span>(T2)), T1, T2>::<\/span>type max1(T1 lhs,T2 rhs) {\r\n return<\/span> (lhs ><\/span> rhs)?<\/span> lhs :<\/span> rhs;\r\n}\r\n\r\ntemplate<\/span> <<\/span>typename<\/span> T1, typename<\/span> T2><\/span> \/\/ (2)<\/span>\r\ntypename<\/span> std::<\/span>common_type<<\/span>T1, T2>::<\/span>type max2(T1 lhs,T2 rhs) {\r\n return<\/span> (lhs ><\/span> rhs)?<\/span> lhs :<\/span> rhs;\r\n}\r\n\r\ntemplate<\/span> <<\/span>typename<\/span> T1, typename<\/span> T2><\/span> \/\/ (3)<\/span>\r\nauto<\/span> max3(T1 lhs,T2 rhs) {\r\n return<\/span> (lhs ><\/span> rhs)?<\/span> lhs :<\/span> rhs;\r\n}\r\n\r\nint<\/span> main() {\r\n \r\n max1(10.5f<\/span>, 5.5<\/span>); \r\n max2(10.5f<\/span>, 5.5<\/span>); \r\n max3(10.5f<\/span>, 5.5<\/span>); \r\n \r\n}\r\n<\/pre>\n<\/div>\nmax1<\/code> (line 1) and max2<\/code> (line 2) are based on the type-traits library. The third version max3<\/code> (line 3) uses the automatic type deduction of auto<\/code>.<\/p>\n\n
max1<\/code> (line 1): typename<\/code> std::conditional<(sizeof(T1) > sizeof(T2)), T1, T2>::type<\/code> returns the type T1<\/code>, or T2<\/code> that is bigger. std::conditional<\/a> is a kind of compile-time ternary operator.<\/li>\nmax2<\/code> (line2): typename td::common_type<T1, T2>::type<\/code> returns the common type of the types T1 and T2. std::common_type<\/a> can accept an arbitrary number of arguments.<\/li>\nmax3<\/code> (line3): auto<\/code> should be self-explanatory.<\/li>\n<\/ul>\nMaybe you are irritated by the typename<\/code> in-front of the return type of the function template max1<\/code> and max2. T1 and T2 are dependent names. What is a dependent name? A dependent name is essentially a name that depends on a template parameter. In this case, we have to give the compiler a hint that T1 and T2 are types. Essentially, they can also be non-types or templates.<\/div>\n <\/div>\nThird disclaimer: I write in an additional post about dependent types.<\/div>\n <\/div>\nLet’s see what C++ Insights provides. I only show the template instantiations. If you want to analyze the entire program, follow this link: C++ Insights<\/a>.<\/div>\n <\/div>\n\n
max1<\/code>(line 1): You can only guess the return type. In the return statement, the smaller type (float) is converted to double<\/code>. ![\"max1\"](\"https:\/\/www.modernescpp.com\/wp-content\/uploads\/2021\/05\/max1.png\")
<\/li>\nmax2<\/code>(line 2): As for max1<\/code>, the return statement gives an idea about the return type: the float value is converted to double<\/code>.<\/li>\n<\/ul>\n![\"max2\"](\"https:\/\/www.modernescpp.com\/wp-content\/uploads\/2021\/05\/max2.png\")
<\/p>\n\n
max3<\/code> (line 3): Now, we can see the return type explicitly. It is a double<\/code>.<\/li>\n<\/ul>\n![\"max3\"](\"https:\/\/www.modernescpp.com\/wp-content\/uploads\/2021\/05\/max3.png\")
<\/p>\n