Scribd
Upload
24 views3 pages

Function Templates: // Overloaded Functions

This document discusses C++ function templates. Function templates allow a function to be defined generically for multiple data types using template parameters. The key points are: 1) A function template is defined using the template keyword followed by template parameters in angle brackets. These parameters can be generic types used within the function body. 2) Instantiating a function template applies the template to a specific type by specifying the type in angle brackets when calling the function. 3) This allows a single function definition to work for multiple types like int and double without code duplication. The compiler generates a separate function for each type used.

Uploaded by

icul1
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as DOCX, PDF, TXT or read online on Scribd
24 views3 pages

Function Templates: // Overloaded Functions

This document discusses C++ function templates. Function templates allow a function to be defined generically for multiple data types using template parameters. The key points are: 1) A function template is defined using the template keyword followed by template parameters in angle brackets. These parameters can be generic types used within the function body. 2) Instantiating a function template applies the template to a specific type by specifying the type in angle brackets when calling the function. 3) This allows a single function definition to work for multiple types like int and double without code duplication. The compiler generates a separate function for each type used.

Uploaded by

icul1
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as DOCX, PDF, TXT or read online on Scribd
You are on page 1/ 3

Function templates

Overloaded functions may have the same definition. For example:


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
// overloaded functions
#include <iostream>
using namespace std;

int sum (int a, int b)
{
return a+b;
}

double sum (double a, double b)
{
return a+b;
}

int main ()
{
cout << sum (10,20) << '\n';
cout << sum (1.0,1.5) << '\n'
return 0;
}
30
2.5


Here, sum is overloaded with different parameter types, but with the exact same body.

The function sum could be overloaded for a lot of types, and it could make sense for all of them
to have the same body. For cases such as this, C++ has the ability to define functions with
generic types, known as function templates. Defining a function template follows the same
syntax than a regular function, except that it is preceded by the template keyword and a series
of template parameters enclosed in angle-brackets <>:

template <template-parameters> function-declaration
The template parameters are a series of parameters separated by commas. These parameters can
be generic template types by specifying either the class or typename keyword followed by an
identifier. This identifier can then be used in the function declaration as if it was a regular type.
For example, a generic sum function could be defined as:
1
2
3
4
5
template <class SomeType>
SomeType sum (SomeType a, SomeType b)
{
return a+b;
}


It makes no difference whether the generic type is specified with keyword class or
keyword typename in the template argument list (they are 100% synonyms in template
declarations).

In the code above, declaring SomeType (a generic type within the template parameters enclosed
in angle-brackets) allows SomeType to be used anywhere in the function definition, just as any
other type; it can be used as the type for parameters, as return type, or to declare new variables of
this type. In all cases, it represents a generic type that will be determined on the moment the
template is instantiated.

Instantiating a template is applying the template to create a function using particular types or
values for its template parameters. This is done by calling the function template, with the same
syntax as calling a regular function, but specifying the template arguments enclosed in angle
brackets:

name <template-arguments> (function-arguments)
For example, the sum function template defined above can be called with:
x = sum<int>(10,20);


The function sum<int> is just one of the possible instantiations of function template sum. In this
case, by using intas template argument in the call, the compiler automatically instantiates a
version of sum where each occurrence ofSomeType is replaced by int, as if it was defined as:
1
2
3
4
int sum (int a, int b)
{
return a+b;
}


Let's see an actual example:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
// function template
#include <iostream>
using namespace std;

template <class T>
T sum (T a, T b)
{
T result;
result = a + b;
return result;
}

int main () {
int i=5, j=6, k;
double f=2.0, g=0.5, h;
k=sum<int>(i,j);
h=sum<double>(f,g);
cout << k << '\n';
cout << h << '\n';
11
2.5
20
21
return 0;
}

You might also like