C++ for Scientists - Technische Universität Dresden

4.6. TEMPLATE SPECIALIZATION 105
Base inline power(const Base& x, int y);
template
double inline power(double x, const Exponent& y);
The compiler will find all overloads that match the argument combination and select the most
specific. For instance, power(3.0, 2u) will match for the first and third overload where the latter
is more specific. 11 To put it to higher math: 12 type specificity is a partial order that forms a
lattice and the compiler picks the maximum of the available overloads. However, you do not
need to dive deeply into algebra to see which type or type combination is more specific.
If we call power(3.0, 2) with the previous overloads all three matches. However, this time we
cannot determine the most specific overload. The compiler will tell us that the call is ambiguous
and show us overload 2 and 3 as candidates. As we implemented the overloads consisently and
with optimal performance we might be glad with either choice but the compiler will not choose.
To disambiguate the overloads we must add:
double inline power(double x, int y);
The lattice people from the previous paragraph will think “Of course, we were missing the join
in the specificity order.” Again, one can understand C ++ without studying lattices.
4.6.3 Partial Specialization
If you implemented template classes you will run sooner or later in the situation where you like
to specialize a template class for another template class. Suppose we have a templated complex
class:
template
class complex;
Assume further that we had some really boosting algorithmic specialization for complex vectors
13 that safes tremendous compute time. Then we start specializing our vector class:
template
class vector;
template
class vector; // again ??? :−/
template
class vector; // how many more ??? :−P
Apparently, this lacks elegance to reimplement the specialization for all possible and impossible
instantiations of complex. Much worse, it destroys our ideal of universal applicability because
the complex class is intended to support user-defined types as Real but the specialization of the
vector class will be ignored for those types.
The solution to the implementation redundancy and the ignorance of new types is ‘Partial
Specialization’. We specialize our vector class for all complex instantiations:
11 TODO: Exercises for which type is more specific than which.
12 For those who like higher mathematics. And only for those.
13 TODO: Anyone a good example?