Template (programming)

Templates are a feature of the C++ programming language that allow functions and classes to operate with generic types. This allows a function or class to work on many different data types without being rewritten for each one.
Templates are of great utility to programmers in C++, especially when combined with multiple inheritance and operator overloading. The C++ Standard Library provides many useful functions within a framework of connected templates.
Technical overview
There are two kinds of templates: function templates and class templates.
Function templates
A function template behaves like a function that can accept arguments of many different types. In other words, a function template represents a family of functions.
Class Templates
Simple Class templates
A function template provides a specification for generating template functions, based on some parameters, which all share the same name and are treated as a unit (meaning that, for instance, the programmer just calls max with some arguments, and the appropriate instance of the template materializes).
Similarly, a class template provides a specification for generating classes based on parameters. The previous section shows an advance use of class templates to perform compile-type computation on types. A more common use for class templates, is the definition of polymorphic classes, such as containers.
For example, the C++ standard library has a list container called list, which is a template. The statement list designates or instantiates a linked-list of type int. The statement list designates or instantiates a linked-list of type string. The template has some additional parameters, which take default values if they are not specified. For example, the programmer can write a custom class that provides memory allocation services, and that class can be specified as an argument to the list template, to instantiate a list container that is tightly coupled to this custom allocator (at compile time).
A class template usually defines a set of generic functions that operate on the type specified for each instance of the class (i.e., the parameter between the angle brackets, as shown above). The compiler will generate the appropriate function code at compile-time for the parameter type that appears between the brackets.
Template specialization
The programmer may decide to implement a special version of a function (or class) for a certain type which is called template specialization. If a class template is specialized by a subset of its parameters it is called partial template specialization. If all of the parameters are specialized it is an explicit specialization or full specialization. Function templates cannot be partially specialized.
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, consider the max function again. Suppose that the programmer has a class for representing mathematical vectors called vec. This vector class has a member function called norm which returns the length of a vector. The programmer wants to be able to use the max template function over two vec objects, with the semantics that it returns the vector which has the greater norm of the two.
The regular max template does not necessarily work. It wants to compare objects using the greater-than operator:
template
typename promote::type max(const L &left, const R &right)
{
// requires "::operator > (L, R)" or "L::operator > (R)"
return left > right ? left : right;
}
One obvious way to solve the problem is to make the greater-than operator work for vec objects using their norm, so that this template is then applicable. However, here is how it can be solved with a template specialization for max:
template<>
typename promote::type max(const vec &left, const vec &right)
{
return left.norm() > right.norm() ? left : right;
}
The template specialization provides custom behavior for this combination of types; the norm member function is called on both vectors to retrieve their lengths, and it is their lengths (assumed to be some scalar numeric type) which are then compared with the greater-than operator.
Also, the previous section Class Templates demonstrates a use of template specialization over class templates to write the base rules for type promotion for two-valued arithmetic operation.
Advantages and disadvantages
Some uses of templates, such as the maximum() function, were previously fulfilled by function-like preprocessor macros. For example, the following is a C++ maximum() macro:
#define maximum(a,b) ((a) < (b) ? (b) : (a))
Both macros and templates are expanded at compile-time. Macros are always expanded inline, whereas templates are only expanded inline when the compiler deems it appropriate. When expanded inline, macro functions and template functions have no extraneous run-time overhead. However, template functions will have run-time overhead when they are not expanded inline.
Templates are considered "type-safe", that is, they require type-checking at compile-time. Hence, the compiler can determine at compile-time whether or not the type associated with a template definition can perform all of the functions required by that template definition.
By design, templates can be utilized in very complex problem spaces, whereas macros are substantially more limited.
There are fundamental drawbacks to the use of templates:
Historically, some compilers exhibited poor support for templates. So, the use of templates could decrease code portability.
Many compilers lack clear instructions when they detect a template definition error. This can increase the effort of developing templates, and has prompted the inclusion of Concepts in the next C++ standard.
Since the compiler generates additional code for each template type, indiscriminate use of templates can lead to code bloat, resulting in larger executables.
Because a template by its nature exposes its implementation, injudicious use in large systems can lead to longer build times.
Additionally, the use of the "less-than" and "greater-than" signs as delimiters is problematic for tools (such as text editors) which analyse source code syntactically. It is difficult, or maybe impossible, for such tools to determine whether a use of these tokens is as comparison operators or template delimiters. For example, this line of code:
foo (a < b, c > d) ;
may be a function call with two integer parameters, each a comparison expression. Alternatively, it could be a declaration of a constructor for class foo taking one parameter, "d", whose type is the parametrised "a < b, c >".
Generic programming features in other languages
Initially, the concept of templates was not included in some languages, such as Java 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 2.0. The generics in Ada predate C++ templates.
Although C++ templates, Java generics, and .NET generics are often considered similar, generics only mimic the basic behavior of C++ templates. Some of the advanced template features utilized by libraries such as Boost and STLSoft, and implementations of the STL itself, for template metaprogramming (explicit or partial specialization, default template arguments, template non-type arguments, template template arguments, ...) are not available with generics.
The D programming language attempts to build on C++ by creating an even more powerful template system. A significant addition is the inclusion of the static if statement, which allows conditional compilation of code based on any information known at compile time.
This function will work for any number of arguments, with the foreach iteration over the tuple of arguments expanded at compile time.
In C++ templates, the compile-time cases are performed by pattern matching over the template arguments, so the Factorial template's base cases are implemented by matching 0 and 1 rather than with an inequality test, which is unavailable: