Operadores de incremento/decremento

Ao lidar com valores, especialmente o tipo numérico, você frequentemente encontrará a necessidade de somar ou subtrair 1. Isto é muito fácil de fazer - você simplesmente pega o valor, adiciona 1 e então o atribui de volta à variável original. Aqui está um exemplo:

int userAge = 41; 
userAge = userAge + 1; 

A variável userAge agora contém o valor de 42 em vez de 41 - fácil! Você pode, claro, fazer a mesma coisa quando quiser subtrair 1:

userAge = userAge - 1; 

Incremento/decremento do postfix

No entanto, o C # tem um operador muito mais curto para cuidar deste trabalho: O operador de incremento/decremento. Ele consiste simplesmente em dois sinais positivos ou negativos, um após o outro. Aqui está o primeiro exemplo, reescrito para usar este operador:

int userAge = 41; 
userAge++; 
Console.WriteLine("Age of user: " + userAge); 

O resultado é exatamente o mesmo, mas veja quanto mais curto é! E nós podemos torná-lo ainda mais curto, porque este operador pode, naturalmente, ser usado dentro de uma declaração existente:

int userAge = 41; 
Console.WriteLine("Age of user: " + userAge++); 

Mas espere um minuto - quando testar isso, você verá que o userAge ainda é impresso como 41. Por quê? Porque estamos usando a versão do postfix, que é avaliada após a declaração circundante. Em outras palavras, a linha é impressa antes que o valor seja incrementado. Esse será o comportamento que você deseja em alguns casos, mas não é ideal para esse uso específico. O que você precisa é o operador de incremento de prefixo.

Incremento/decremento do prefixo

Este operador se parece exatamente com a versão do postfix, mas em vez de aparecer depois da variável, ele aparecerá antes, instruindo o interpretador a avaliá-lo antes de avaliar a declaração circundante:

int userAge = 41; 
Console.WriteLine("Age of user: " + ++userAge); 

Isso terá o efeito desejado, onde o userAge é incrementado antes que a linha seja impressa. Agora, pode parecer um pouco confuso com três sinais +, mas o primeiro é para a concatenação de strings, enquanto os dois últimos são o operador real. Se preferir, você pode envolver a instrução de incremento com parênteses para deixar claro o que é que pertence:

Console.WriteLine("Age of user: " + (++userAge)); 

Tudo depende de você decidir - funciona exatamente da mesma maneira!

E, claro, você pode usar o operador de decréscimo exatamente da mesma maneira como ilustrado acima. Aqui está a versão do postfix:

int userAge = 41; 
Console.WriteLine("Age of user: " + (userAge--)); 

E a versão do prefixo:

int userAge = 41; 
Console.WriteLine("Age of user: " + (--userAge)); 

Resumo

Então, esses foram os operadores de incremento e decremento. Eles são ótimos para um caso de uso muito específico: Quando você deseja incrementar ou decrementar um valor em 1. No próximo capítulo, veremos o operador de atribuição de adição, que se parece muito com este, mas tem um uso um pouco mais amplo .

Tal como acontece com vários outros operadores C #, este cai sob o termo "açúcar sintático" - a mesma tarefa pode ser realizada sem este operador específico, mas com isso, seu código se torna mais curto. Se isso se torna mais legível é muito subjetivo - algumas pessoas gostam delas, enquanto outras sentem que seu código se torna mais fácil de ler e entender sem elas. É tudo para você!