Partial template specialization

From Wikipedia, the free encyclopedia
Jump to: navigation, search

Partial template specialization is a particular form of class template specialization. Usually used in reference to the C++ programming language, it allows the programmer to specialize only some arguments of a class template, as opposed to explicit specialization, where all the template arguments are provided.

Templates and specialization[edit]

Class templates are really meta-classes: they are partial abstract data types that provide instructions to the compiler on how to create classes with the proper data members. For example, the C++ standard containers are class templates. When a programmer uses a vector, one instantiates it with a specific data type, for example, int, string or double. Each type of vector results in a different class in the compiler's object code, each one working with a different data type.

If one knows that a class template will be used with a specific data type fairly often and this data type allows some optimizations (e.g. bit shifting with integers, as opposed to multiplying or dividing by 2), one may specialize the template by specifying another class template that is identical but by specifying the parameter types. When the compiler sees such a class template instantiated in code, it will generally choose the most specialized template definition that matches the instantiation. Therefore, an explicit specialization (one where all the template arguments are specified) will be preferred to a partial specialization if all the template arguments match.

Partial specialization[edit]

Templates can have more than one parameter type. Some older compilers allow one only to specialize either all or none of the template's parameters. Compilers that support partial specialization allow the programmer to specialize some parameters while leaving the others generic. Until recently most compilers did not support this feature well (at best) or ignored such specializations (at worst).

At least the GNU, Intel, Comeau, and Microsoft compilers fully support partial specialization of templates.


Suppose there exists a KeyValuePair class with two template parameters, as follows.

template <typename Key, typename Value>
class KeyValuePair {};

The following is an example of a class that defines an explicit (or full) template specialization of KeyValuePair by pairing integers with strings. The class type retains the same name as the original version.

template <>
class KeyValuePair<int, std::string> {};

The next is an example of partial specialization of KeyValuePair with the same name as the original version and one specialized template parameter.

template <typename Key>
class KeyValuePair<Key, std::string> {};

The next example class KeyStringPair is derived from the original KeyValuePair with a new name, and defines a partial template specialization. In contrast to the explicit specialization above, only the Value template parameter of the superclass is specialized, while the Key template parameter remains generic.

template <typename Key>
class KeyStringPair : public KeyValuePair<Key, std::string> {};

It does not matter which template parameters are specialized and which remain generic. For instance, the following is also a valid example of a partial specialization of the original KeyValuePair class.

template <typename Value>
class IntegerValuePair : public KeyValuePair<int, Value> {};


C++ templates are not limited to classes - they can also be used to define function templates. Although function templates can be fully specialized, they cannot be partially specialized, irrespective of whether they are member function templates or non-member function templates. This can be beneficial to compiler writers, but affects the flexibility and granularity of what developers can do.[1] But, function templates can be overloaded, which gives nearly the same effect as what partial function template specialization would have.[2] The following examples are provided to illustrate these points.

// legal: base function template
template <typename ReturnType, typename ArgumentType>
ReturnType Foo(ArgumentType arg);
// legal: explicit/full function template specialization
template <>
int Foo<int, char>(char arg);
// illegal: partial function template specialization of the return type
template <typename ArgumentType>
void Foo<void, ArgumentType>(ArgumentType arg);
// legal: base function template overloading the return type
template <typename ArgumentType>
void Foo(ArgumentType arg);
// legal: base function template overloading the argument type
template <typename ReturnType>
ReturnType Foo(char arg);


  1. ^ Alexandrescu, Andrei (1 February 2001). Modern C++ Design. Addison Wesley. p. 23. ISBN 0-201-70431-5. 
  2. ^ Sutter, Herb (July 2001). "Why Not Specialize Function Templates?". C/C++ Users Journal 19 (7). Retrieved 7 December 2014.