Pós-incremento/Decremento

Parte da seção Fundamentos do Journey de C++ da Coddy — lição 19 de 74.

Na lição anterior, cobrimos os operadores de incremento (++) e decremento (--). Estes operadores possuem duas formas: prefixo e posfixo.

A forma prefixada é escrita antes da variável (ex: ++x ou --x), e a forma pós-fixada é escrita depois da variável (ex: x++ ou x--).

Saber qual forma usar é importante na prática. Por exemplo, em um jogo você pode rastrear a pontuação de um jogador com score++ após cada acerto, ou usar --lives para refletir imediatamente uma vida perdida antes de verificar se o jogo acabou. Em loops, a escolha entre prefixo e sufixo pode afetar qual valor é usado em uma expressão antes ou depois da atualização.

A diferença entre as duas formas é sutil, mas importante:

Forma prefixada: Incrementa/decrementa a variável e, em seguida, retorna o novo valor.
Forma pós-fixada: Retorna o valor atual da variável e, em seguida, a incrementa/decrementa.

Aqui está um exemplo para ilustrar a diferença:

int x = 5;
int y = x++;
// y = 5, x = 6 (posfixo: y recebe o valor original, então x é incrementado)

int a = 5;
int b = ++a;
// b = 6, a = 6 (prefixo: a é incrementado primeiro, então b recebe o novo valor)

No primeiro caso, y recebe o valor original de x (5) e, em seguida, x é incrementado para 6. No segundo caso, a é incrementado primeiro e, em seguida, seu novo valor (6) é atribuído a b.

A mesma lógica se aplica ao operador de decremento:

int x = 5;
int y = x--;
// y = 5, x = 4 (posfixo: y recebe o valor original, então x é decrementado)

int a = 5;
int b = --a;
// b = 4, a = 4 (prefixo: a é decrementado primeiro, então b recebe o novo valor)

Desafio

Iniciante

Você recebeu um código com as inicializações de x, y e z. (Não apague essas linhas!)

Sua tarefa é usar os operadores de incremento/decremento para realizar as seguintes operações, nesta ordem:

Use o operador de incremento pós-fixado para atribuir o valor atual de x a a e, em seguida, incrementar x.
Use o operador de decremento pré-fixado para decrementar y e atribuir seu novo valor a b.
Use o operador de decremento pós-fixado para atribuir o valor atual de z a c e, em seguida, decrementar z.

Após realizar essas operações, imprima os valores de a, b, c, x, y e z no console no seguinte formato:

a: [value of a]
b: [value of b]
c: [value of c]
x: [value of x]
y: [value of y]
z: [value of z]

Experimente você mesmo

#include <iostream>

int main() {
    int x = 10;
    int y = 20;
    int z = 30;
    
    int a, b, c;
    
    // Digite seu código abaixo
    
    
    // Não altere as linhas abaixo
    std::cout << "a: " << a << std::endl;
    std::cout << "b: " << b << std::endl;
    std::cout << "c: " << c << std::endl;
    std::cout << "x: " << x << std::endl;
    std::cout << "y: " << y << std::endl;
    std::cout << "z: " << z << std::endl;
    
    return 0;
}