c++ - programar - postincremento
Preincremento más rápido que poscreción en C++-¿cierto? Si es así, ¿por qué es? (5)
El incremento posterior por lo general implica mantener una copia del valor anterior y agrega un pequeño código adicional. El pre-incremento simplemente hace su trabajo y se quita de en medio. Normalmente preincrecio a menos que la semántica cambie y el incremento posterior sea realmente necesario.
Posible duplicado:
¿Hay una diferencia de rendimiento entre i ++ y ++ i en C ++?
Escuché que los preincrementos (++ i) son un poco más rápidos que los postincrementos (i ++) en C ++. ¿Es eso cierto? ¿Y cuál es el motivo de esto?
En cualquier compilador decente, ++ i e i ++ son idénticos si el valor no se utiliza.
Si se usa el valor, ++ necesitaría un temporal para almacenar el valor de preincremento si se deseara una semántica idéntica.
La diferencia para tipos de tipos simples como int es probablemente insignificante. Supongo que el compilador puede optimizar tales casos (por ejemplo, convertir un postfijo en un incremento de prefijo cuando corresponda). Sin embargo, para tipos complejos (típicamente iteradores STL, la diferencia puede ser notable). El compilador no puede cambiar al prefijo en estos casos porque los operadores realmente pueden hacer cosas totalmente diferentes. Recomiendo leer Iterators de STL y Rendimiento para obtener información de contexto sobre la penalización de rendimiento al usar el incremento posterior para los iteradores de STL (cuento: lleva el doble de tiempo que el preincremento).
en realidad, depende. Postincrement necesita una copia ya que conserva el valor anterior. Si el tipo incrementado es un tipo complejo (por ejemplo, un iterador) y no un tipo simple, el preincremento es más rápido que el postincremento. Eso solo es cierto, por supuesto, si no necesita el valor antes del incremento.
Algunos compiladores incluso pueden detectar que no es necesario un postincrement y optimizar la copia, pero como siempre, es un mal hábito confiar en eso.
Los postincrementos tienen que hacer una copia del objeto para devolver el valor no incrementado. Para los tipos de clase, esto podría ser significativo, pero para los tipos "int-like" (punteros incluidos), probablemente no lo sea.