de error: "no puede competir con el operador +", por iterador de la lista

Question

Para el código de abajo, estoy consiguiendo el error en el título para la línea

while((*(It2 + code)).exists){ 

void locatetohashtable(std::list<Element> elist, 
         int *m,std::list<Element>& table, 
         std::list<std::string>& keylist) 
{   
    std::list<Element>::iterator It2=table.begin(); 
    int i=0; 
    int k=0; 
    std::list<Element>::iterator It; 
    for(It = elist.begin(); It != elist.end(); ++It) 
    { 
     int code=hash_func(stringIntValue((*It).name),*m,i); 
     while((*(It2 + code)).exists){ 
      i++; 
     } 
     table.insert(*(It2+i), (*It)); 
     keylist.insert(keylist.begin(),(*It).name); 
     k++; 
    } 
} 

No estoy recibiendo el mismo error para ++It

¿De qué se trata el problema?

Answer 1

Un iterator para un std::list es bidireccional, por lo que no es compatible con +(int). Las únicas operaciones de movimiento admitidas son ++ y --.

Answer 2

std::list iteradores son solo bidireccionales, no de acceso aleatorio, por lo que no puede usar el operador + para avanzarlos. Use std::next (C++ 11) o std::advance en su lugar.

Answer 3

Eso es porque los iteradores std::list son bidirectional iterators, por lo que no son compatibles con la operación de adición que está tratando de realizar. En la práctica, esto se debe a que no se puede implementar como una operación eficiente, ya que las listas no proporcionan acceso aleatorio, por lo que tendría que hacer un paso en incrementos únicos desde el iterador inicial hasta el objetivo. La decisión de diseño es no proporcionar una operación, lo que será ineficiente.

Puede usar std::advance o std::next para evitar escribir sus propios bucles de incremento, pero debajo del capó aumentará paso a paso.

Answer 4

Esta es una cuestión de "Concepto".

A list solo se puede atravesar eficientemente forward and backward, por lo que sus iteradores modelan el concepto de Iterador bidireccional.

Puede usar std::advance para mover el iterador en varias posiciones a la vez, sin embargo, no será eficiente.

O puede cambiar para usar un vector o deque en lugar de una lista. Como son contenedores de acceso aleatorio, sus iteradores admiten sumas y restas de manera eficiente.