Templates are a feature of the
C++ programming language that allows
functions and
classes to operate with
generic types. This allows a function or class
declaration to reference via a generic
variable another different class (built-in or newly declared
data type
In computer science and computer programming, a data type (or simply type) is a collection or grouping of data values, usually specified by a set of possible values, a set of allowed operations on these values, and/or a representation of these ...
) without creating full declaration for each of these different classes.
In plain terms, a templated class or function would be the equivalent of (before "compiling") copying and pasting the templated block of code where it is used, and then replacing the template parameter with the actual one. For this reason, classes employing templated methods place the implementation in the headers (*.h files) as no symbol could be compiled without knowing the type beforehand.
The
C++ Standard Library
The C standard library, sometimes referred to as libc, is the standard library for the C programming language, as specified in the ISO C standard.ISO/ IEC (2018). '' ISO/IEC 9899:2018(E): Programming Languages - C §7'' Starting from the origina ...
provides many useful functions within a framework of connected templates.
Major inspirations for C++ templates were the parameterized modules provided by the language
CLU and the generics provided by
Ada.
Technical overview
There are three kinds of templates: ''function templates'', ''class templates'' and, since
C++14, ''variable templates''. Since
C++11
C++11 is a version of a joint technical standard, ISO/IEC 14882, by the International Organization for Standardization (ISO) and International Electrotechnical Commission (IEC), for the C++ programming language. C++11 replaced the prior vers ...
, templates may be either
variadic or non-variadic; in earlier versions of C++ they are always non-variadic.
C++ Templates are
Turing complete.
Function templates
A ''function template'' behaves like a function except that the template can have arguments of many different types (see example). In other words, a function template represents a family of functions. The format for declaring function templates with type parameters is:
template declaration;
template declaration;
Both expressions have the same meaning and behave in exactly the same way. The latter form was introduced to avoid confusion, since a type parameter need not be a class until C++20. (It can be a basic type such as
int
or
double
.)
For example, the C++ Standard Library contains the function template
max(x, y)
which returns the larger of
x
and
y
. That function template could be defined like this:
template
const T& max(const T& a, const T& b)
This single function definition works with many data types. Specifically, it works with all data types for which < (the less-than operator) is defined and returns a value with a type convertible to
bool
. The usage of a function template saves space in the source code file in addition to limiting changes to one function description and making the code easier to read.
An instantiated function template usually produces the same object code, though, compared to writing separate functions for all the different data types used in a specific program. For example, if a program uses both an
int
and a
double
version of the
max()
function template above, the
compiler
In computing, a compiler is a computer program that Translator (computing), translates computer code written in one programming language (the ''source'' language) into another language (the ''target'' language). The name "compiler" is primaril ...
will create an object code version of
max()
that operates on
int
arguments and another object code version that operates on
double
arguments. The compiler output will be identical to what would have been produced if the source code had contained two separate non-templated versions of
max()
, one written to handle
int
and one written to handle
double
.
Here is how the function template could be used:
#include
int main()
In the first two cases, the template argument
T
is automatically deduced by the compiler to be
int
and
double
, respectively. In the third case automatic deduction of
max(3, 7.0)
would fail because the type of the parameters must in general match the template arguments exactly. Therefore, we explicitly instantiate the
double
version with
max()
.
This function template can be instantiated with any
copy-constructible type for which the expression
y < x
is valid. For user-defined types, this implies that the less-than operator (
<
) must be
overloaded in the type.
Abbreviated function templates
Since
C++20, using
auto
or
Concept
A concept is an abstract idea that serves as a foundation for more concrete principles, thoughts, and beliefs.
Concepts play an important role in all aspects of cognition. As such, concepts are studied within such disciplines as linguistics, ...
auto
in any of the parameters of a
function declaration, that declaration becomes an ''abbreviated function template'' declaration. Such a declaration declares a function template and one invented template parameter for each placeholder is appended to the template parameter list:
void f1(auto); // same as template void f1(T)
void f2(C1 auto); // same as template void f2(T), if C1 is a concept
void f3(C2 auto...); // same as template void f3(Ts...), if C2 is a concept
void f4(C2 auto, ...); // same as template void f4(T...), if C2 is a concept
void f5(const C3 auto*, C4 auto&); // same as template void f5(const T*, U&);
Class templates
A class template provides a specification for generating classes based on parameters. Class templates are generally used to implement
containers
A container is any receptacle or enclosure for holding a product used in storage, packaging, and transportation, including shipping.
Things kept inside of a container are protected on several sides by being inside of its structure. The term ...
. A class template is instantiated by passing a given set of types to it as template arguments.
The C++ Standard Library contains many class templates, in particular the containers adapted from the
Standard Template Library, such as
vector
Vector most often refers to:
* Euclidean vector, a quantity with a magnitude and a direction
* Disease vector, an agent that carries and transmits an infectious pathogen into another living organism
Vector may also refer to:
Mathematics a ...
.
Variable templates
In C++14, templates can be also used for variables, as in the following example:
template
constexpr T pi = T; // (Almost) from std::numbers::pi
Non-type template parameters
Although templating on types, as in the examples above, is the most common form of templating in C++, it is also possible to template on values. Thus, for example, a class declared with
template
class MyClass;
can be instantiated with a specific
int
.
As a real-world example, the
standard library
In computer programming, a standard library is the library (computing), library made available across Programming language implementation, implementations of a programming language. Often, a standard library is specified by its associated program ...
fixed-size
array type
std::array
is templated on both a type (representing the type of object that the array holds) and a number which is of type
std::size_t
(representing the number of elements the array holds).
std::array
can be declared as follows:
template struct array;
and an array of six
char
s might be declared:
array myArray;
Template specialization
When a function or class is instantiated from a template, a
specialization of that template is created by the compiler for the set of arguments used, and the specialization is referred to as being a generated specialization.
Explicit template specialization
Sometimes, the programmer may decide to implement a special version of a function (or class) for a given set of template type arguments which is called an explicit specialization. In this way certain template types can have a specialized implementation that is optimized for the type or a more meaningful implementation than the generic implementation.
* If a class template is specialized by a subset of its parameters it is called
partial template specialization (function templates cannot be partially specialized).
* If all of the parameters are specialized it is a ''full specialization''.
Explicit specialization is used when the behavior of a function or class for particular choices of the template parameters must deviate from the generic behavior: that is, from the code generated by the main template, or templates. For example, the template definition below defines a specific implementation of
max()
for arguments of type
const char*
:
#include
template<>
const char* max(const char* a, const char* b)
Variadic templates
C++11 introduced
variadic templates, which can take a variable number of arguments in a manner somewhat similar to
variadic function
In mathematics and in computer programming, a variadic function is a function of indefinite arity, i.e., one which accepts a variable number of arguments. Support for variadic functions differs widely among programming languages.
The term ''var ...
s such as
std::printf
.
Template aliases
C++11 introduced template aliases, which act like parameterized
typedef
typedef is a reserved keyword in the programming languages C, C++, and Objective-C. It is used to create an additional name (''alias'') for another data type, but does not create a new type, except in the obscure case of a qualified typedef of ...
s.
The following code shows the definition of a template alias
StrMap
. This allows, for example,
StrMap
to be used as shorthand for
std::unordered_map
.
template using StrMap = std::unordered_map;
Generic programming features in other languages
Initially, the concept of templates was not included in some languages, such as
Java
Java is one of the Greater Sunda Islands in Indonesia. It is bordered by the Indian Ocean to the south and the Java Sea (a part of Pacific Ocean) to the north. With a population of 156.9 million people (including Madura) in mid 2024, proje ...
and
C# 1.0.
Java's adoption of generics mimics the behavior of templates, but is technically different. C# added generics (parameterized types) in
.NET
The .NET platform (pronounced as "''dot net"'') is a free and open-source, managed code, managed computer software framework for Microsoft Windows, Windows, Linux, and macOS operating systems. The project is mainly developed by Microsoft emplo ...
2.0. The generics in Ada predate C++ templates.
Although C++ templates, Java generics, and
.NET
The .NET platform (pronounced as "''dot net"'') is a free and open-source, managed code, managed computer software framework for Microsoft Windows, Windows, Linux, and macOS operating systems. The project is mainly developed by Microsoft emplo ...
generics are often considered similar, generics only mimic the basic behavior of templates.
Some of the advanced template features utilized by libraries such as
Boost and
STLSoft, and implementations of the STL, for
template metaprogramming
Template metaprogramming (TMP) is a metaprogramming technique in which templates are used by a compiler to generate temporary source code, which is merged by the compiler with the rest of the source code and then compiled. The output of these te ...
(explicit or partial specialization, default template arguments, template non-type arguments, template template arguments, ...) are unavailable with generics.
In C++ templates, compile-time cases were historically performed by pattern matching over the template arguments. For example, the template base class in the Factorial example below is implemented by matching 0 rather than with an inequality test, which was previously unavailable. However, the arrival in C++11 of standard library features such as std::conditional has provided another, more flexible way to handle conditional template instantiation.
// Induction
template
struct Factorial ;
// Base case via template specialization:
template<> struct Factorial<0> ;
With these definitions, one can compute, say 6! at compile time using the expression
Factorial<6>::value
.
Alternatively,
constexpr
in C++11 /
if constexpr
in C++17 can be used to calculate such values directly using a function at compile-time:
template
unsigned factorial()
Because of this, template meta-programming is now mostly used to do operations on types.
See also
*
Template metaprogramming
Template metaprogramming (TMP) is a metaprogramming technique in which templates are used by a compiler to generate temporary source code, which is merged by the compiler with the rest of the source code and then compiled. The output of these te ...
*
Metaprogramming
Metaprogramming is a computer programming technique in which computer programs have the ability to treat other programs as their data. It means that a program can be designed to read, generate, analyse, or transform other programs, and even modi ...
*
Monomorphization
*
Generic programming
Generic programming is a style of computer programming in which algorithms are written in terms of data types ''to-be-specified-later'' that are then ''instantiated'' when needed for specific types provided as parameters. This approach, pioneer ...
*
Header-only
*
Substitution failure is not an error
*
Curiously recurring template pattern
The curiously recurring template pattern (CRTP) is an idiom, originally in C++, in which a class X derives from a class template instantiation using X itself as a template argument. More generally it is known as F-bound polymorphism, and it is a ...
*
List of C++ template libraries
References
External links
Demonstration of the Turing-completeness of C++ templates(
Lambda calculus
In mathematical logic, the lambda calculus (also written as ''λ''-calculus) is a formal system for expressing computability, computation based on function Abstraction (computer science), abstraction and function application, application using var ...
implementation)
{{DEFAULTSORT:Template (Programming)
Generic programming
Metaprogramming
C++
Articles with example C++ code