C++ for Scientists - Technische Universität Dresden

4.6. TEMPLATE SPECIALIZATION 107
template
T inline abs(const T& x)
{
return x < T(0) ? −x : x;
}
template // Do not specialize functions like this either
T inline abs(const std::complex& x)
{
return sqrt(real(x)∗real(x) + imag(x)∗imag(x));
}
This works significantly better than the explicit specialization but even this form of specialization
fails sometimes in the sense that a template function is selected which is not the most
specific. 15 A mean aspect of this implicit specialization is that it seems to work properly with
few specializations and when a software project grows eventually it goes wrong. Since the
developers have seen the specialization working before, they might not expect it and the unintended
function selection might remain unobserved while corrupting results or at least wasting
resources. It is also possible that the specialization behavior varies from compiler to compiler. 16
The only conclusion from this is to not specializing function templates! It introduces an
unnecessary fragility into our software. Instead we introduce an additional class (called functor
§ 4.8) with an operator(). Template classes are properly specialized on all compilers 17 both
partially and completely.
In our abs example we start with the function itself and a forward declaration of the template
class:
template struct abs functor;
template
typename abs functor::result type
inline abs(const T& x)
{
abs functor functor object;
return functor object(x);
}
Alternatively to the forward declaration we could have declared the class directly. The return
type of our function refers to a typedef or (as correct term in generic programming) to a
‘Associated Type’ of abs functor. Already for complex numbers we do not return the argument
type itself but its associated type value type. Using an associated type here gives us all possible
flexibility for further specialization. For instance, the magnitude of a vector could be the sum
or maximum of the elements’ magnitudes or a vector with the magnitudes of each element.
Evidently the functor classes must define a result type to be called.
Inside the function, we instantiate the functor class with the argument type: abs functor
and create an object of this type. Then we call the object’s application operator. As we do not
15 TODO: Good example.
16 TODO: Ask a compiler expert about this.
17 Several years ago many compilers failed in partial specialization, e.g. VS 2003, but today all major compiler
handle this properly. If you nevertheless experience problems with this feature in some compiler take your hands
off of it, most likely you will encounter further problems. Even the CUDA compiler that is far from being
standard-compliant supports partial specialization.