Question

I am currently doing some template metaprogramming. In my case I can handle any “iteratable” type, i.e. any type for which a typedef foo const_iterator exists in the same manner. I was trying to use the new C++11 template metaprogramming for this, however I could not find a method to detect if a certain type is missing.

Because I also need to turn on/off other template specializations based on other characteristics, I am currently using a template with two parameters, and the second one gets produced via std::enable_if. Here is what I am currently doing:

template <typename T, typename Enable = void>
struct Foo{}; // default case is invalid

template <typename T>
struct Foo< T, typename std::enable_if<std::is_fundamental<T>::value>::type>{ 
   void do_stuff(){ ... }
};

template<typename T>
struct exists{
   static const bool value = true;
};

template<typename T>
struct Foo<T, typename std::enable_if<exists< typename T::const_iterator >::value >::type> {
    void do_stuff(){ ... }
};

I was not able to do something like this without the exists helper template. For example simply doing

template<typename T>
struct Foo<T, typename T::const_iterator> {
    void do_stuff(){ ... }
};

did not work, because in those cases where this specialization should be used, the invalid default case was instantiated instead.

However I could not find this exists anywhere in the new C++11 standard, which as far as I know simply is taking from boost::type_traits for this kind of stuff. However on the homepage for boost::type_traits does not show any reference to anything that could be used instead.

Is this functionality missing, or did I overlook some other obvious way to achieve the desired behavior?

Answer 1

If you simply want if a given type contains const_iterator then following is a simplified version of your code:

template<typename T>
struct void_ { typedef void type; };

template<typename T, typename = void>
struct Foo {};

template<typename T>
struct Foo <T, typename void_<typename T::const_iterator>::type> {
      void do_stuff(){ ... }
};

See this answer for some explanation of how this technique works.