Olá pessoal,
Este é o primeiro POST (de muitos que ainda vão vir) onde irei falar sobre instruções úteis e práticas, que é muito comum utilizar durante a programação, mas que alguns programadores tem a dificuldade de compreender e expressar o seu REAL SIGNIFICADO.
Irei falar nesse PRIMEIRO POST dos OPERADORES DE PREFIXO E SUFIXO, muito presente em linguagens como C/C++, C#, Java, PHP e etc. Então vamos lá.
Os operadores de PREFIXO e SUFIXO
Os operadores de PREFIXO E SUFIXO são muito úteis quando queremos incrementar (somar) ou decrementar (subtrair) um valor numérico (normalmente tipos como inteiro).
Quem aprendeu programação sabe que uma das formas e ATUALIZAR o valor de uma variável numérica incrementando o seu valor e realizando a execução da seguinte instrução, demonstrado na sintaxe abaixo:
1 |
<variável> = <variável> + 1 |
A instrução acima diz que a <variável> receberá (=) o seu valor incrementado com “mais 1”. Supondo como exemplo uma variável chamada “x”, cujo valor inicial é “12”, considere a seguinte instrução abaixo:
1 2 |
int x = 12; x = x + 1; |
Como resultado final a variável “x” assume no final o valor “13”, porém há uma forma mais simples e curta de realizar esse mesmo incremento usando um operador de prefixo ou sufixo, onde ambos incrementam o valor de uma variável. Vejamos abaixo a sintaxe da aplicação do operador de prefixo e sufixo respectivamente:
1 2 3 4 5 6 7 8 9 |
//Para incremento ++<variável>; ou <variável>++; //Para decremento --<variável>; ou <variável>--; |
Logo, a instrução de incremento poderia ser encurtada de duas formas, conforme mostrado abaixo:
1 2 3 |
int x = 12; //Usando operador de prefixo ++x; |
Ou
1 2 3 |
int x = 12; //Usando operador de sufixo x++; |
Pelo o que podemos ver acima, chegamos a conclusão de que:
x++ OU ++x É IGUAL A: x = x + 1
Para ambas as demonstrações mostradas anteriormente, o valor final da variável “x” é 13, mas qual a REAL DIFERENÇA entre os operadores de prefixo e sufixo? Vamos conferir:
Qual a diferença entre ‘++x’ E ‘x++’ ?
Apesar de ambos fazerem a mesma coisa existe uma pequena diferença entre eles, que não é possível notar na demonstração anterior.
Usando os operadores de prefixo ou sufixo, é possível escrever instruções parecidas como a mostrada abaixo:
1 2 3 4 5 6 |
//Usando operadores de prefixo int x = 12; int y = x++; //Usando operadores de sufixo int x = 12; int y = ++x; |
Nas demonstrações mostradas anteriormente podemos ver que a variável “y” recebe como atribuição (=) o valor de “x” precedido ou seguido de um operador de incremento (++).
A ordem como o operador (++) aparece em “x” afetará no resultado final de “y”. Considerando o operador de prefixo, vamos traduzir de uma forma simples a instrução mostrada anteriormente:
A instrução abaixo:
1 2 |
int x=12; int y = ++x; |
Equivale a:
1 2 3 |
int x = 12; x = x + 1; y = x; |
Como o operador vem na frente da varável “x”, ocorre antes da atribuição o seu incremento para depois o valor já incrementado ser atribuído para “y”. No final teremos a variável “x” com o valor 13 e “y” também com 13.
Já usando o operador de sufixo, o cenário já muda, conforme mostrado a seguir:
A instrução abaixo:
1 2 |
int x=12; int y = x++; |
Equivale a:
1 2 3 |
int x = 12; y = x; x = x + 1; |
Como o operador vem após variável “x”, ocorre primeiramente a atribuição do seu valor atual (12) para “y”, ocorrendo em seguido o seu incremento. No final teremos a variável “y” com o valor 12 e “x” com 13.
Se eu quiser incrementar e decrementar valores acima de 1?
As instruções mostradas aqui são válidas para incrementar ou decrementar de forma curta valores de 1 em 1. Agora, que seu quiser atualizar o valor incrementando ou decrementando valores acima de 1? Isso é possível utilizando uma outra expressão. Vejamos a situação abaixo:
1 2 |
int x = 12; x = x + 3; |
Veja que na última instrução incrementamos o valor atual da variável “x” em 3, resultando no final o valor “15”. A instrução de incremento de valores acima de um poderia ser simplificada usando a seguinte sintaxe:
1 |
<variável>+=<valor>; |
Utilizando a sintaxe mostrada acima, poderíamos escrever o código da demonstração anterior da seguinte forma:
1 2 |
int x = 12; x+=3; |
Logo podemos chegar a conclusão de que:
x+=3 É IGUAL A: x = x + 3
Usando outros operadores
Para a sintaxe demonstrada anteriormente é possível a utilização de outros operadores além da soma. Vejamos abaixo:
1 2 3 4 |
x+=4; //Equivale a 'x = x + 4' x-=2; //Equivale a 'x = x - 2' x*=3; //Equivale a 'x = x * 3' x/=3; //Equivale a 'x = x / 3' |
Bom pessoal, por hoje é só. Em breve estarei postando mais dicas de uso de instruções parecidas como essa, que aceleram muito o processo de codificação, de uma forma muito prática e simples.
Se você achou legal este POST compartilhe com seus amigos, pois dicas como essa são de grande importância.
Um forte abraço para todos