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.
maximum(x, y)which returns either x or y, whichever is larger.
maximum()could be defined like this:
Notice that the user can use the same function for many different data types.
Template functions can be defined for arguments of any type for which a concrete function can be created by the compiler. If the data type is a class, the
< operator must be defined for this example template function to work.
Template functions, which support both primitive and class types, also allow the user to utilize standard template libraries such as STL. Template libraries can leverage template functions by allowing the user of the library to define types and operators for those types.
The Standard Template Library contains
complex class, which is used to represent complex numbers. However, the
complex class does not define the
< operator because there is no strict ordering for complex numbers. Therefore,
maximum(x, y) will fail with a compile error if x and y are
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 template function (or class) is specialized by a subset of its parameters then it is called partial template specialization.
For example the programmer may want to apply an ordering on
complex numbers based on their distance from (0,0):
A class template extends the aforementioned template function concept to classes. Class templates are often used to define the methods and sub-types of generic containers. For example, the STL for C++ has a linked list container called
list. The statement
list<int> designates or instantiates a linked-list of type
int. The statement
list<string> designates or instantiates a linked-list of type
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.
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, where as macros are substantially more limited.
There are three primary drawbacks to the use of templates:
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:
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>".
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. For example:
Also note that the
!() delimiters are used rather than the
<> delimiters. This prevents ambiguity in the parsing of templates.
Other significant features include typesafe variadic template functions.
This function will work for any number of arguments, with the
foreach iteration over the tuple of arguments expanded at compile time.