You can choose to specialize only some of the parameters of a class template. This is known as partial specialization. Note that function templates cannot be partially specialized; use overloading to achieve the same effect.
A partial specialization is declared with a template header that
contains one or more template parameters. (With no template parameters,
it is a total specialization, not a partial specialization; see the
previous section for details.) The class declaration that follows the
template header must supply an argument for each parameter of the
primary template (or rely on default arguments), and the arguments can
depend on the template parameters of the partial specialization. For
example, suppose you have a simple pair
class, similar to the one in the standard
library, but you want to allow one member of the pair
to be void
. In this case, an object can be made
smaller and store only one item:
template<typename T, typename U> struct pair { T first; U second; }; template<typename X> struct pair<X, void> { X first; };
The partial specialization of a class is a distinct template and must provide a complete class definition. You cannot partially specialize a member of a class template, only the entire class template.
Example 7-9 shows
partial specializations of the type_traits
template from Example 7-8. The first partial
specialization applies to all pointer types. It sets the is_pointer
member to 1
, for example. The second partial
specialization applies to all const
types. It sets most members to their values obtained from the
non-const
template instance. Thus,
type_traits<const
int*>::base_type
is plain int
.
Example 7-9. Partially specializing a class template
// Specialize for all pointer types.template<typename T> struct type_traits<T*>
{ typedef T base_type; enum { is_fundamental = type_traits<T>::is_fundamental }; enum { is_integer = 0 }; enum { is_float = 0 }; enum { is_pointer = 1 }; enum { is_reference = 0 }; static std::string to_string(const T& x) { std::ostringstream out; out << x; return out.str( ); } }; // Specialize for const types, so base_type refers to the non-const type.template<typename T> struct type_traits<const T>
{ typedef T base_type; typedef type_traits<base_type> base_type_traits; enum { is_fundamental = base_type_traits::is_fundamental }; enum { is_integer = base_type_traits::is_integer }; enum { is_float = base_type_traits::is_float }; enum { is_pointer = base_type_traits::is_pointer }; enum { is_reference = base_type_traits::is_reference }; static std::string to_string(const base_type& x) { return type_traits<base_type>::to_string(x); } };