How to check if a template parameter is an iterator type or not?

G

10

14

template<class T>
struct is_iterator
{
    static const bool value = ??? // What to write ???
};

int main()
{
    assert(false == is_iterator<int>::value);
    assert(true == is_iterator<vector<int>::iterator>::value);
    assert(true == is_iterator<list<int>::iterator>::value);
    assert(true == is_iterator<string::iterator>::value);
    assert(true == is_iterator<char*>::value); // a raw pointer is also an iterator
}

The question is: How to make the five assert statements pass?

Grumpy answered 2/12, 2010 at 14:20 Comment(6)

I guess Concept checking could help you. It's not easy though. – Ching 2/12, 2010 at 14:24

Do you really need to know? What are you going to do when you find out? Would it be sufficient to just test that the type implements, say, operator* and operator++? – Irs 2/12, 2010 at 14:45

@Karl Knechtel: My aim is: if type T have operator* and operator++ (including built-in operators), then is_iterator<T>::value will be non-zero. – Grumpy 2/12, 2010 at 15:0

now you've said two different things. Do you only want to test for the presence of those two operators, or do you want to test whether it's an iterator? – Ambit 2/12, 2010 at 17:43

In addition, the linked question preceded C++11, and that has much better compile time reflection support. – Dink 20/8, 2012 at 9:27

@Grumpy Those requirements are that of the InputIterator concept (en.cppreference.com/w/cpp/concept/InputIterator, see also en.cppreference.com/w/cpp/iterator) for which the standard provides a traits class to check for standard iterators. Other conforming iterators should specialize (or derive from) the type traits accordingly. – Rebuttal 24/10, 2016 at 19:53

D

5

template<class T>
struct is_iterator
{   
    static T makeT();
    typedef void * twoptrs[2];  // sizeof(twoptrs) > sizeof(void *)
    static twoptrs & test(...); // Common case
    template<class R> static typename R::iterator_category * test(R); // Iterator
    template<class R> static void * test(R *); // Pointer

    static const bool value = sizeof(test(makeT())) == sizeof(void *); 
};

Directrix answered 2/12, 2010 at 14:55 Comment(8)

Why is it necessary to use "|| is_pointer<T>::value"? Shouldn't the first check already be enough given the "template<class R> static void * test(R *); // Pointer" line? – Amontillado 2/12, 2010 at 15:48

@Jan de Vos. I do not know why Armen changed my answer. – Directrix 2/12, 2010 at 15:56

Fails to compile for a few things that aren't iterators (for example function types), and returns true for a few things that aren't iterators (for example pointer-to-function: there's no such thing as an array of functions and you can't increment a pointer-to-function). Close enough for most practical purposes though, I think. I think (not sure) it can also return false for some things that are iterators, but are neither pointers nor have an iterator_type typedef. Iterators in std are allowed just to specialize std::iterator_traits, I think. – Ambit 2/12, 2010 at 18:0

"returns true for a few things that aren't iterators" - but then, std::iterator_traits gives a false match for function pointers too, at least in my implementation, so I definitely forgive you that :-) – Ambit 2/12, 2010 at 18:7

Any C++03-compatible version of this? ie. without iterator_category and variadic functions? – Mustachio 15/6, 2016 at 0:16

@metamorphosis, the code is valid C++03 (it doesn't correctly identify all iterators, but it's valid C++03). – Cyrillic 16/10, 2016 at 23:4

@JonathanWakely I didn't pick up on iterator_category being C++03, which it is, but where they've written "...", are they just basically writing "etc" ie. as a placeholder, not a variadic argument? – Mustachio 23/10, 2016 at 1:14

@metamorphosis, no, it's valid C++ code, but it's not a variadic template it's a varargs function like printf, which has been valid in C since before C++ even existed. It's valid C++03 code. – Cyrillic 23/10, 2016 at 12:44

S

22

How about something like this?

template<typename T, typename = void>
struct is_iterator
{
   static constexpr bool value = false;
};

template<typename T>
struct is_iterator<T, typename std::enable_if<!std::is_same<typename std::iterator_traits<T>::value_type, void>::value>::type>
{
   static constexpr bool value = true;
};

example:

#include <iostream>
#include <type_traits>
#include <vector>

template<typename T, typename = void>
struct is_iterator
{
   static constexpr bool value = false;
};

