¿Por qué std :: distance no funciona en la combinación de iteradores const y nonconst?

Question

Como dice la pregunta, me pregunto cuál es el motivo. Porque recibo un error cuando trato de obtener la distancia entre los iteradores const y los que no son const.

vector<int> v; 
auto it=v.begin(); 
auto cit=v.cbegin(); 
distance(it,cit); 


no matching function for call to ‘distance(__gnu_cxx::__normal_iterator<int*, std::vector<int> >&, __gnu_cxx::__normal_iterator<const int*, std::vector<int> >&) 

Desde mi limitada comprensión de los iteradores, no veo ninguna razón para que no debería funcionar.

Answer 1

Tiene un iterador mutable y un iterador constante en la llamada al std::distance, por lo que la deducción del argumento de la plantilla está fallando. Puede solucionar esto especificando explícitamente el argumento de la plantilla.

std::vector<int> v; 
auto i1 = v.begin(); 
auto i2 = v.cbegin(); 

auto dist = std::distance<std::vector<int>::const_iterator>(i1, i2); 

Answer 2

Esto se debe a std::distance() sólo toma un parámetro de plantilla:

template <class InputIterator> 
iterator_traits<InputIterator>::difference_type 
distance(InputIterator first, InputIterator last); 

Por lo tanto, first y last debe ser convertible en el mismo tipo, y la resolución de la plantilla por desgracia no considerará que vector<int>::iterator es convertible en vector<int>::const_iterator.

Answer 3

std::distance trabajará con esos dos iteradores lo que no funciona es la inferencia argumento de plantilla. El compilador intenta resolver qué tipo sustituir al primer argumento de plantilla y tiene dos posibles candidatos, lo que según el estándar termina en un error.

Puede hacer una de dos cosas, o bien comparar sólo iteradores del mismo tipo, o proporcionar el tipo de la plantilla:

std::distance<std::vector<int>::const_iterator>(v.begin(), v.cbegin()); 

Answer 4

Como todo el mundo dice, es porque std::distance sólo toma un tipo de iterador, y la deducción del argumento de la plantilla no puede elegir cuál debería ser (aunque solo uno de ellos es posible dado que iterator se convierte a const_iterator pero no vuelve).

podría valer la pena escribir una plantilla algo como esto:

template <typename Container> 
typename Container::const_iterator constify(const Container &, typename Container::iterator it) { 
    return it; 
} 

A continuación, se puede forzar la deducción plantilla de la siguiente manera:

std::distance(constify(v, it), cit); 

en lugar de escribir ese gran tipo long. El parámetro Container& es una pena, está ahí porque AFAIK Container no se puede deducir solo de un argumento iterador.