One of the great features of modern C++ is templates. A template is a simple and a very powerful statement in C++ which defines the operations of a class or function and lets the user apply the same template on different types in those operations. In this post we will explain function templates in C++ which can be used by a professional C++ Compiler and IDE with C++ examples from this article.
Table of Contents
What is a template in C++?
A template is a very powerful statement in C++ which simply defines the operations of a class, a function, an alias or a variable and lets the user apply the same template on different data types in those template operations. Templates are similar to macros in C++ except the compiler checks the types used before the template is expanded.
How does a template in C++ work?
For example, here is a function template that adds two a and b parameters in T type,
|
1 2 3 4 5 6 7 |
template <class T> T add (T a, T b) { return a+b; } |
for example if a and b are int variables, this template can be used as below
|
1 2 3 |
int i = add <int> (a, b); |
and in the next lines same template can be used for the x and y float variables as below too,
|
1 2 3 |
float f = add <float> (x, y); |
Templates are powerful entity that can be parameterized by one or more template parameters. These parameters can be type template parameters, non-type template parameters, and template template parameters.
What are function templates in C++?
A Template Function may have multiple template parameter types, and the function can still use regular non-templated types.
In a previous post about Function Overloading, we had two add() functions working with integer and float numbers, in that example we can say add() function is overloaded with int and float parameter types, and with the same body.
This add() function can 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++ can define functions with generic types, known as Function Templates. Defining a function template follows the same syntax as a regular function, except that it is preceded by the template keyword and a series of template parameters enclosed with < and > angle brackets.
Here is the syntax of a function template,
|
1 2 3 |
template < parameter_list > requires_clause(optional) declaration |
Consider a function max(x, y) that returns the larger of its two arguments. x and y can be of any type that has the ability to be ordered. But, since C++ is a strongly typed language, it expects the types of the parameters x and y to be declared at compile time. Without using templates, many overloaded versions of max are required, one for each data type to be supported even though the code for each version is essentially identical. Each version compares the arguments and returns the larger.
One way around this problem is to use a macro:
|
1 2 3 |
#define max(x,y) ((x > y) ? x : y) |
The template parameters are a series of parameters separated by commas. These parameters can be generic template types by specifying either the class or type name keyword followed by an identifier. This identifier can then be used in the function declaration as if it was a regular type. For example, in general usage, our previous add() function could be defined as,
|
1 2 3 4 5 6 7 |
template <class T> T add (T a, T b) { return a+b; } |
Is there a full example of function templates in C++?
Templates are a powerful and versatile feature because of variable type can be defined during usage. Template functions may have multiple template parameters, and the function can still use regular non-templated types. Here is the full example how to use these template functions,
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 |
#include <iostream> template <class TempType> TempType add (TempType a, TempType b) { TempType result; result = a + b; return result; } int main() { int a = 500, b = 300, c; float x = 2.0, y = 0.5, z; c = add <int> (a, b); z = add <float> (x, y); std::cout << c << '\n'; std::cout << z << '\n'; getchar(); return 0; } |
What are non-type template arguments in function templates in C++?
In some cases, the template arguments may include expressions of a particular type instead of being introduced by class or type name,
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 |
#include <iostream> template <class TempType, int b> TempType add (TempType a) { return a + b; } int main() { std::cout << add<int,9>(100) << '\n'; std::cout << add<int,8>(100) << '\n'; getchar(); return 0; } |
Here, the second parameter of this add() function template is of type int. It just looks like a regular function parameter, and can actually be used just like one.
The symbol vector must always be accompanied by a data type in angle brackets. It cannot appear alone, except in some cases in the original template definition.
C++ Builder is the easiest and fastest C and C++ IDE for building simple or professional applications on the Windows, MacOS, iOS & Android operating systems. It is also easy for beginners to learn with its wide range of samples, tutorials, help files, and LSP support for code. RAD Studio’s C++ Builder version comes with the award-winning VCL framework for high-performance native Windows apps and the powerful FireMonkey (FMX) framework for cross-platform UIs.
There is a free C++ Builder Community Edition for students, beginners, and startups; it can be downloaded from here. For professional developers, there are Professional, Architect, or Enterprise versions of C++ Builder and there is a trial version you can download from here.
Design. Code. Compile. Deploy.
Start Free Trial
Free C++Builder Community Edition
