Un método que funciona al menos en gcc es a través de la referencia typedef:
struct true_type { };
struct false_type { };
template<typename T>
struct is_const_reference
{
typedef false_type type;
};
template<typename T>
struct is_const_reference<T const &>
{
typedef true_type type;
};
template<typename T>
struct is_const_iterator
{
typedef typename is_const_reference<
typename std::iterator_traits<T>::reference>::type type;
};
puede comprobar que funciona por usando
inline bool test_internal(true_type)
{
return true;
}
inline bool test_internal(false_type)
{
return false;
}
template<typename T>
bool test(T const &)
{
return test_internal(typename is_const_iterator<T>::type());
}
bool this_should_return_false(void)
{
std::list<int> l;
return test(l.begin());
}
bool this_should_return_true(void)
{
std::list<int> const l;
return test(l.begin());
}
Con un suficiente alto h nivel de optimización, las últimas dos funciones se deben reducir a return false;
y return true;
, respectivamente. Al menos lo hacen por mí.
¿Acaso soy yo o ha habido falta en los votos a favor de la comunidad últimamente? :(+1 dijiste que funcionaba, se ve bien –
He seleccionado tu respuesta, ya que tu solución usa std :: iterator_traits <> class –
No funciona cuando 'std :: iterator_traits :: pointer' es un tipo de clase de proxy. Pero si hay una solución para ese caso, tendría que usar SFINAE bastante desagradable. – aschepler