{"id":6238,"date":"2021-10-15T06:17:59","date_gmt":"2021-10-15T06:17:59","guid":{"rendered":"https:\/\/www.modernescpp.com\/index.php\/automatic-return-type\/"},"modified":"2023-06-26T09:24:48","modified_gmt":"2023-06-26T09:24:48","slug":"automatic-return-type","status":"publish","type":"post","link":"https:\/\/www.modernescpp.com\/index.php\/automatic-return-type\/","title":{"rendered":"Automatic Return Type (C++98)"},"content":{"rendered":"

Depending on the used C++ standard, there are different ways to return the correct return type of a function template. In this post, I start with traits (C++98), continue in my next post with C++11\/14, and end with concepts (C++20).<\/p>\n

<\/p>\n

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

Here is the challenge for today’s post.<\/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, such as sum<\/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 that the arithmetic operation t + t2 <\/code>provides. Here are a few examples using run-time type information (RTTI)<\/a> with std::type_info.<\/code><\/p>\n
<\/p>\n
\n
\/\/ typeinfo.cpp<\/span>\r\n\r\n#include <iostream><\/span>\r\n#include <typeinfo><\/span>\r\n \r\nint<\/span> main<\/span>() {\r\n\t\r\n    std::<\/span>cout <<<\/span> '\\n'<\/span>;\r\n \r\n    std::<\/span>cout <<<\/span> \"typeid(5.5 + 5.5).name(): \"<\/span> <<<\/span> typeid<\/span>(5.5<\/span> +<\/span> 5.5<\/span>).name() <<<\/span> '\\n'<\/span>;\r\n    std::<\/span>cout <<<\/span> \"typeid(5.5 + true).name(): \"<\/span> <<<\/span> typeid<\/span>(5.5<\/span> +<\/span> true<\/span>).name() <<<\/span> '\\n'<\/span>;\r\n    std::<\/span>cout <<<\/span> \"typeid(true + 5.5).name(): \"<\/span> <<<\/span> typeid<\/span>(true<\/span> +<\/span> 5.5<\/span>).name() <<<\/span> '\\n'<\/span>;\r\n    std::<\/span>cout <<<\/span> \"typeid(true + false).name(): \"<\/span> <<<\/span> typeid<\/span>(true<\/span> +<\/span> false<\/span>).name() <<<\/span> '\\n'<\/span>;\r\n\r\n    std::<\/span>cout <<<\/span> '\\n'<\/span>;\r\n    \r\n}\r\n<\/pre>\n<\/div>\n
 <\/p>\n
I executed the program on Windows using MSVC because MSVC produces in contrast to GCC or Clang human-readable names.<\/p>\n
 \"typeinfo\"<\/p>\n
 <\/p>\n
 <\/p>\n
Adding two double<\/code>s returns a double<\/code>, adding a double<\/code> and a bool<\/code> returns a bool<\/code>, and adding two bool<\/code>s returns an int<\/code>.<\/p>\n
I use in my examples only arithmetic types<\/a>. You must extend my solutions if you want to apply my examples to user-defined that support arithmetic operations.<\/p>\n
Now, my journey starts with C++98.<\/p>\n<\/p>\n
C++98<\/h2>\n
Honestly, C++98 provides no general solution for returning the correct type. Essentially, you must implement the type-deduction rules using a technique called traits<\/a>, also known as template traits. A traits class provides valuable information about template parameters and can be used instead of the template parameters.<\/p>\n
The following class ResultType<\/code> provides a type-to-type mapping using full template specialization.<\/p>\n
 <\/p>\n
<\/p>\n
\n
\/\/ traits.cpp<\/span>\r\n\r\n#include <iostream><\/span>\r\n#include <typeinfo><\/span>\r\n\r\ntemplate<\/span> <<\/span>typename<\/span> T, typename<\/span> T2><\/span> \/\/ primary template (1)<\/span>\r\nstruct<\/span> ReturnType;       \r\n\r\ntemplate<\/span> <><\/span>  \/\/ full specialization for double, double<\/span>\r\nstruct<\/span> ReturnType <<\/span>double<\/span>, double<\/span>><\/span> {\r\n    typedef<\/span> double<\/span> Type;\r\n};\r\n\r\ntemplate<\/span> <><\/span> \/\/  full specialization for double, bool<\/span>\r\nstruct<\/span> ReturnType <<\/span>double<\/span>, bool<\/span>><\/span> {\r\n    typedef<\/span> double<\/span> Type;         \/\/ (2)<\/span>\r\n};\r\n\r\ntemplate<\/span> <><\/span> \/\/ full specialization for bool, double<\/span>\r\nstruct<\/span> ReturnType <<\/span>bool<\/span>, double<\/span>><\/span> {\r\n    typedef<\/span> double<\/span> Type;\r\n};\r\n\r\ntemplate<\/span> <><\/span> \/\/ full specialization for bool, bool<\/span>\r\nstruct<\/span> ReturnType <<\/span>bool<\/span>, bool<\/span>><\/span> {\r\n    typedef<\/span> int<\/span> Type;\r\n};\r\n\r\ntemplate<\/span> <<\/span>typename<\/span> T, typename<\/span> T2><\/span>  \r\ntypename<\/span> ReturnType<<\/span>T, T2>::<\/span>Type sum(T t, T2 t2) {   \/\/ (3)<\/span>\r\n    return<\/span> t +<\/span> t2;\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(sum(5.5, 5.5)).name(): \"<\/span> <<<\/span> typeid<\/span>(sum(5.5<\/span>, 5.5<\/span>)).name() <<<\/span> '\\n'<\/span>;\r\n    std::<\/span>cout <<<\/span> \"typeid(sum(5.5, true)).name(): \"<\/span> <<<\/span> typeid<\/span>(sum(5.5<\/span>, true<\/span>)).name() <<<\/span> '\\n'<\/span>;\r\n    std::<\/span>cout <<<\/span> \"typeid(sum(true, 5.5)).name(): \"<\/span> <<<\/span> typeid<\/span>(sum(true<\/span>, 5.5<\/span>)).name() <<<\/span> '\\n'<\/span>;\r\n    std::<\/span>cout <<<\/span> \"typeid(sum(true, false)).name(): \"<\/span> <<<\/span> typeid<\/span>(sum(true<\/span>, false<\/span>)).name() <<<\/span> '\\n'<\/span>;\r\n\r\n    std::<\/span>cout <<<\/span> '\\n'<\/span>;\r\n\r\n}\r\n<\/pre>\n<\/div>\n
 <\/p>\n
Line (1) is the primary template or general template. The primary template has to be declared before the following full specializations. A declaration such as in line 1 is acceptable if the primary template is unnecessary. The following lines provide the full specializations for <double, double><\/code> , for <double, bool><\/code>, for <bool, double><\/code>, and for <bool, bool><\/code>. You can read more details about template specialization in my previous posts:<\/p>\n