How do type_traits work?

If you have used Boost's type_traits header (or what's in C++ standard now) you might have wondered as to how these could have been implemented. If you haven't, type traits are like a jacket to any type that provide meta information about them without actually modifying the type/class itself. I will dig into the type_traits header of Boost to see how its done.

To demonstrate how it's used, lets assume you are writing a generic algorithm that works on a range of iterators. But your assumption it that it is an iterator to a numeric type, because you do a lot of numeric operation on them. So, here is how you write it.

<br /> template <typename Iterator><br /> typename iterator_traits<Iterator>::value_type total(Iterator begin_, Iterator end_)<br /> {<br />         //Check if the type this function is parameterized on is an arithmetic type.<br />         // If not we throw a compiler error.<br />         BOOST_STATIC_ASSERT(( typename is_arithmetic<typename iterator_traits<Iterator>::value_type>::value ));<br /> <br /> ..... rest of the code..... <br /> }<br />

This should throw a compiler error if any non-arithmetic type is passed to total(). Let's look at how is_arithmetic is implemented so as to see how it identifies arithmetic types from others.

Let's go down to: /usr/include/boost/type_traits.cpp. It includes a lot of internal headers from /usr/include/boost/ which have the same name as the trait class they provide.

If you go down to /usr/include/boost/type_traits/is_arithmetic.hpp

You see a lot of arcane pre-processor stuff, but the key thing to observe is:

<br /> ::boost::detail::is_arithmetic_impl<T>::value<br />

You might notice all internal details in Boost goes into an internal namespace.

So, is_arithmetic_impl<T> is another internal type trait class, which is wrapped around by the one we use.

It looks as follows:

<br /> template< typename T ><br /> struct is_arithmetic_impl<br /> {<br />     BOOST_STATIC_CONSTANT(bool, value =<br />         (::boost::type_traits::ice_or<<br />             ::boost::is_integral<T>::value,<br />             ::boost::is_float<T>::value<br />         >::value));<br /> };<br />

This structure again wraps around more type traits is_integral, is_float and does a compile time logical OR of the results. They mean that an arithmetic type should be integral or one of the float types.

Let's explore is_integral.hpp. It provides a traits class that returns a type true when parametrized on  intergal types and false for any other type. Basically, it tells whether a type is integral or not.

Again if you skim through all the pre-processor magic to come down to what they are implementing you see a set of declarations:

<br /> BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_integral,T,false)<br />

followed by:

<br /> BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1(is_integral,unsigned char,true)<br /> BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1(is_integral,unsigned short,true)<br /> BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1(is_integral,unsigned int,true)<br /> BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1(is_integral,unsigned long,true)<br />

and many more other integral types.

If you look for what BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1 macro expands to in boost/type_traits/detail/bool_trait_def.hpp, it looks as follows:


<br /> #define BOOST_TT_AUX_BOOL_TRAIT_DEF1(trait,T,C) \<br /> template< typename T > struct trait \<br />     BOOST_TT_AUX_BOOL_C_BASE(C) \<br /> { \<br />     BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) \<br />     BOOST_MPL_AUX_LAMBDA_SUPPORT(1,trait,(T)) \<br /> }; \<br />



To explain this in simple terms, all what's being done here is explicit template specialization


You can think of is_integral to be implemented as follows in simple terms:

<br /> template <typename T><br /> struct is_integral<br /> {<br />         enum{value=false};<br /> };<br /> <br /> template <><br /> struct is_integral<int><br /> {<br />         enum {value=true};<br /> };<br /> <br /> template <><br /> struct is_integral<long><br /> {<br />         enum {value = true};<br /> };<br />

.... and so on for each integral type. So, the value is going to be true for each type they specialize on, but false for all other types..