Qual o resultado e por quê?

i=8 j=8 k=9 m=8 n=15

É isso?

Roger:

i=8 j=8 k=9 m=8 n=15
É isso?

int i = 8;

// equivalente a: int j = i; i = i + 1;
// logo, j = 8 e i = 9
int j = i++;

// equivalente a: i = i + 1; int k = i;
// logo, i = 10, k = 10
int k = ++i;

// equivalente a: int m = i; i = i - 1;
// logo, m = 10, i = 9
int m = i--;

// equivalente a: x = i + 1; y = i - 1; int n = x + y;
// logo, x = 10, y = 8, n = 18, i = 9
// x e y representam variaveis internas do compilador
int n = i++ + --i;

// o resultado será: i=9 j=8 k=10 m=10 n=18
System.out.printf("i=%d j=%d k=%d m=%d n=%d",i,j,k,m,n);

Abraços!

não entendi ainda.

Qual a dúvida?

Na última operação n “recebe temporariamente” o valor atual de i e depois o compilador decrementa i e soma mais um ao i quando terminar a operação.

Como os sinais de ++ vem depois da variável i, o compilador vai usar o valor atual dela e só vai incrementá-la depois que terminar a operação!

Vamos tentar outra vez:

1) int i = 8;   
2) int j = i++;   
3) int k = ++i;   
4) int m = i--;   
5) int n = i++ + --i;   
       
System.out.printf("i=%d j=%d k=%d m=%d n=%d",i,j,k,m,n);

1: i vale 8, certo?
2: j = 8 - Aqui ocorre que o “j” recebe o valor de “i” ( 8 ) e depois o “i” é incrementado atravéz do ++, passando a ser 9, certo? (i=9 e j=8 )
3: k = 10 - Aqui o pré incremento (++) adiciona 1 ao “i” e só depois atribui o valor de “i” ao “k”, certo? (i=10, j=8 e k=10)
4: m=10 - Neste caso, como anteriormente, primeiro é atribuido ao “m” o valor de “i” e depois subtraido 1 de “i”, OK? (i=9, j=8, k=10 e m=10)
5: n=19 - Aqui vamos por parte. Primeiro atribui o valor atual do “i” ( 9 ) ao “n” e acrescenta 1 (n=9 e i=10). Depois retira-se 1 de “i” (–i) (i=9 novamente) e soma-se com o que estava atribuído ao “n” ( 9+9=18 ).

i=9 j=8 k=10 m=10 n=18

Ficou claro?

Abraço

Marco A.

Fica ainda mais claro se debugarem o exemplo.

Gente a dúvida principal está em saber porquê n será 18 uma vez que existe uma ordem de precedência nos sinais ai. Eu imagino que na linha 5(n = i++ + --i) a ordem logica de execução deveria ser:

A) executar a operação i++ (porém somaria 1 somente apos atribuir o valor da soma a N (operador =); logo i continuaria como 9;

b) executar a operação --i; logo i teria o novo valor de 8

c) executar a soma de 9+8

d) atribuir 17 a N;

e) no final da atribuição em N somar +1 a i referente a operação i++ do passo A; logo i voltaria a ser 9;

Não sei se cometi um erro de interpretação mas me recordo que a ordem de precedência é:

1. ++ e –
2. • /

…
Ultimo) =

dfsilva86:

Qual a dúvida?
Na última operação n “recebe temporariamente” o valor atual de i e depois o compilador decrementa i e soma mais um ao i quando terminar a operação.

Como os sinais de ++ vem depois da variável i, o compilador vai usar o valor atual dela e só vai incrementá-la depois que terminar a operação!

Isso não está claro. Tentando entender o quê você disse continuaria errado, afinal cai nos mesmos passos que citei acima.

Esse n=19 no inicio da linha vou entender como um erro de digitação. Quer dizer então que você atribuiu logo de inicio um valor a N e em seguida somou +1 a i sendo que isso não deveria ser praticamente os últimos passos?

Entendo que essa deve ser a explicação correta do problema, mas é um pouco estranho.

Mas olha, no seu comentário x = i + 1 (usando o 10 para atribuir a N) é errado, senão seria verdade dizer que j = i++ é o mesmo que j = i +1, o que é errado.

Como Funciona:

no exemplo nº 5 é usado operador pós-fixado e pré-fixado.

1º) O Compilador verifica que a variável i utiliza operador pós-fixado, ou seja ele vai usar o valor atual da variável…blz…ele pega o valor atual
2º) Ele identifica o operador + que ira fazer uma soma e encontra a variável j com operador pré-fixado, ou seja atualiza a variável j e depois utiliza seu valor, feito isso ele faz a soma e atribui a N.
3º) Terminada a expressão ele atualiza o valor de i que tem um operador pós-fixado

Ou seja, o operador pós-fixado será executado somente depois que terminar a expressão.

O Resultado será o mesmo se fizer:

ou

Sobre a ordem de precedência eu acho que vc está certo, mas na expressão nós temos apenas 1 operador para a expressão (+). Os demais são operadores pós e pré-fixados, não deixam de ser operadores mas são executados de forma diferente. Me corrijam se estiver falando besteira!!

Espero ter ajudado!

Mais então maluco, executando seus passos olha como deveria ficar:

1. i = 9
   n = 9 + --i

2. n = 9 + 8
   n = 17

3. i = 9

Reparou? O que você diz é o mesmo que está ai. O RESULTADO correto é 18 para N. :shock:

Entendi o que vc disse!! você está certo…

Então a questão são os operadores pós e pré fixados, vamos lá de novo.

O que eu entendi com o debug:
1º) Ele faz a soma com os valores atuais de "i"
2º) Ele incrementa e depois decrementa resultando i em 9 e n em 18!!! conforme a ordem de precedencia…

Eu acho que é isso, mas agora fiquei mais confuso:

Se fizer assim: i=10 e n=19

Se fizer assim: i=8 e n=17

Vou estudar mais esses operadores!!!

Essa questão é de algum simulado?

Na verdade não. Estava lendo um livro sobre estrutura de dados para aprender conceitos mais avançados de arvores e me deparei com esse treixo de código que fiquei com tremenda dúvida. Dai achei muito parecido com essas questões de prova de certificação, por isso postei aqui.

Mas ainda não achei uma boa explicação para isto.

Até.