java - qué - que es un flyer y como se hace
¿Qué es más eficiente i++ o++ i? (21)
¡Si importa! Especialmente si estás en C ++ ...
++i // the prefered way, unless..
auto j = i++ // this is what you need
Siempre debe usar la notación de prefijo para evitar la sobrecarga de copia necesaria y con C ++ ¡esto importa!
Exact Duplicate : ¿Hay una diferencia de rendimiento entre i ++ y ++ i en C ++?
Duplicado exacto : diferencia entre i ++ y ++ i en un bucle?
¿Qué es más eficiente i ++ o ++ i?
Solo he usado esto en Java y C / C ++, pero realmente estoy pidiendo todos los idiomas en los que esto se implementa.
En la universidad, un profesor nos mostró que ++ era más eficiente, pero han pasado un par de años y me gustaría recibir comentarios de la comunidad SO.
++ i es potencialmente más eficiente para una implementación no trivial del operador ++, pero incluso en ese escenario, el compilador puede optimizar el intermedio temporal.
++ i toma 1 instrucción de procesador menos que i ++ en ensamblaje x86 sin optimización
A menos que me esté perdiendo algo, deberían tener la misma eficacia. Ambos deberían dar como resultado una sola instrucción de agregar. Es solo una cuestión de dónde tiene lugar la instrucción add: al principio o al final de su línea de código.
Bueno, en C ++ creo que tienen diferentes usos, dependiendo de cuándo quieras que se actualice la variable. La eficiencia no debe determinar cuándo se usa uno sobre el otro, pero supongo que tendrían la misma eficiencia de cualquier manera.
Buscaría en otra parte potencial de optimización.
En general, es más eficiente usar ++ i que i ++. La simple razón de esto es que ++ i es completamente igual a
i + = 1;
que para x86 es una instrucción única (y probablemente la mayoría de otras arquitecturas ampliamente utilizadas). i ++ es sin embargo igual a
tmp = i; i + = 1;
Esto se debe a que el valor anterior de ''i'' es lo que i ++ evalúa. Y claramente eso requiere más trabajo que simplemente i + = 1;
Pero como se dijo anteriormente, esto prácticamente no tiene impacto con un compilador suficientemente inteligente, ya que optimizará las operaciones no utilizadas. Para muchos lenguajes interpretados (ejemplo: PHP), es probable que haya una ganancia mínima en la velocidad de ++ i; Pero este aumento es insignificante.
Es difícil responder a esto precisamente porque depende de la implementación del compilador / intérprete.
Pero, hablando en general, puedes decir más o menos extender i ++ a las siguientes instrucciones:
COPY i to tmp
INCREMENT tmp
SAVE tmp as i
Mientras ++ i se extenderá aproximadamente a:
LOAD i
INCREMENT i
No puede decir que ++ i es más rápido que i ++ ya que las implementaciones de lenguaje son bastante inteligentes y pueden optimizar estas instrucciones cuando sabe que no tendrá acceso al valor temporal de i ++. Esto generalmente ocurre en, por ejemplo, un ciclo for. Entonces, en muchos casos, es lo mismo.
Si está intentando este tipo de micro-optimizaciones, le aconsejo que haga un perfil / medida antes de elegir una sobre otra.
Generalmente, en c ++, postfix requerirá la construcción adicional del objeto incrementado, mientras que el prefijo se aplica directamente al objeto. (O eso he leído)
Como no puedo dar fe de cómo lo maneja el compilador debido a mi limitado conocimiento sobre el tema, podría ser manejado por usted, convirtiéndolo en un punto discutible.
La eficiencia no debe ser su preocupación: es el significado . Los dos no son lo mismo, a menos que sean independientes: uno opera el pre-uso del valor, el otro mensaje.
int i; i = 1; cout << i ++; // Devoluciones 1
int i; i = 1; cout << ++ i; // Devoluciones 2
Cuando el significado no es importante, la mayoría de los compiladores traducirán tanto ++ i como i ++ (por ejemplo, en un bucle for) en el mismo código máquina / VM.
No hay diferencia. Usa la construcción que tenga más sentido.
Si su aplicación se ejecuta lentamente, puedo garantizarle que nunca será así debido a las diferencias de velocidad en la operación de incremento de número entero. Si es así, es un error grave en el compilador. Los problemas de velocidad en su aplicación serán ineficiencias algorítmicas, esperando IO, y así sucesivamente.
No te preocupes por problemas que no tienes. La optimización prematura es la fuente de todos los males.
No hay respuesta correcta o incorrecta
Como depende de
1) cómo fue implementado por el compilador
2) en qué CPU se ejecuta el sistema
3) Si soy byte o doblo palabra
No importa en un compilador moderno.
int v = i++;
es lo mismo que
int v = i;
i = i + 1;
Un compilador moderno descubrirá que v no se utiliza y que el código para calcular v es puro (sin efectos secundarios). Luego eliminará v y el código de asignación y generará esto
i = i + 1;
Un "i ++" independiente; o "++ i" debería generar código igualmente eficiente. La diferencia viene si lo estás usando en una expresión, donde el "efecto secundario" entra en juego.
Dicho esto, hubo un tiempo, cuando "todo el mundo es un Vax", y los compiladores apestaban, que ++ se decía que era más eficiente que i ++, incluso en un "para (i = 0; i <N; + + i) "configuración de tipo.
++i es más rápido porque i++ tiene que almacenar i , luego incrementarlo, luego devolver el valor almacenado de i . ++i simplemente aumenta i luego lo devuelve.
// ++i
i += 1;
return i;
// i++
temp = i;
i += 1;
return temp;
En general, es más fácil escribir i ++, por lo tanto, es más eficiente en términos de tiempo de productividad.
En serio, sin embargo, si soy un tipo de datos nativo (como int, double, etc.), no hay diferencia.
Y depende de la implementación si es un tipo definido por el usuario, como
class Type
{
Type& operator ++(){}
const Type& operator ++(int i){}
};
T i;
i ++:
- crea una copia temporal de i
- incrementar i
- devolver la copia temporal
++ i:
- incrementar i
- devolver i
Con las optimizaciones activadas, es muy posible que el ensamblaje resultante sea idéntico, sin embargo, ++ i es más eficiente.
editar: tenga en cuenta que en C ++, puedo ser cualquier objeto que soporte el operador de prefijo y postfix ++. Para objetos complejos, el costo de copia temporal no es insignificante.
++ No necesito una variable temporal para almacenar cosas. Piénsalo de esta manera:
++ i
int preIncrement(int i)
{
i = i + 1;
return i;
}
i ++
int i = 5; // as an example
int postIncrement(_i)
{
int temp = _i;
i = _i + 1;
return temp;
}
¿Ver? Postincrement requiere una variable temporal. Suponiendo que el compilador no lo solucione todo, lo cual es casi seguro.
Por supuesto, más importante es la lógica del programa; usted corre el riesgo de encontrarse con The Sad Tragedy of Micro-Optimization Theatre si se preocupa demasiado por esto ... :)
Depende del contexto, por ejemplo:
x = i++
En este caso, ''x'' será igual a ''i'', y solo después de eso ''i'' se incrementará en uno.
x = ++i
En este caso, ''i'' aumentará en uno y luego el nuevo valor de ''x'' se asignará a ''x''.
En el caso de un ciclo ''para'', hay poca diferencia aparente aparte del rendimiento (++ i es más rápido).
Esta pregunta de tiene una gran respuesta: ¿hay una diferencia de rendimiento entre i ++ y ++ i en C?
Me gustaría agregar que debe usar el que mejor se adapte a sus necesidades. Excepto en las aplicaciones más críticas para el tiempo, no es importante. Desde una perspectiva académica también, es mejor escribir un código que exprese lo que necesita y optimice al fin.