Cualquier compilador vale su sal generará exactamente la misma secuencia en lenguaje de máquina para ambas construcciones para cualquier tipo incorporado ( int
, float
, etc.), siempre y cuando la declaración realmente es tan simple como x = x + a;
y optimización está activada . (En particular, GCC -O0
, que es el modo predeterminado, realiza anti-optimizaciones , como insertar almacenes completamente innecesarios en la memoria, para garantizar que los depuradores siempre puedan encontrar valores de variables).
Sin embargo, si la declaración es más complicada, pueden ser diferentes. Supongamos que f
es una función que devuelve un puntero, entonces
*f() += a;
llamadas f
solo una vez, mientras que
*f() = *f() + a;
lo llama dos veces. Si f
tiene efectos secundarios, uno de los dos estará mal (probablemente el último). Incluso si f
no tiene efectos secundarios, es posible que el compilador no pueda eliminar la segunda llamada, por lo que esta última puede ser más lenta.
Y dado que estamos hablando de C ++ aquí, la situación es completamente diferente para los tipos de clases que sobrecargan operator+
y operator+=
. Si x
es de ese tipo, entonces, antes de la optimización, se x += a
traduce en
x.operator+=(a);
mientras que se x = x + a
traduce en
auto TEMP(x.operator+(a));
x.operator=(TEMP);
Ahora, si la clase está escrita correctamente y el optimizador del compilador es lo suficientemente bueno, ambos terminarán generando el mismo lenguaje de máquina, pero no es tan seguro como lo es para los tipos integrados. Esto es probablemente en lo que está pensando Stroustrup cuando fomenta su uso +=
.