bucle ‘for’ vs ‘foreach’ de Qt en C++

Cuál es mejor (o más rápido), un C++ for bucle o el foreach operador proporcionado por Qt? Por ejemplo, la siguiente condición

QList<QString> listofstrings;

¿Cual es mejor?

foreach(QString str, listofstrings)
{
    //code
}

o

int count = listofstrings.count();
QString str = QString();
for(int i=0;i<count;i++)
{
    str = listofstrings.at(i);
    //Code
}

Realmente no importa en la mayoría de los casos.

La gran cantidad de preguntas en StackOverflow con respecto a si este método o ese método es más rápido desmiente el hecho de que, en la gran mayoría de los casos, el código pasa la mayor parte de su tiempo esperando a que los usuarios hagan algo.

Si usted son realmente preocupado, perfílelo usted mismo y actúe de acuerdo con lo que encuentre.

Pero creo que lo más probable es que encuentre que esta pregunta solo importa en el trabajo más intenso de procesamiento de datos. La diferencia bien puede ser solo un par de segundos e incluso entonces, solo cuando se procesa una gran cantidad de elementos.

Haz que tu código funcione primero. Entonces haz que funcione rápido (y solo si encuentra un problema de rendimiento real).

El tiempo dedicado a la optimización antes de que haya terminado la funcionalidad y pueda perfilar correctamente, es en su mayoría tiempo perdido.

En primer lugar, me gustaría decir que estoy de acuerdo con Pax y que la velocidad probablemente no entra en juego. foreach gana indiscutiblemente en base a la legibilidad, y eso es suficiente en el 98% de los casos.

Pero, por supuesto, los muchachos de Qt lo investigaron y de hecho hicieron algunos perfiles:
http://blog.qt.io/blog/2009/01/23/iterando-eficientemente/

La lección principal que se puede sacar de eso es: use referencias constantes en bucles de solo lectura, ya que evita la creación de instancias temporales. También hace que el propósito del bucle sea más explícito, independientemente del método de bucle que utilice.

realmente no importa. Lo más probable es que si su programa es lento, este no es el problema. Sin embargo, debe tenerse en cuenta que no está haciendo una comparación completamente igual. Qt foreach es más similar a esto (este ejemplo usará QList<QString>):

for(QList<QString>::iterator it = Con.begin(); it != Con.end(); ++it) {
    QString &str = *it;
    // your code here
}

La macro puede hacer esto usando algunas extensiones del compilador (como GCC’s __typeof__) para obtener el tipo de contenedor pasado. También imagina ese impulso BOOST_FOREACH es muy similar en concepto.

La razón por la que su ejemplo no es justo es que su versión que no es Qt está agregando trabajo adicional.

Estás indexando en lugar de iterar realmente. Si está utilizando un tipo con asignación no contigua (sospecho que este podría ser el caso con QList<>), entonces la indexación será más costosa ya que el código tiene que calcular “dónde” está el elemento n-ésimo.

Habiendo dicho eso. Eso todavía no importa La diferencia de tiempo entre esas dos piezas de código será insignificante, si es que existe. No pierdas tu tiempo preocupándote por eso. Escriba lo que le resulte más claro y comprensible.

EDITAR: Como beneficio adicional, actualmente estoy muy a favor de la versión C ++ 11 de la iteración de contenedores, es limpia, concisa y simple:

for(QString &s : Con) {
    // you code here
}

Ya que Qt 5.7 la foreach macro está en desuso, Qt lo alienta a usar el C ++ 11 for en cambio.
http://doc.qt.io/qt-5/qtglobal.html#foreach

(más detalles sobre la diferencia aquí: https://www.kdab.com/adiós-q_foreach/)

No quiero responder a la pregunta de cuál es más rápido, pero sí quiero decir cuál es mejor.

El mayor problema con el foreach de Qt es el hecho de que toma una copia de su contenedor antes de iterar sobre él. Podría decir ‘esto no importa porque las clases de Qt se cuentan’ pero debido a que se usa una copia, en realidad no cambia su contenedor original en absoluto.

En resumen, el foreach de Qt solo se puede usar para bucles de solo lectura y, por lo tanto, debe evitarse. Qt felizmente le permitirá escribir un bucle foreach que cree que actualizará/modificará su contenedor, pero al final todos los cambios se descartan.

Primero, estoy completamente de acuerdo con la respuesta de que “no importa”. Elija la solución más limpia y optimícela si se convierte en un problema.

Pero otra forma de verlo es que, a menudo, la solución más rápida es la que describe su intención con mayor precisión. En este caso, el foreach de QT dice que le gustaría aplicar alguna acción para cada elemento en el contenedor.

Un simple bucle for dice que te gustaría un contador i. Desea agregar repetidamente uno a este valor i, y siempre que sea menor que la cantidad de elementos en el contenedor, le gustaría realizar alguna acción.

En otras palabras, el bucle for normal sobreespecifica el problema. Agrega muchos requisitos que en realidad no son parte de lo que está tratando de hacer. tu no cuidado sobre el contador de bucles. Pero tan pronto como escribes un bucle for, tiene que estar allí.

Por otro lado, la gente de QT no ha hecho promesas adicionales que puedan afectar el rendimiento. Simplemente garantizan iterar a través del contenedor y aplicar una acción a cada uno.

En otras palabras, a menudo la solución más limpia y elegante es también la más rápida.

El foreach de Qt tiene una sintaxis más clara para el bucle for en mi humilde opinión, por lo que es mejor en ese sentido. En cuanto al rendimiento, dudo que haya algo en él.

Podrías considerar usar el BOOST_FOREACH en cambio, ya que es un bucle for elegante bien pensado, y es portátil (y presumiblemente llegará a C ++ algún día y también es una prueba para el futuro).