C++ for Scientists - Technische Universität Dresden

136 CHAPTER 5. META-PROGRAMMING
double d1= 3., d2= 4.;
std::cout ≪ ”min magnitude(d1, d2) = ” ≪ min magnitude(d1, d2) ≪ ’\n’;
If we call this function with two complex values:
std::complex c1(3.), c2(4.);
std::cout ≪ ”min magnitude(c1, c2) = ” ≪ min magnitude(c1, c2) ≪ ’\n’;
we will see the error message
no match for ≫operator< ≪in ≫ax < a≪
The problem is that abs returns in this case double values which provides the comparison operator
but we store them as complex values in the temporaries.
The careful reader might think we do we store them at all, if we compared the magnitudes
directly we might safe memory and we could compare them as they are. This absolutely true
and this is how we would implement the function normally. However, there are situations where
one need a temporary, e.g., when computing the value with the minimal magnitude in a vector.
For the sake of simplicity we just look at two values. With the new standard we can also handle
the issue easily with auto types like:
template
T inline min magnitude(const T& x, const T& y)
{
using std::abs;
auto ax= abs(x), ay= abs(y);
return ax < ay ? x : y;
}
To make a long story short, sometimes we need to know explicitly the result type of an expression
or a type information in general. Just think of a member variable of a template class: we must
know the type of the member in the definition of the class.
This leads us to ‘type traits’. Type traits meta-functions that provide an information about a
type.
In the example here we search for a given type an appropriate type for its magnitude. We can
provide such type information by template specialization:
template
struct Magnitude {};
template
struct Magnitude
{
typedef int type;
};
template
struct Magnitude
{
typedef float type;
};
template