std :: enable_if lub SFINAE dla iteratora lub wskaźnik

Question

chciałbym napisać konstruktora dla MyClass że pobiera argumentu, a ja chcę to do kompilacji tylko jeśli argument jest pointer lub iterator (coś mające iterator_traits). Jak to osiągnąć?

Answer 1

Niestety, nie ma standardowego sposobu wykrywania, czy modele klasy Iterator. Najprostszym sprawdzeniem jest, że *it i ++it są poprawne pod względem składni; można to zrobić przy użyciu standardowych technik SFINAE:

template<typename T, 
    typename = decltype(*std::declval<T&>(), void(), ++std::declval<T&>(), void())> 
    MyClass(T); 

Uwzglę wymogów Iterator z 24.2.2: 2:

template<typename T> typename std::enable_if< 
    !std::is_void<decltype(*std::declval<T &>())>::value 
    && std::is_same<decltype(++std::declval<T &>()), 
        typename std::add_lvalue_reference<T>::type>::value, 
    std::true_type>::type has_iterator_requirements_helper(int); 
template<typename T> std::false_type has_iterator_requirements_helper(...); 
template<typename T> struct has_iterator_requirements: 
    decltype(has_iterator_requirements_helper<T>(0)) {}; 

template<typename, bool> struct is_iterator_check: std::false_type {}; 
template<typename T> struct is_iterator_check<T, true>: std::true_type { 
    typedef typename std::iterator_traits<T>::difference_type difference_type; 
    typedef typename std::iterator_traits<T>::value_type value_type; 
    typedef typename std::iterator_traits<T>::iterator_category iterator_category; 
    typedef typename std::iterator_traits<T>::reference reference; 
    typedef typename std::iterator_traits<T>::pointer pointer; 
    static_assert(std::is_same<decltype(*std::declval<T &>()), reference>::value 
     || std::is_void<reference>::value, "*r must be of type reference"); 
}; 
template<typename T> struct is_iterator: is_iterator_check<T, 
    (std::is_pointer<T>::value 
    && !std::is_void<typename std::remove_pointer<T>::type>::value 
    && !std::is_function<typename std::remove_pointer<T>::type>::value 
    ) || (std::is_copy_constructible<T>::value 
    && std::is_copy_assignable<T>::value 
    && std::is_nothrow_destructible<T>::value 
    // TODO: check lvalues are swappable 
    && has_iterator_requirements<T>::value 
    )> {}; 

Problem z próby użycia iterator_traits jest to, że jest zdefiniowany szablon dla wszystkich typy i ich instancja zakończy się niepowodzeniem w kontekście innym niż SFINAE (należy pamiętać, że SFINAE ma zastosowanie wyłącznie w przypadku bezpośredniej awarii substytucji). libstdC++ ma numer conforming extension, w którym tworzenie wystąpień iterator_traits na typach innych niż iteratory spowoduje utworzenie pustego typu; można zrobić podobną sztuczkę poprzez sprawdzenie istnienia iterator_category na temat typu:

template<typename T> std::true_type has_iterator_category_helper(
    T::iterator_category *); 
template<typename T> std::false_type has_iterator_category_helper(...); 
template<typename T> struct has_iterator_category<T>: 
    decltype(has_iterator_category_helper<T>(0)) { }; 
template<typename T> struct is_iterator: std::integral_constant<bool, 
    std::is_pointer<T>::value || has_iterator_category<T>::value> {}; 

template<typename T, typename = std::enable_if<is_iterator<T>::value>> 
    MyClass(T); 

Będzie to jednak nie działać dla typów, które same nie narażają iterator_category ale zostały dostosowane przez oddzielny iterator_traits specjalizacji; w takim przypadku prosta metoda SFINAE ma więcej sensu (i można utworzyć instancję iterator_traits w konstruktorze, aby potwierdzić, że typ jest podobny do iteratora).