std :: enable_if o SFINAE de iterador o puntero

Question

me gustaría escribir un constructor para MyClass que tienen un argumento y yo quiero que esto compilar sólo si el argumento es un pointer o un iterator (algo que tiene iterator_traits). ¿Cómo lograr esto?

Answer 1

Lamentablemente, no hay una forma estándar para detectar si una clase modelos Iterator. La comprobación más simple sería que *it y ++it son sintácticamente válidos; usted puede hacer esto utilizando técnicas estándar SFINAE:

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

Teniendo en cuenta los requisitos de Iterator 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 
    )> {}; 

El problema con tratar de utilizar iterator_traits es que es una plantilla definida para todos tipos, y su creación de instancias fallará en un contexto que no sea SFINAE (recuerde que SFINAE solo aplica para fallas de sustitución directa). libstdC++ tiene un conforming extension mediante el cual la instanciación de iterator_traits en tipos no iteradores producirá un tipo vacío; se puede hacer un truco similar mediante la comprobación de la existencia de iterator_category del tipo:

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

Este será sin embargo no funcionar para los tipos que por sí mismas no exponer a iterator_category pero han sido adaptadas por un iterator_traits especialización separada; en ese caso, el método SFINAE simple tiene más sentido (y puede instanciar iterator_traits dentro del constructor para confirmar que el tipo es similar a un iterador).