As reading the C++ template metaprogramming, I learn the famous saying in software engineering again. How to understand this remark in the context of C++ template metaprogramming?

 What we have to mention is the type trait skill, I‘d like to reference the demo in the book:

template <class ForwardIterator1, class ForwardIterator2>    void iter_swap(ForwardIterator1 i1, ForwardIterator2 i2)    {        typename                      // (see Language Note)          ForwardIterator1::value_type tmp = *i1;        *i1 = *i2;        *i2 = tmp;    }

We can make this function work only if the template parameter ForwardIterator1 has a "Property" named as value type; What if we assign a plain int* to ForwardIterator1?
The compiler will complain there is no value_type defined in int*. But int* is exactly an iterable type, we have to fix this problem. The mean we introduce is to setup an extra level of indirection. The extra level of indirection is the trait:

    template <class Iterator>    struct iterator_traits {        typedef typename Iterator::value_type value_type;        ...four more typedefs    };

 Then we can use this level of indirection to be a adapter for the typing difference;

    template <class ForwardIterator1, class ForwardIterator2>    void iter_swap(ForwardIterator1 i1, ForwardIterator2 i2)    {        typename          iterator_traits<ForwardIterator1>::value_type tmp = *i1;        *i1 = *i2;        *i2 = tmp;    }

In case of int*, we use partial specialization syntax of C++

    template <>    struct iterator_traits<T*>    {        typedef T value_type;        four more typedefs...    };

The compiler will not complain because of the existance of the extra level of indirection: traits

Traits achieve the type recognization non-intrusively, "the generic function can access the type uniformly";

We can solve any problem by introducing an extra level of indirection