テンプレートパラメータがイテレータの型であるかどうかをチェックする方法は？

Question

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 
} 

質問があります：5つのアサート文をパスするにはどうすればいいですか？

Answer 1

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 *); 
}; 

Answer 2

さて、あなたはこれがSFINAEを使用して行うことができ、かつ正確な技術がwiki page for SFINAEで見つけることができますiterator_categoryと呼ばれる入れ子になったのtypedefを持っているタイプをチェックすることができます。これは100％メソッドではありませんが、すべてのまともなイテレータはイテレータに共通のtypedefを提供する必要があり、iterator_categoryはイテレータ固有のものです。 TYPEが単にポインタであるかどうかを確認することも忘れないでください。ポインタはイテレータです。数年後、ここに来て

Answer 3

template < class T, class Enabler = void > 
struct is_iterator : public boost::false_type { }; 

template < class T > 
struct is_iterator< T, typename boost::enable_if_c< 
     sizeof(*(*(T*)0)) + sizeof((*(T*)0)++) + sizeof(++(*(T*)0)) + 
     sizeof((*(T*)0) == (*(T*)0)) + sizeof((*(T*)0) != (*(T*)0)) + 
     sizeof((*(T*)0) = (*(T*)0)) >::type > : public boost::true_type { }; 

Answer 4

、ここで、C++ 11とC++ 14には、そのような事をすることが多く容易になります。 iteratorは、その核心で、逆参照可能であり、増分可能なものである。それがinput iteratorであれば、それにも匹敵します。あなたが望むように見えるので、後者と一緒に行きましょう。

最も単純なバージョンはvoid_tを使用することであろう。

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

ベースケース：

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

有効なケースの特殊：

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 { }; 

別名：

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

iterator_categoryに頼るか、過負荷解決を使用して面倒なC++ 03スタイルのチェックを使用する必要はありません。表現SFINAEはここにあります。

---

氏Wakelyコメントで指摘したように、[iterator.traits]ことを必要とする：タイプ

、 Iterator場合は イテレータのタイプであることが要求される

iterator_traits<Iterator>::difference_type 
iterator_traits<Iterator>::value_type 
iterator_traits<Iterator>::iterator_category 

は、反復子の差異タイプ、値タイプ、および反復子カテゴリとしてそれぞれ定義されます。

だから我々は単にそれをチェックするために、当社のイテレータ形質を定義することができます。

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 { }; 

iterator_traits<T>::iterator_categoryが悪い形成されている場合は、Tがイテレータではありません。

Answer 5

元のポスターは、イテレータを増分および逆参照できるようにするために、実際にはInputIterator（http://en.cppreference.com/w/cpp/concept/InputIteratorを参照）を識別する方法を求めていることを明らかにしました。これは、標準C++ 11で非常に単純なSFINAEソリューションを持っています。GCCのSTLからのものと同様：

template<typename InputIterator> 
using RequireInputIterator = typename 
    std::enable_if<std::is_convertible<typename 
             std::iterator_traits<InputIterator>::iterator_category, 
             std::input_iterator_tag>::value>::type; 

... 

// Example: declare a vector constructor from a pair of input iterators. 
template <typename InputIterator, typename = RequireInputIterator<InputIterator> > 
    MyVector(InputIterator first, InputIterator last) { /* ... */ }; 

これはアーメンTsirunyanはイテレータ自分自身の必要と思っていたのtypedefを定義するイテレータ型の特性クラスに依存しています。 （反復子はがtypedefを提供しますが、イテレータとして裸のポインタを使用するために必要な特性クラスで提供することもできますし、標準のライブラリ実装が必要です）