Operadores incremento y decremento en C++

4 min
Iniciación

Los operadores de incremento (++) y decremento (--) se aplican sobre variables para aumentar o disminuir su valor en una unidad.

Operador	Descripción	Comportamiento
`x++`	Pre incremento	Incrementa primero, devuelve el valor actualizado.
`++x`	Post-incremento	Devuelve el valor original, luego incrementa.
`x--`	Pre-decremento	Decrementa primero, devuelve el valor actualizado.
`--x`	Post-decremento	Devuelve el valor original, luego decrementa.

La diferencia entre incremento y decremento está clara.

++ añade una unidad
-- quita una unidad.

La duda surge entre pre y post (es decir, si va antes o después de la variable). La diferencia es que

pre incrementa/decremente, y luego devuelve el valor modificado
post devuelve el valor original, y luego lo incrementa/decrementa

¿Cuándo usar pre y cuando usar pro?

Os lo pongo fácil. Da igual porque los deberéis usar siempre van en su propia línea (abajo os pongo ejemplos)

Uso de los operadores de incremento y decremento

Vamos a ver el comportamiento de cada uno de ellos más en detalle 👇

Pre-incremento

En el caso del pre-incremento (++variable), el operador ++ aparece antes de la variable. Esto significa que el valor de la variable se incrementa antes de que la variable sea utilizada en la expresión en la que aparece.

#include <iostream>

int main() {
    int x = 5;
    int y = ++x;  // x se incrementa primero, luego se asigna a y

    std::cout << "Valor de x: " << x << std::endl; // Resultado: 6
    std::cout << "Valor de y: " << y << std::endl; // Resultado: 6
    return 0;
}

En este caso:

x se incrementa a 6 antes de ser asignado a y.
Tanto x como y tendrán el valor 6.

Post-incremento

En el caso del post-incremento (variable++), el operador ++ aparece después de la variable. Esto significa que la variable se utiliza en la expresión con su valor original y luego se incrementa.

#include <iostream>

int main() {
    int x = 5;
    int y = x++;  // x se asigna a y, luego se incrementa

    std::cout << "Valor de x: " << x << std::endl; // Resultado: 6
    std::cout << "Valor de y: " << y << std::endl; // Resultado: 5
    return 0;
}

En este caso:

y toma el valor original de x, que es 5.
Luego x se incrementa a 6.
El resultado final es x = 6 y y = 5.

Pre-decremento

Con el operador pre-decremento (--variable), el valor de la variable se decrementa antes de que se utilice en la expresión.

#include <iostream>

int main() {
    int x = 5;
    int y = --x;  // x se decrementa primero, luego se asigna a y

    std::cout << "Valor de x: " << x << std::endl; // Resultado: 4
    std::cout << "Valor de y: " << y << std::endl; // Resultado: 4
    return 0;
}

Aquí:

x se decrementa a 4 antes de ser asignado a y.
Ambos valores (x y y) son 4.

Post-decremento

El operador post-decremento (variable--) utiliza primero el valor original de la variable y luego lo decrementa.

#include <iostream>

int main() {
    int x = 5;
    int y = x--;  // x se asigna a y, luego se decrementa

    std::cout << "Valor de x: " << x << std::endl; // Resultado: 4
    std::cout << "Valor de y: " << y << std::endl; // Resultado: 5
    return 0;
}

En este ejemplo:

y toma el valor original de x, que es 5.
Luego x se decrementa a 4.
El resultado final es x = 4 y y = 5.

Donde SÍ usarlos

Como he dicho arriba, cuando uséis un operadores pre y post incremento/decremento que sea en su propia línea.

Por ejemplo, así:

int x = 5;
int y = 10;
x++;  // en su propia línea

int result = x + y;
// result vale 15

La única excepción notoria que se me ocurre es cuando se usan en bucles for.

En el siguiente ejemplo, usamos i++ en el bucle for para incrementar i al final de cada iteración.

#include <iostream>

int main() {
    for (int i = 0; i < 5; i++) {
        std::cout << "Iteración " << i << std::endl;
    }
    return 0;
}

Esto también está bien (en realidad, el ++ no deja de ir suelto en su propia instrucción única)

Donde NO usarlos

Es una mala idea usar los operadores pre y post incremento/decremento en expresiones complejas, porque dan lugar a errores muy difíciles de detectar.

Es decir, que no hagáis cosas así

int x = 5;
int y = 10;
int result = x++ + y;   // Post-incremento: x se usa como 5
// result vale 15

int x = 5;
int y = 10;
int result = ++x + y;   // Pre-incremento: x se usa como 6
// result vale 16