{"id":2055,"date":"2025-01-27T19:36:29","date_gmt":"2025-01-27T19:36:29","guid":{"rendered":"https:\/\/bhiggs.x10hosting.com\/PracticalCPlusPlusProgramming\/?page_id=2055"},"modified":"2025-01-27T21:16:47","modified_gmt":"2025-01-27T21:16:47","slug":"template-explicit-specialization","status":"publish","type":"page","link":"https:\/\/bhiggs.x10hosting.com\/PracticalCPlusPlusProgramming\/index.php\/topics\/c-details\/function-templates-2\/template-explicit-specialization\/","title":{"rendered":"Template Explicit Specialization"},"content":{"rendered":"\n

<\/span>Template Explicit Specialization<\/span><\/h2>\n\n\n\n

Let’s look at a simpler template function, one that returns whether the first value is greater than the second value:<\/p>\n\n\n\n

\n
\n
<\/path><\/path><\/svg><\/span>
\/\/<\/span><\/span>\n\/\/  templcompare.h<\/span><\/span>\n\/\/  Function Templates<\/span><\/span>\n\/\/<\/span><\/span>\n\/\/  Created by Bryan Higgs on 10\/11\/24.<\/span><\/span>\n\/\/<\/span><\/span>\n<\/span>\n#ifndef<\/span> templcompare_h<\/span><\/span>\n#define<\/span> templcompare_h<\/span><\/span>\n<\/span>\ntemplate<\/span> <<\/span>typename<\/span> <\/span>T<\/span>><\/span><\/span>\nbool<\/span> <\/span>isGreater<\/span>(<\/span>const<\/span> <\/span>T<\/span> <\/span>&<\/span>value1<\/span>, <\/span>const<\/span> <\/span>T<\/span> <\/span>&<\/span>value2<\/span>)<\/span><\/span>\n{<\/span><\/span>\n  <\/span>if<\/span> (value1 > value2)<\/span><\/span>\n    <\/span>return<\/span> <\/span>true<\/span>;<\/span><\/span>\n  <\/span>return<\/span> <\/span>false<\/span>;<\/span><\/span>\n}<\/span><\/span>\n<\/span>\n#endif<\/span> \/* templcompare_h *\/<\/span><\/span><\/code><\/pre><\/div>\n<\/div>\n\n\n\n
\n
<\/path><\/path><\/svg><\/span>
\/\/<\/span><\/span>\n\/\/  templcompare_main.cpp<\/span><\/span>\n\/\/  Function Templates<\/span><\/span>\n\/\/<\/span><\/span>\n\/\/  Created by Bryan Higgs on 10\/11\/24.<\/span><\/span>\n\/\/<\/span><\/span>\n<\/span>\n#include<\/span> <\/span><iostream><\/span><\/span>\n#include<\/span> <\/span>"templcompare.h"<\/span><\/span>\n<\/span>\nint<\/span> <\/span>main<\/span>(<\/span>int<\/span> <\/span>argc<\/span>, <\/span>const<\/span> <\/span>char<\/span> <\/span>*<\/span> <\/span>argv<\/span>[])<\/span><\/span>\n{<\/span><\/span>\n  <\/span>int<\/span> i1 = <\/span>5<\/span>, i2 = <\/span>2<\/span>;<\/span><\/span>\n  <\/span>double<\/span> d1 = <\/span>45.2<\/span>, d2 = <\/span>89.3<\/span>;<\/span><\/span>\n  <\/span>const<\/span> <\/span>char<\/span> *s1 = <\/span>"Frodo"<\/span>, *s2 = <\/span>"Bilbo"<\/span>;<\/span><\/span>\n  <\/span><\/span>\n  <\/span>std<\/span>::cout << i1 << <\/span>" > "<\/span> << i2 << <\/span>" "<\/span> << <\/span>std<\/span>::boolalpha<\/span><\/span>\n            << <\/span>isGreater<\/span>(i1, i2) << <\/span>std<\/span>::endl;<\/span><\/span>\n  <\/span>std<\/span>::cout << d1 << <\/span>" > "<\/span> << d2 << <\/span>" "<\/span> << <\/span>std<\/span>::boolalpha<\/span><\/span>\n            << <\/span>isGreater<\/span>(d1, d2) << <\/span>std<\/span>::endl;<\/span><\/span>\n  <\/span>std<\/span>::cout << s1 << <\/span>" > "<\/span> << s2 << <\/span>" "<\/span> << <\/span>std<\/span>::boolalpha<\/span><\/span>\n            << <\/span>isGreater<\/span>(s1, s2) << <\/span>std<\/span>::endl;<\/span><\/span>\n  <\/span><\/span>\n  <\/span>return<\/span> <\/span>0<\/span>;<\/span><\/span>\n}<\/span><\/span><\/code><\/pre><\/div>\n<\/div>\n<\/div>\n\n\n\n
This produces the following output:<\/p>\n\n\n\n
5 > 2 true\n45.2 > 89.3 false\nFrodo > Bilbo false\nProgram ended with exit code: 0<\/strong><\/code><\/pre>\n\n\n\n
\n
But “Frodo” should be greater than “Bilbo” for normal sorting!<\/strong>
What’s wrong?<\/strong><\/p>\n<\/blockquote>\n\n\n\n
<\/div>\n\n\n\n
This result is because the isGreater<\/strong> function is relying on the type T<\/strong> to support the ><\/strong> operator.  In the case of the type const char <\/code>*<\/strong>, the function is comparing pointer values<\/em>, not the strings.<\/p>\n\n\n\n
This shows that function templates cannot always provide the right solution for all types.<\/p>\n\n\n\n
We need to specify that the behavior of max should be different for the type const char *<\/strong>.<\/p>\n\n\n\n
We do this by specifying a template explicit specialization<\/em>.<\/p>\n\n\n\n
A Template Specialization<\/em><\/strong> consists of:<\/p>\n\n\n\n
    \n
  • The keyword template<\/strong> followed by <><\/strong> (with nothing between the brackets)<\/li>\n\n\n\n
  • Followed by the template name and a bracket pair containing the template parameters for the specialization<\/li>\n\n\n\n
  • The function parameter list<\/li>\n\n\n\n
  • followed by the function body.<\/li>\n<\/ul>\n\n\n\n
    \n
    \n
    <\/path><\/path><\/svg><\/span>
    \/\/<\/span><\/span>\n\/\/  templcompare.h<\/span><\/span>\n\/\/  Function Templates<\/span><\/span>\n\/\/<\/span><\/span>\n\/\/  Created by Bryan Higgs on 10\/11\/24.<\/span><\/span>\n\/\/<\/span><\/span>\n<\/span>\n#ifndef<\/span> templcompare_h<\/span><\/span>\n#define<\/span> templcompare_h<\/span><\/span>\n<\/span>\ntemplate<\/span> <<\/span>typename<\/span> <\/span>T<\/span>><\/span><\/span>\nbool<\/span> <\/span>isGreater<\/span>(<\/span>const<\/span> <\/span>T<\/span> <\/span>&<\/span>value1<\/span>, <\/span>const<\/span> <\/span>T<\/span> <\/span>&<\/span>value2<\/span>)<\/span><\/span>\n{<\/span><\/span>\n  <\/span>if<\/span> (value1 > value2)<\/span><\/span>\n    <\/span>return<\/span> <\/span>true<\/span>;<\/span><\/span>\n  <\/span>return<\/span> <\/span>false<\/span>;<\/span><\/span>\n}<\/span><\/span>\n<\/span>\ntemplate<\/span><><\/span><\/span>\nbool<\/span> isGreater<<\/span>const<\/span> <\/span>char<\/span>*><\/span><\/span>\n              (<\/span>const<\/span> <\/span>char<\/span> * <\/span>const<\/span> &value1,<\/span><\/span>\n               <\/span>const<\/span> <\/span>char<\/span> * <\/span>const<\/span> &value2)<\/span><\/span>\n{<\/span><\/span>\n  <\/span>if<\/span> ( <\/span>strcmp<\/span>(value1, value2) > <\/span>0<\/span> )<\/span><\/span>\n    <\/span>return<\/span> <\/span>true<\/span>;<\/span><\/span>\n  <\/span>return<\/span> <\/span>false<\/span>;<\/span><\/span>\n}<\/span><\/span>\n<\/span>\n#endif<\/span> \/* templcompare_h *\/<\/span><\/span><\/code><\/pre><\/div>\n<\/div>\n\n\n\n
    \n
    <\/path><\/path><\/svg><\/span>
    \/\/<\/span><\/span>\n\/\/  templcompare_main.cpp<\/span><\/span>\n\/\/  Function Templates<\/span><\/span>\n\/\/<\/span><\/span>\n\/\/  Created by Bryan Higgs on 10\/11\/24.<\/span><\/span>\n\/\/<\/span><\/span>\n<\/span>\n#include<\/span> <\/span><iostream><\/span><\/span>\n#include<\/span> <\/span>"templcompare.h"<\/span><\/span>\n<\/span>\nint<\/span> <\/span>main<\/span>(<\/span>int<\/span> <\/span>argc<\/span>, <\/span>const<\/span> <\/span>char<\/span> <\/span>*<\/span> <\/span>argv<\/span>[])<\/span><\/span>\n{<\/span><\/span>\n  <\/span>int<\/span> i1 = <\/span>5<\/span>, i2 = <\/span>2<\/span>;<\/span><\/span>\n  <\/span>double<\/span> d1 = <\/span>45.2<\/span>, d2 = <\/span>89.3<\/span>;<\/span><\/span>\n  <\/span>const<\/span> <\/span>char<\/span> *s1 = <\/span>"Frodo"<\/span>, *s2 = <\/span>"Bilbo"<\/span>;<\/span><\/span>\n  <\/span><\/span>\n  <\/span>std<\/span>::cout << i1 << <\/span>" > "<\/span> << i2 << <\/span>" "<\/span> << <\/span>std<\/span>::boolalpha<\/span><\/span>\n            << <\/span>isGreater<\/span>(i1, i2) << <\/span>std<\/span>::endl;<\/span><\/span>\n  <\/span>std<\/span>::cout << d1 << <\/span>" > "<\/span> << d2 << <\/span>" "<\/span> << <\/span>std<\/span>::boolalpha<\/span><\/span>\n            << <\/span>isGreater<\/span>(d1, d2) << <\/span>std<\/span>::endl;<\/span><\/span>\n  <\/span>std<\/span>::cout << s1 << <\/span>" > "<\/span> << s2 << <\/span>" "<\/span> << <\/span>std<\/span>::boolalpha<\/span><\/span>\n            << <\/span>isGreater<\/span>(s1, s2) << <\/span>std<\/span>::endl;<\/span><\/span>\n  <\/span><\/span>\n  <\/span>return<\/span> <\/span>0<\/span>;<\/span><\/span>\n}<\/span><\/span><\/code><\/pre><\/div>\n<\/div>\n<\/div>\n\n\n\n
    \n
    \n
    Which produces the following output:<\/p>\n\n\n\n
    5 > 2 true\n45.2 > 89.3 false\nFrodo > Bilbo true\nProgram ended with exit code: 0<\/strong><\/code><\/pre>\n<\/div>\n\n\n\n
    \n
    So, now the strings (actually const char *<\/strong>) values are compared correctly.<\/p>\n<\/div>\n<\/div>\n\n\n\n
    <\/span>Using an Ordinary Function to Achieve the Same Result<\/span><\/h3>\n\n\n\n
    It is possible to use an ordinary (non-template) function to achieve the same result:<\/p>\n\n\n\n
    \n
    \n
    <\/path><\/path><\/svg><\/span>
    \/\/<\/span><\/span>\n\/\/  templcompare.h<\/span><\/span>\n\/\/  Function Templates<\/span><\/span>\n\/\/<\/span><\/span>\n\/\/  Created by Bryan Higgs on 10\/11\/24.<\/span><\/span>\n\/\/<\/span><\/span>\n<\/span>\n#ifndef<\/span> templcompare_h<\/span><\/span>\n#define<\/span> templcompare_h<\/span><\/span>\n<\/span>\ntemplate<\/span> <<\/span>typename<\/span> <\/span>T<\/span>><\/span><\/span>\nbool<\/span> <\/span>isGreater<\/span>(<\/span>const<\/span> <\/span>T<\/span> <\/span>&<\/span>value1<\/span>, <\/span>const<\/span> <\/span>T<\/span> <\/span>&<\/span>value2<\/span>)<\/span><\/span>\n{<\/span><\/span>\n  <\/span>if<\/span> (value1 > value2)<\/span><\/span>\n    <\/span>return<\/span> <\/span>true<\/span>;<\/span><\/span>\n  <\/span>return<\/span> <\/span>false<\/span>;<\/span><\/span>\n}<\/span><\/span>\n<\/span>\nbool<\/span> isGreater<\/span><\/span>\n              (<\/span>const<\/span> <\/span>char<\/span> * <\/span>const<\/span> &value1,<\/span><\/span>\n               <\/span>const<\/span> <\/span>char<\/span> * <\/span>const<\/span> &value2)<\/span><\/span>\n{<\/span><\/span>\n  <\/span>if<\/span> ( <\/span>strcmp<\/span>(value1, value2) > <\/span>0<\/span> )<\/span><\/span>\n    <\/span>return<\/span> <\/span>true<\/span>;<\/span><\/span>\n  <\/span>return<\/span> <\/span>false<\/span>;<\/span><\/span>\n}<\/span><\/span>\n<\/span>\n#endif<\/span> \/* templcompare_h *\/<\/span><\/span><\/code><\/pre><\/div>\n<\/div>\n\n\n\n
    \n
    <\/path><\/path><\/svg><\/span>
    \/\/<\/span><\/span>\n\/\/  templcompare_main.cpp<\/span><\/span>\n\/\/  Function Templates<\/span><\/span>\n\/\/<\/span><\/span>\n\/\/  Created by Bryan Higgs on 10\/11\/24.<\/span><\/span>\n\/\/<\/span><\/span>\n<\/span>\n#include<\/span> <\/span><iostream><\/span><\/span>\n#include<\/span> <\/span>"templcompare.h"<\/span><\/span>\n<\/span>\nint<\/span> <\/span>main<\/span>(<\/span>int<\/span> <\/span>argc<\/span>, <\/span>const<\/span> <\/span>char<\/span> <\/span>*<\/span> <\/span>argv<\/span>[])<\/span><\/span>\n{<\/span><\/span>\n  <\/span>int<\/span> i1 = <\/span>5<\/span>, i2 = <\/span>2<\/span>;<\/span><\/span>\n  <\/span>double<\/span> d1 = <\/span>45.2<\/span>, d2 = <\/span>89.3<\/span>;<\/span><\/span>\n  <\/span>const<\/span> <\/span>char<\/span> *s1 = <\/span>"Frodo"<\/span>, *s2 = <\/span>"Bilbo"<\/span>;<\/span><\/span>\n  <\/span><\/span>\n  <\/span>std<\/span>::cout << i1 << <\/span>" > "<\/span> << i2 << <\/span>" "<\/span> << <\/span>std<\/span>::boolalpha<\/span><\/span>\n            << <\/span>isGreater<\/span>(i1, i2) << <\/span>std<\/span>::endl;<\/span><\/span>\n  <\/span>std<\/span>::cout << d1 << <\/span>" > "<\/span> << d2 << <\/span>" "<\/span> << <\/span>std<\/span>::boolalpha<\/span><\/span>\n            << <\/span>isGreater<\/span>(d1, d2) << <\/span>std<\/span>::endl;<\/span><\/span>\n  <\/span>std<\/span>::cout << s1 << <\/span>" > "<\/span> << s2 << <\/span>" "<\/span> << <\/span>std<\/span>::boolalpha<\/span><\/span>\n            << <\/span>isGreater<\/span>(s1, s2) << <\/span>std<\/span>::endl;<\/span><\/span>\n  <\/span><\/span>\n  <\/span>return<\/span> <\/span>0<\/span>;<\/span><\/span>\n}<\/span><\/span><\/code><\/pre><\/div>\n<\/div>\n<\/div>\n\n\n\n
    However, this is not<\/em><\/strong> a template explicit specialization.<\/p>\n\n\n\n
    When we define a non-template function, normal conversions are applied to the arguments.<\/p>\n\n\n\n
    Then we specialize a template, conversions are not applied to the argument types.<\/p>\n\n\n\n
    In a call to a specialized version of a template, the argument types in the call must match the specialized version function parameter types exactly<\/em>. If they do not, then the compiler will instantiate an instantiation for the arguments from the template definition.<\/p>\n\n\n\n
    <\/span>Template Argument Deduction<\/span><\/h3>\n\n\n\n
    When a function template is called, the types and values of the template arguments are determined by looking at the types of the function arguments.  This is called template argument deduction<\/em>.<\/p>\n\n\n\n
    There are times when it is not possible for the compiler to deduce the proper template arguments for a function template:<\/p>\n\n\n\n
    \n
    \n
    <\/path><\/path><\/svg><\/span>
    \/\/<\/span><\/span>\n\/\/  main.cpp<\/span><\/span>\n\/\/  Template Argument Deduction<\/span><\/span>\n\/\/<\/span><\/span>\n\/\/  Created by Bryan Higgs on 10\/13\/24.<\/span><\/span>\n\/\/<\/span><\/span>\n<\/span>\n#include<\/span> <\/span><iostream><\/span><\/span>\n<\/span>\ntemplate<\/span> <<\/span>typename<\/span> <\/span>T<\/span>><\/span><\/span>\nT<\/span> <\/span>*<\/span>create<\/span>()<\/span><\/span>\n{<\/span>  \/\/ Make a T and return a pointer to it<\/span><\/span>\n  <\/span>return<\/span> <\/span>new<\/span> T;<\/span><\/span>\n}<\/span><\/span>\n<\/span>\nint<\/span> <\/span>main<\/span>(<\/span>int<\/span> <\/span>argc<\/span>, <\/span>const<\/span> <\/span>char<\/span> <\/span>*<\/span> <\/span>argv<\/span>[])<\/span><\/span>\n{<\/span><\/span>\n  <\/span>int<\/span> *p = <\/span>create<\/span>();<\/span>  \/\/ error: could not deduce<\/span><\/span>\n                      \/\/ template argument for 'T'<\/span><\/span>\n  <\/span>return<\/span> <\/span>0<\/span>;<\/span><\/span>\n}<\/span><\/span><\/code><\/pre><\/div>\n<\/div>\n\n\n\n
    \n
    … produces the following compile-time error:<\/p>\n\n\n\n
    main.cpp:18:12 No matching function for call to 'create'\n\nCandidate template ignored: couldn't infer template argument 'T'<\/strong><\/code><\/pre>\n<\/div>\n<\/div>\n\n\n\n
    <\/span>Explicit Template Specification<\/span><\/h3>\n\n\n\n
    The solution to this is to use explicit template specification<\/em>:<\/p>\n\n\n\n
    \n
    \n
    <\/path><\/path><\/svg><\/span>
    \/\/<\/span><\/span>\n\/\/  main.cpp<\/span><\/span>\n\/\/  Template Argument Deduction<\/span><\/span>\n\/\/<\/span><\/span>\n\/\/  Created by Bryan Higgs on 10\/13\/24.<\/span><\/span>\n\/\/<\/span><\/span>\n<\/span>\n#include<\/span> <\/span><iostream><\/span><\/span>\n<\/span>\ntemplate<\/span> <<\/span>typename<\/span> <\/span>T<\/span>><\/span><\/span>\nT<\/span> <\/span>*<\/span>create<\/span>()<\/span><\/span>\n{<\/span>  \/\/ Make a T and return a pointer to it<\/span><\/span>\n  <\/span>return<\/span> <\/span>new<\/span> T;<\/span><\/span>\n}<\/span><\/span>\n<\/span>\nint<\/span> <\/span>main<\/span>(<\/span>int<\/span> <\/span>argc<\/span>, <\/span>const<\/span> <\/span>char<\/span> <\/span>*<\/span> <\/span>argv<\/span>[])<\/span><\/span>\n{<\/span><\/span>\n  <\/span>int<\/span> *p = <\/span>create<\/span><<\/span>int<\/span>>();<\/span><\/span>\n  <\/span><\/span>\n  <\/span>return<\/span> <\/span>0<\/span>;<\/span><\/span>\n}<\/span><\/span><\/code><\/pre><\/div>\n<\/div>\n\n\n\n
    \n
    This now compiles.<\/p>\n<\/div>\n<\/div>\n\n\n\n
    One common use of explicit specification is to provide a return type for a function template:<\/p>\n\n\n\n
    \n
    \n
    <\/path><\/path><\/svg><\/span>
    \/\/<\/span><\/span>\n\/\/  ReturnType.cpp<\/span><\/span>\n\/\/  Template Argument Deduction<\/span><\/span>\n\/\/<\/span><\/span>\n\/\/  Created by Bryan Higgs on 10\/13\/24.<\/span><\/span>\n\/\/<\/span><\/span>\n<\/span>\n#include<\/span> <\/span><iostream><\/span><\/span>\n<\/span>\ntemplate<\/span> <<\/span>typename<\/span> <\/span>T<\/span>, <\/span>typename<\/span> <\/span>U<\/span>><\/span><\/span>\nU<\/span> <\/span>implicit_cast<\/span>(<\/span>U<\/span> <\/span>u<\/span>)<\/span><\/span>\n{<\/span><\/span>\n  <\/span>std<\/span>::cout << <\/span>"T:"<\/span> << <\/span>typeid<\/span>(T).<\/span>name<\/span>() << <\/span>" "<\/span><\/span>\n            << <\/span>"U:"<\/span> << <\/span>typeid<\/span>(U).<\/span>name<\/span>() << <\/span>std<\/span>::endl;<\/span><\/span>\n  <\/span>return<\/span> u;<\/span><\/span>\n}<\/span><\/span>\n<\/span>\nint<\/span> <\/span>main<\/span>(<\/span>int<\/span> <\/span>argc<\/span>, <\/span>const<\/span> <\/span>char<\/span> <\/span>*<\/span> <\/span>argv<\/span>[])<\/span><\/span>\n{<\/span><\/span>\n  <\/span>int<\/span> ivalue = <\/span>5<\/span>;<\/span><\/span>\n  <\/span>double<\/span> dvalue = <\/span>implicit_cast<\/span>(ivalue);<\/span><\/span>\n          \/\/ error: can't deduce T<\/span><\/span>\n  dvalue = <\/span>implicit_cast<\/span><<\/span>double<\/span>>(ivalue);<\/span><\/span>\n          \/\/ T is double; U is int<\/span><\/span>\n  <\/span>char<\/span> cvalue = <\/span>implicit_cast<\/span><<\/span>char<\/span>, <\/span>double<\/span>>(ivalue);<\/span><\/span>\n          \/\/ T is char; U is double<\/span><\/span>\n  <\/span>char<\/span> *cptr = <\/span>implicit_cast<\/span><<\/span>char<\/span> *, <\/span>int<\/span>>(ivalue);<\/span><\/span>\n          \/\/ T is char *; U is int<\/span><\/span>\n          \/\/ error can't convert int to char*<\/span><\/span>\n  <\/span><\/span>\n  <\/span>return<\/span> <\/span>0<\/span>;<\/span><\/span>\n}<\/span><\/span><\/code><\/pre><\/div>\n<\/div>\n\n\n\n
    \n
    which produces the following compile-time errors:<\/p>\n\n\n\n
    ReturnType.cpp:21:19 No matching function for call to 'implicit_cast'\n\nCandidate template ignored: couldn't infer template argument 'T'\n\nReturnType.cpp:27:9 Cannot initialize a variable of type 'char *' with an rvalue of type 'int'<\/strong>\n<\/code><\/pre>\n<\/div>\n<\/div>\n\n\n\n
    When we remove the offending statements:<\/p>\n\n\n\n
    \n
    \n
    <\/path><\/path><\/svg><\/span>
    \/\/<\/span><\/span>\n\/\/  ReturnType.cpp<\/span><\/span>\n\/\/  Template Argument Deduction<\/span><\/span>\n\/\/<\/span><\/span>\n\/\/  Created by Bryan Higgs on 10\/13\/24.<\/span><\/span>\n\/\/<\/span><\/span>\n<\/span>\n#include<\/span> <\/span><iostream><\/span><\/span>\n<\/span>\ntemplate<\/span> <<\/span>typename<\/span> <\/span>T<\/span>, <\/span>typename<\/span> <\/span>U<\/span>><\/span><\/span>\nU<\/span> <\/span>implicit_cast<\/span>(<\/span>U<\/span> <\/span>u<\/span>)<\/span><\/span>\n{<\/span><\/span>\n  <\/span>std<\/span>::cout << <\/span>"T:"<\/span> << <\/span>typeid<\/span>(T).<\/span>name<\/span>() << <\/span>" "<\/span><\/span>\n            << <\/span>"U:"<\/span> << <\/span>typeid<\/span>(U).<\/span>name<\/span>() << <\/span>std<\/span>::endl;<\/span><\/span>\n  <\/span>return<\/span> u;<\/span><\/span>\n}<\/span><\/span>\n<\/span>\nint<\/span> <\/span>main<\/span>(<\/span>int<\/span> <\/span>argc<\/span>, <\/span>const<\/span> <\/span>char<\/span> <\/span>*<\/span> <\/span>argv<\/span>[])<\/span><\/span>\n{<\/span><\/span>\n  <\/span>int<\/span> ivalue = <\/span>5<\/span>;<\/span><\/span>\n  <\/span>double<\/span> dvalue = <\/span>implicit_cast<\/span><<\/span>double<\/span>>(ivalue);<\/span><\/span>\n          \/\/ T is double; U is int<\/span><\/span>\n  <\/span>char<\/span> cvalue = <\/span>implicit_cast<\/span><<\/span>char<\/span>, <\/span>double<\/span>>(ivalue);<\/span><\/span>\n          \/\/ T is char; U is double<\/span><\/span>\n  <\/span><\/span>\n  <\/span>return<\/span> <\/span>0<\/span>;<\/span><\/span>\n}<\/span><\/span><\/code><\/pre><\/div>\n<\/div>\n\n\n\n
    \n
    the program now compiles, runs, and produces the following output:<\/p>\n\n\n\n
    T:d U:i\nT:c U:d\nProgram ended with exit code: 0<\/strong><\/code><\/pre>\n\n\n\n
    Translation:<\/p>\n\n\n\n