{"id":2038,"date":"2025-01-27T19:11:35","date_gmt":"2025-01-27T19:11:35","guid":{"rendered":"https:\/\/bhiggs.x10hosting.com\/PracticalCPlusPlusProgramming\/?page_id=2038"},"modified":"2025-01-27T21:14:19","modified_gmt":"2025-01-27T21:14:19","slug":"whats-the-problem","status":"publish","type":"page","link":"https:\/\/bhiggs.x10hosting.com\/PracticalCPlusPlusProgramming\/index.php\/topics\/c-details\/function-templates-2\/whats-the-problem\/","title":{"rendered":"What’s The Problem?"},"content":{"rendered":"\n

<\/span>What’s the Problem?<\/span><\/h2>\n\n\n\n

Consider the implementation of a min()<\/strong> function for int<\/strong>s:<\/p>\n\n\n\n

int min(int a, int b)\n{\n  return a < b ? a : b;\n}<\/strong><\/code><\/pre>\n\n\n\n
You can’t use the above code for double<\/strong>s, even though the algorithm is exactly the same.  Only the types change:<\/p>\n\n\n\n
int min(double a, double b)\n{\n  return a < b ? a : b;\n}<\/strong><\/code><\/pre>\n\n\n\n
So, you have to provide a different version of min()<\/strong> for every type that you want to support.<\/p>\n\n\n\n
If you want to have a min()<\/strong> for a user-defined type, then the user has to implement it;  the vendor doesn’t know all the types the user will want to implement.<\/p>\n\n\n\n
At least in C++, unlike C, you can use a single name for all these functions!<\/p>\n\n\n\n
<\/span>One Solution: Macros<\/span><\/h3>\n\n\n\n
One could use macros to solve the problem:<\/p>\n\n\n\n
#define min(a,b) (a) < (b) ? (a) : (b)<\/strong><\/code><\/pre>\n\n\n\n
Notice the care with which you have to construct this — all those parentheses!  And it still isn’t safe! <\/p>\n\n\n\n
For example, the following:<\/p>\n\n\n\n
min(10, 20);<\/strong>
<\/strong>min(25.46, 193.7);<\/strong><\/code><\/pre>\n\n\n\n
<\/strong>will work with this form, but:<\/p>\n\n\n\n
min(p++, myfunc());<\/strong><\/code><\/pre>\n\n\n\n
will not.  Why?<\/p>\n\n\n\n
\n
Macros are not safe, nor are they type-safe.<\/em><\/strong><\/p>\n<\/blockquote>\n\n\n\n
<\/span>The Real Solution…<\/span><\/h3>\n\n\n\n
We need some way of writing a function, and parameterizing<\/em> it, so that the proper definition can be used at compile time. <\/p>\n\n\n\n
In C++, these are called Function Templates<\/strong><\/em>, and are defined and used like:<\/p>\n\n\n\n
\n
\n
<\/path><\/path><\/svg><\/span>
\/\/<\/span><\/span>\n\/\/  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<\/span>\ntemplate<\/span> <<\/span>typename<\/span> <\/span>Type<\/span>><\/span><\/span>\nType<\/span> <\/span>min<\/span>(<\/span>Type<\/span> <\/span>a<\/span>, <\/span>Type<\/span> <\/span>b<\/span>)<\/span><\/span>\n{<\/span><\/span>\n  <\/span>return<\/span> a < b ? a : b;<\/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>std<\/span>::cout << <\/span>"min(10, 20) = "<\/span><\/span>\n            << <\/span>min<\/span>(<\/span>10<\/span>, <\/span>20<\/span>) << <\/span>std<\/span>::endl;<\/span><\/span>\n  <\/span>std<\/span>::cout << <\/span>"min(25.46, 193.7) = "<\/span><\/span>\n            << <\/span>min<\/span>(<\/span>25.46<\/span>, <\/span>193.7<\/span>) << <\/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\n\n\n
\n
… which produces the following output:<\/p>\n\n\n\n
min(10, 20) = 10\nmin(25.46, 193.7) = 25.46\nProgram ended with exit code: 0<\/strong><\/code><\/pre>\n<\/div>\n<\/div>\n\n\n\n
The above template definition:<\/p>\n\n\n\n
template <typename Type>\nType min(Type a, Type b)\n{\n  return a < b ? a : b;\n}<\/strong><\/code><\/pre>\n\n\n\n
specifies a family of functions<\/em> that returns the maximum of two values.<\/p>\n\n\n\n
<\/span>Function Template Instantiation<\/span><\/h3>\n\n\n\n
In order to make this program work, the compiler has to do the following for each call to min()<\/strong>:<\/p>\n\n\n\n
    \n
  1. Find the appropriate function template definition.<\/li>\n\n\n\n
  2. Construct an instantiation<\/em> of the function template, causing the appropriate real function definition to be created.<\/li>\n\n\n\n
  3. Generate the code to invoke the function.<\/li>\n<\/ol>\n\n\n\n
    In other words, the actual function definition comes into being as an automatic side-effect<\/em> of either invoking<\/em>, or taking the address of<\/em>, a template function.<\/p>\n\n\n\n
    \n
    At least, that’s how it’s supposed to be!  <\/em><\/strong><\/p>\n\n\n\n
    Historically, the use of templates is one of the most troublesome and inconsistently implemented features in C++.  Different compilers have implemented templates differently, and often have had incomplete levels of support for the C++ standard definition of templates. The situation has been improving, and by now is much better.<\/em><\/strong><\/p>\n<\/blockquote>\n\n\n\n
    For example, imagine you’re trying to implement a function that accepts an array of Type<\/strong>, and returns the minimum value contained within the array of that Type<\/strong>:<\/p>\n\n\n\n
    \n
    \n
    Thus the function template:<\/p>\n\n\n\n
    <\/path><\/path><\/svg><\/span>
    \/\/<\/span><\/span>\n\/\/  min1.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> min1_h<\/span><\/span>\n#define<\/span> min1_h<\/span><\/span>\n<\/span>\ntemplate<\/span> <<\/span>typename<\/span> <\/span>Type<\/span>><\/span><\/span>\nType<\/span> <\/span>min<\/span>(<\/span>Type<\/span> <\/span>array<\/span>[], <\/span>size_t<\/span> <\/span>size<\/span>)<\/span><\/span>\n{<\/span><\/span>\n  Type min_val = <\/span>array<\/span>[<\/span>0<\/span>];<\/span><\/span>\n  <\/span>for<\/span> (<\/span>size_t<\/span> i = <\/span>1<\/span>; i < size; i++)<\/span><\/span>\n  {<\/span><\/span>\n    <\/span>if<\/span> (<\/span>array<\/span>[i] < min_val)<\/span><\/span>\n      min_val = <\/span>array<\/span>[i];<\/span><\/span>\n  }<\/span><\/span>\n  <\/span>return<\/span> min_val;<\/span><\/span>\n}<\/span><\/span>\n<\/span>\n#endif<\/span> \/* min1_h *\/<\/span><\/span><\/code><\/pre><\/div>\n<\/div>\n\n\n\n
    \n
    When called like:<\/p>\n\n\n\n
    <\/path><\/path><\/svg><\/span>
    \/\/<\/span><\/span>\n\/\/  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>"min1.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> array[] = { <\/span>12<\/span>, <\/span>45<\/span>, <\/span>3<\/span>, <\/span>19<\/span>, <\/span>157<\/span> };<\/span><\/span>\n  <\/span>std<\/span>::cout << <\/span>"Minimum value = "<\/span><\/span>\n            << <\/span>min<\/span>( array, <\/span>sizeof<\/span>(array)\/<\/span>sizeof<\/span>(<\/span>int<\/span>) )<\/span><\/span>\n            << <\/span>std<\/span>::endl;<\/span><\/span>\n<\/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
    will be instantiated as follows:<\/p>\n\n\n\n
    <\/path><\/path><\/svg><\/span>
    int<\/span> <\/span>min<\/span>(<\/span>Type<\/span> <\/span>array<\/span>[], <\/span>size_t<\/span> <\/span>size<\/span>)<\/span><\/span>\n{<\/span><\/span>\n  <\/span>int<\/span> min_val = <\/span>array<\/span>[<\/span>0<\/span>];<\/span><\/span>\n  <\/span>for<\/span> (<\/span>size_t<\/span> i = <\/span>1<\/span>; i < size; i++)<\/span><\/span>\n  {<\/span><\/span>\n    <\/span>if<\/span> (<\/span>array<\/span>[i] < min_val)<\/span><\/span>\n      min_val = <\/span>array<\/span>[i];<\/span><\/span>\n  }<\/span><\/span>\n  <\/span>return<\/span> min_val;<\/span><\/span>\n}<\/span><\/span><\/code><\/pre><\/div>\n<\/div>\n\n\n\n
    \n
    … and produces the following output:<\/p>\n\n\n\n
    Minimum value = 3\nProgram ended with exit code: 0<\/strong><\/code><\/pre>\n<\/div>\n<\/div>\n\n\n\n
    \n
    Note that the compiler will only allocate space for functions actually called and therefore instantiated. It will not allocate space for functions that are not called by the program.<\/p>\n<\/blockquote>\n\n\n\n
    <\/span>Template Parameters<\/span><\/h3>\n\n\n\n
    The first line of a template function:<\/p>\n\n\n\n
    template < <\/strong>comma-separated-list-of parameters<\/em> ><\/strong><\/code><\/pre>\n\n\n\n
    specifies a list of template parameters<\/em>. In the above max<\/code><\/strong> example, the list consists of a single parameter:<\/p>\n\n\n\n
    typename Type<\/strong><\/code><\/pre>\n\n\n\n
    which indicates that Type<\/code><\/strong> (it’s just a name) is a yet-to-be-determined type<\/em> that is referred to in the body of the template.<\/p>\n\n\n\n
    \n
    Historically, when templates were introduced, C++ used the keyword class<\/strong>, as in:<\/p>\n\n\n\n
    template <class T><\/strong><\/code><\/pre>\n\n\n\n
    The use of the keyword class<\/strong> is potentially confusing. It does not indicate that Type<\/strong> is actually a class<\/em>; it simply is the original way that C++ used to indicate that Type<\/strong> is a type<\/em>. Since then, C++ has added a new keyword, typename<\/strong>, which was not present when the first template implementations became available. So, now, we prefer to use the following instead:<\/p>\n\n\n\n
    typename Type<\/strong><\/code><\/pre>\n\n\n\n
    The use of the keyword class<\/strong> still exists in a lot of code. Its use is simply historical, and should be viewed as equivalent to using typename<\/strong>. The two keywords are totally equivalent in this context. typename<\/strong> is now preferred.<\/p>\n<\/blockquote>\n\n\n\n
    The determination of the actual type of Type<\/strong> is done when the function template is instantiated as a result of a call to the template function, such as:<\/p>\n\n\n\n
    min(10, 20)<\/strong><\/code><\/pre>\n\n\n\n
    In this case, the compiler determines from the function arguments that Type<\/strong> is of type int<\/strong>.<\/p>\n\n\n\n
    A function call:<\/p>\n\n\n\n
    min(10.6, 0.7)<\/strong><\/code><\/pre>\n\n\n\n
    will result in a Type<\/strong> of type double<\/strong> for this instantiation.<\/p>\n\n\n\n
    <\/span>The Template Parameter List<\/span><\/h4>\n\n\n\n
    A template parameter list <\/em>consists of a comma-separated list of template parameters<\/em> enclosed within angle brackets (<<\/strong> and ><\/strong>):<\/p>\n\n\n\n
    template <typename Type, int size><\/strong><\/code><\/pre>\n\n\n\n
    You may have as many template parameters as you like.<\/p>\n\n\n\n
    There are two kinds of template parameters:<\/p>\n\n\n\n