Operadores de incremento y decremento

[G+10]

bueno en el manual que estoy leyendo dice que hay operadores de incremento ++ y decremento --
Y que hay postifijos y prefijos, y que los postifijos incrementan después de que su valor se de y prefijos antes, alguien me da un ejemplo que no le entendí bien.

[davirro]

http://www.norte.uni.edu.ni/estudiantes/manualc.pdf

[StraT]

Bueno, pues mira:

int a = 0, b = 1;

a++ // a = 1;
++a // a = 1;
a = b++;  //a = 1 y b = 2 -> Post incremento
a = ++b; //a = 2 y b = 2 -> Pre incremento

Y es igual pero al revés con el --.

[G+10]

Bueno, pues mira:

int a = 0, b = 1;

a++ // a = 1;
++a // a = 1;
a = b++;  //a = 1 y b = 2 -> Post incremento
a = ++b; //a = 2 y b = 2 -> Pre incremento

Y es igual pero al revés con el --.

gracias muy claro el ejemplo

[alberizo]

Ya puestos en el tema, según he leido en algunos sitios, si por ejemplo se quiere incrementar 1 a una variable, este sería el orden de eficacia y rendimiento

++a < a = a+1 < a++

¿Alguien puede confirmarlo?

[Capiflash]

Pues me gustaria que alguien explicase por qué ++a rinde mejor que a++. Según lo veo yo son la misma operación , sólo se diferencian en cuando se aplican , o me estoy equivocando demasiado?

[ethernet]

Pues me gustaria que alguien explicase por qué ++a rinde mejor que a++. Según lo veo yo son la misma operación , sólo se diferencian en cuando se aplican , o me estoy equivocando demasiado?

coge stl y te miras un iterator, verás que para el it++ necesita crear un temporal y para ++it no.

[davur]

Código [Seleccionar] Expand

Foo operator++(Foo& foo, int) // Postincremento
{
  Foo temp = foo;
  ++foo;
  return temp;
}

Foo& operator++(Foo& foo) // Preincremento
{
  ++foo.bar;
  return foo;
}

Dependiendo de la complejidad de Foo (construcción no trivial, semántica de copia), puede no ser posible optimizar la llamada al constructor copia en el operador de postincremento (caso habitual: iteradores de la librería estándar).

Moraleja: a no ser que realmente necesites el valor devuelto por el operador de postincremento, utiliza siempre el operador de preincremento (porque nunca es menos eficiente).

[StraT]

Sí, davur tiene razón, de hecho para comprobarlo vosotros mismos podéis probar a sobrecargar los operadores de pre y postincremento de cualquier clase que tengáis, y comprobad que el código que os sale en uno tiene una variable temporal y el otro no.

Saludos

[Capiflash]

Vaya , pues no me habia parado a pensar nunca en eso , todos los dias se aprende algo nuevo :)

Gracias! :P

[davur]

Técnicamente, el problema es el mismo tanto para tipos predefinidos como para tipos definidos por el usuario. En la práctica, al compilador le resultará bastante más sencillo optimizar en el caso de un tipo predefinido. Pero es que también podrá optimizar, generalmente, en el caso de un tipo definido por el usuario (existe la salvedad de tipos con características como las que comentábamos anteriormente).

Personalmente, y por consistencia, siempre que es posible utilizo el operador de preincremento. De esta manera, no hay debate.

[16BITBoy]

interesante cuestión, ya lei algo antes acerca de eso, aunque, tiene que ser bien complejo y lento algoritmo para tener que recurrir a esto ¿no? o tanto se nota la rapidez en la ejecucion :S

[StraT]

tiene que ser bien complejo y lento algoritmo para tener que recurrir a esto ¿no? o tanto se nota la rapidez en la ejecucion :S

No, realmente no se nota tanto, pero si te acostumbras a hacerlo, que no cuesta nada, estás siguiendo buenas prácticas. También debes tener en cuenta dónde se usan los incrementos, por ejemplo en bucles. En un bucle de 20 iteraciones no se nota, pero imagina un bucle de un millón de iteraciones, o de cien millones. Estás creando cien millones de variables temporales.

Un saludo, ;)