//////////////////// // // Name: Template Argument Deduction // Author: Shadow // Version: 1.0.0 // Date: 12.03.2019 // Description: Short presentation of argument // deduction in templates using max() as // example, showing different upsides as // well as downsides. // Reference: C++ Templates, The Complete Guide // //////////////////// // //////////PREPROCESSOR////////// // #include #include // //////////FUNCTIONS////////// // /* * Template parameters have to be concluded by the * compiler depending on the arguments we pass. * Thus, the simplest implementation of max() looks * like this: */ template T custom_max_1( T a, T b ) { return ( b < a ) ? a : b; } /* * However, T might only be 'part' of the type. Since * max() does not alter the arguments it receives, * we can pass a constant reference instead. */ template T custom_max_2( const T& a, const T& b ) { return ( b < a ) ? a : b; } /* * If we pass 'int' here, T will still be deduced as * 'int', because the parameters match for * 'int const&'. However, automatic type conversations * are quite limited during the type deduction. * When passing by reference, the template parameters * must match exactly; when passing by value, only * trivial conversations apply, meaning the decayed * types must match. * 'Decayed' types are base types, resulting in * qualifiers such as 'const' or 'volatile' to be * ignored, as well as references being converted to * the reference type, and arrays/functions being * converted to pointers. * If you want to pass parameters of different kinds * of types, you have to use multiple template * parameters, shown below: */ template T1 custom_max_3( const T1& a, const T2& b ) { return ( b < a ) ? b : a; } /* * Although it might seem like a good idea to be able * to pass different types, a problem araises. * Depending on which value is returned, it might be * converted to the parameter type used as the return * type. * For example, if 'b' > 'a', then 'b' will be * implicitly casted to 'T1', regardless of the * caller's intentions, who might want to use the * returned value for further actions, requiring the * precise value of 'b'. * An option to solve this problem is to introduce * a template parameter for the return type: */ template RT custom_max_4( const T1& a, const T2& b ) { return ( b < a ) ? a : b; } /* * However, the process of argument deduction does not * take return types, which cannot be determined by * instantiation of the template, into account. * Therefore, RT cannot be deduced by the compiler. * If you wanted to use the function, you could * explicitly specify the types to be used for the * parameters: custom_max_4< int, double, double >( 4, 7.2 ); * Not very stylish. We can do a little better by * specifying only the first argument explicitly, * leaving the rest up to the deduction process. * In general, all argument types up to the last type * that cannot be determined implicitly must be * specified. All we have to do is to change the order * of the template parameters: */ template RT custom_max_5( const T1& a, const T2& b ) { return ( b < a ) ? a : b; } /* * Now we can call custom_max_5< double >( 4, 7.2 ); * where 'RT' is explicitly set to 'double', while * 'T1' and 'T2' are deduced. Since the advantages are * slight and not very significant, it might be a * better idea to stick with the simple version. * * However, in cases where the return type does depend * on template parameters, it is possible to deduce * the return type. There are essentially two ways * for doing so: */ //C++ 14 template auto custom_max_6( const T1& a, const T2& b ) { return ( b < a ) ? a : b; } /* * Since C++ 14, we can simply use 'auto' to have the * type deduced. Before C++ 14, we have to declare * that the return type is actually derived from the * result of the ?: operator: */ //C++ 11 template auto custom_max_7( const T1& a, const T2& b ) -> decltype( b < a ? a : b ) { return ( b < a ) ? a : b; } /* * There is a drawback to this method though, because * the return type might be a reference when T is * under circumstances a reference. Thus it is a * better idea to return the decayed type of T by * using the function std::decay<>, which returns the * resulting type as a member type. * As a consequence, the expression must be qualified * with 'typename', resulting in a quite long line of * code: */ template auto custom_max_8( const T1& a, const T2& b ) -> typename std::decay< decltype( b < a ? a : b ) >::type { return ( b < a ) ? a : b; } /* * Also back to C++ 14 dates the third option. * In fact, you can specify choosing * "the more general type", which is in return * acquired by the function std::common_type<>::type. * The implementation simplifies to: */ template std::common_type_t< T1, T2 > custom_max_9( const T1& a, const T2& b ) { return ( b < a ) ? a : b; } /* * We can combine most of the previous approaches by * introducing default values for the template * parameters. While being able to define the return * type, there can still be multiple parameter types. * Now it would look like this: */ template > RT custom_max_10( const T1& a, const T2& b ) { return ( b < a ) ? a : b; } /* * Although in this case, we would have to specify * three types if we wanted to explicitly specify * the return type. In order to be able to deduce * the type of 'RT' using 'T1' and 'T2', 'RT' must * follow after them. Although it is possible to have * default values for leading template parameters, * it is not possible to deduce their type, thus only * being useful if there is a "natural" default for * the template parameters. * * As a result, looking at all the different reasons * and implementations, the easiest solution would be * to go with the C++ 14 method and have the compiler * deduce the return type using the 'auto' keyword. */ // //////////MAIN FUNCTION////////// // int main() { /* * Below are some tests for the implementations, * in this case for the solution mentioned above. * You are welcomed to switch out the * implementation and test different scenarions! */ int a { 10 }; const int b { 20 }; int& c { a }; double d { 30.5 }; std::cout << "Test Results:" << "\nmax( 10, 20 ) => " << custom_max_6( a, b ) // OK: T = int << "\nmax( 20, 10 ) => " << custom_max_6( b, c ) // OK: T = int << "\nmax( 20, 30.5 ) => " << custom_max_6( b, d ) << std::endl; // OK: T = double return 0; }