template<typename T>
struct is_iterator<T, typename std::enable_if<!std::is_same<typename std::iterator_traits<T>::value_type, void>::value>::type>
{
   static constexpr bool value = true;
};

int main()
{
   static_assert(!is_iterator<int>::value);
   static_assert(is_iterator<int*>::value);
   static_assert(is_iterator<std::vector<int>::iterator>::value);
}

http://liveworkspace.org/code/7dcf96c97fd0b7a69f12658fc7b2693e

Spectrogram answered 20/8, 2012 at 6:8 Comment(6)

Try it with a random struct like Foo (I tried it on Visual C++). Same problem as mine. – Puccini 20/8, 2012 at 6:10

Visual Studio's rules are not the most similar. You will have to produce something compiler-specific. – Fellah 20/8, 2012 at 6:12

Well, it does fail on Visual C++, so either the compiler or this is wrong... – Puccini 20/8, 2012 at 6:12

@DeadMG: Do you mean it's a bug? or that there's no portable way to do it? – Puccini 20/8, 2012 at 6:12

@Mehrdad: There's a portable solution and a VC++ solution. Together that should be sufficient. – Dink 20/8, 2012 at 9:28

how does this work? for example using Tp = typename std::enable_if<!std::is_same<typename std::iterator_traits<It>::value_type, void>::value>::type; Tp = void – Malkamalkah 24/2, 2022 at 11:44

R

17

Coming in here a few years later, where C++11 and C++14 make it a lot easier to do such things. An iterator is, at its core, something that is dereferencable, incrementable. If it's an input iterator, then also comparable. Let's go with the latter - since that looks like what you want.

The simplest version would be to use void_t:

template <typename... >
using void_t = void;

Base case:

template <typename T, typename = void>
struct is_input_iterator : std::false_type { };

Valid case specialization:

template <typename T>
struct is_input_iterator<T,
    void_t<decltype(++std::declval<T&>()),                       // incrementable,
           decltype(*std::declval<T&>()),                        // dereferencable,
           decltype(std::declval<T&>() == std::declval<T&>())>>  // comparable
    : std::true_type { };

Alias:

template <typename T>
using is_input_iterator_t = typename is_input_iterator<T>::type;

No need to rely on iterator_category or using the tedious C++03 style of check things using overload resolution. Expression SFINAE is where it's at.

As Mr. Wakely points out in the comments, [iterator.traits] requires that:

it is required that if Iterator is the type of an iterator, the types
iterator_traits<Iterator>::difference_type
iterator_traits<Iterator>::value_type
iterator_traits<Iterator>::iterator_category
be defined as the iterator’s difference type, value type and iterator category, respectively.

So we can define our iterator trait to simply check for that:

template <class T, class = void>
struct is_iterator : std::false_type { };

template <class T>
struct is_iterator<T, void_t<
    typename std::iterator_traits<T>::iterator_category
>> : std::true_type { };

If iterator_traits<T>::iterator_category is ill-formed, then T is not an iterator.

Recalescence answered 14/7, 2015 at 14:28 Comment(3)

In addition to being incrementable and dereferencable, valid iterators are required to ensure that iterator_traits<T> defines value_type, difference_type etc. (either by providing them as nested types in the iterator or by specializing iterator_traits). Since DR 2408 you can safely check for any one of them in an expression SFINAE context to tell if iterator_traits thinks the type is an iterator. So I'd add iterator_traits<T>::iterator_category to your void_t argument list. – Cyrillic 16/10, 2016 at 23:13

@JonathanWakely Might as well just check that one right, instead of everything else? – Recalescence 17/10, 2016 at 12:28

Yes, it's probably safe to assume a type won't provide all the nested types (or a specialization of iterator_traits) without also being incrementable or dereferencable. If a type does do that you can slap the author and refuse to use the type, rather than try to make your trait cope with it :) – Cyrillic 17/10, 2016 at 14:33

D

5

template<class T>
struct is_iterator
{   
    static T makeT();
    typedef void * twoptrs[2];  // sizeof(twoptrs) > sizeof(void *)
    static twoptrs & test(...); // Common case
    template<class R> static typename R::iterator_category * test(R); // Iterator
    template<class R> static void * test(R *); // Pointer

    static const bool value = sizeof(test(makeT())) == sizeof(void *); 
};