Letâ€™s have a look at this small function:

```
template<typename T>
T mix(T a, T b, T r)
{
return r * a + (1 - r) * b;
}// This struct declares a type identical to T if and only if T is
// a float-like type. We are going to specialize it only for the
// valid types. For the other types, the missing type declaration
// in the struct will trigger a substitution failure.
template<typename T>
struct only_if_float_like;
template<>
struct only_if_float_like<float>
{
typedef float type;
};
template<>
struct only_if_float_like<double>
{
typedef double type;
};
template<typename T>
typename only_if_float_like<T>::type mix(T a, T b, T r)
{
return r * a + (1 - r) * b;
}
void test()
{
// float and double are handled as expected.
printf("%f' n", mix(1.f, 3.f, 0.5f));
printf("%f' n", mix(1.d, 3.d, 0.5d));
// Using integers triggers an error, we can say that it fails successfully!
// printf("%d' n", mix(1, 3, 2));
}
```

This is a quite basic function that just
combine two values with a weighted sum. Its implementation tells us
that r should probably be in
[0,1], but most
importantly, the computation makes sense only if T is a float-like
type. If we want to prevent the compiler or the programmer to call
this function with an incompatible type, we can add some
SFINAE^{15}, for example by introducing a type deduced
from T that would not be defined if T is not a float-like type. In
C++98 the implementation could have been similar to:

Aside from the fact that long double is not handled, does it work as expected?

Typing custom type like only_if_float_like for every use case is repetitive, so we would certainly end up splitting it into two types, that could be used like only_if<is_float_like<T>::value, T>::type.

<type_traits>

Lucky us, C++11 greatly simplify this work by introducing the required types, in the form of std::enable_if and std::is_floating_point_type. Using these types the whole implementation is reduced to the following:

```
#include <type_traits>
template<typename T>
typename std::enable_if<std::is_floating_point<T>::value, T>::type
mix(T a, T b, T r)
{
return r * a + (1 - r) * b;
}
```

There are many other predicates and operations added in <type_traits> in C++11, that can greatly help for metaprogramming. I can only suggest to have a look at them on a nice online reference.

^{15}Substitution Failure Is Not An Error, is a
principle in template instantiations according to which the
compiler must not emit an error if it fails to instantiate a template. Instead it should try
another template candidate. This feature is often used and abused
to provide multiple implementation behind the same function
signature.