7.6 Partial Specialization

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);
  }
};