In the previous section class template specializations were introduced.  In
this section we'll introduce a variant of this specialization, both in
number and type of template parameters that are specialized.  em(Partial
specializations) may be defined for class templates having
        hi(partial specialization)
        hi(class template: partial specialization)
    multiple template parameters. 

Function templates cannot be partially specialized: there is no need for
        hi(function template: partial specialization)
    that, as a `partially specialized function template' merely is a function
template that is tailored to particular types of some of its parameters. Since
function templates can be overloaded, `partially specializing' a function
template simply means that overloads have to be defined for those specialized
parameter types.

With partial specializations a subset (any subset) of template type parameters
are given specific values. It is also possible to use a class template partial
specialization when the intent is to specialize the class template, but to
parameterize the data type that is processed by the specialization.

To start our discussion with an example of the latter use of a partial class
template specialization consider the class tt(CirQue<vector<int>>)
developed in the previous section. When designing tt(CirQue<vector<int>>)
you may have asked yourself how many specializations you'd have to
implement. One for tt(vector<int>), one for tt(vector<string>), one for
tt(vector<double>)?  As long as the data types handled by the tt(vector) used
by the class tt(CirQue<vector<...>>) behaves like an tt(int) (i.e., is a
value-type of class) the answer is: zero. Instead of defining full
specializations for each new data type the data type itself can be
parameterized, resulting in a partial specialization:
        verb(
    template <typename Data>
    class CirQue<std::vector<Data>>
    {
        ...
    };
        )
    The above class is a specialization as a template argument list is
appended to the tt(CirQue) class name. But as the class template itself has a
non-empty template parameter list it is in fact recognized as a partial
specialization. There is one characteristic that distinguishes the
implementation (subsequent to the class template's interface) of a class
template member function of a partial specialization from the implementation
of a member function of a full specialization. Implementations of partially
specialized class template member functions receive a template header. No
template headers are used when implementing fully specialized class template
members.

Implementing the partial specialization for tt(CirQue) is not difficult and is
left as an exercise for the reader (hints: simply change tt(int) into tt(Data)
in the tt(CirQue<vector<int>>) specialization of the previous section).
Remember to prefix the type tt(iterator) by tt(typename) (as in tt(typedef
typename DataVect::iterator iterator)) (as discussed in section
ref(DISTINGUISH)).

In the next subsections we'll concentrate on specializing class template
non-type template parameters. These partial specializations are now
illustrated using some simple concepts defined in matrix algebra, a branch of
linear algebra.
