Estou com algumas dúvidas sobre pós-incremento e pré-incremento.
suponde que:
int a=1;
a=a++; a resposta será 1
a=++a; a resposta será 2
a=a++ +a; resposta será 3
a=++a +a; resposta será 4
for(a=1; a<2; ++a) resposta será 1
for(a=1; a<2; a++) resposta será 1
Dúvidas:
Como funciona o pré-incremento (++i) e o pós-incremento(i++) seguindo os exemplos acima.
No exemplos 1) a variável “a” recebe 1 depois incrementa (++), o incremento (adiciona mais 1). Portanto no exemplo 1) como no exemplo 2) a resposta não teria que ser “2”.
Comente os exemplos: 3) e 4)
Comente os exemplos: 5) e 6) - Por que independente da posição do incremento as respostas são as mesmas?
Vamos aos comentários ehehe … vou falar o que sei, já meio que estudando, então podem me corrigir se disser besteira.
Ah, recomendo procurar no forum tb porque tem mais topicos sobre incrementos.
Não deveria. O pós-incremento só é executado depois das atribuições. Então o Java faz a seguinte operação para o exemplo 1:
a=a;
a++;
[quote]- Comente os exemplos: 3) e 4)
3) a=a++ +a; resposta será 3
4) a=++a +a; resposta será 4 [/quote]
Quebrando o 3 fica assim:
a = a; //1
a = a + a; //2
a++; //3
O 4 fica assim:
a++; //2
a = a + a //4
Entendeu? Pos-incremento feito depois de tudo, pré-incremento feito antes de tudo.
[quote]- Comente os exemplos: 5) e 6) - Por que independente da posição do incremento as respostas são as mesmas?
5) for(a=1; a<2; ++a) resposta será 1
6) for(a=1; a<2; a++) resposta será 1 [/quote]
Não sei … eu achei que sabia ehehe, mas pelo que sei em C esses laços sairiam com a=2 … pq ele faz o incremento, atribui e depois testa, a=2 ele sai mas não volta o valor de a pra 1 (antes do incremento) … alguem?
resposta para o 5 e 6
é que em java, o incremento do for é executado sempre apos o loop, não importando se ele é utilizado pré ou pós incremento
ja no C, no loop ele tem comportamento diferente
neste caso, acho que não faz diferença de quando eles são incrementados.
pois:
for (<declaracao>, <expressao booleana>, <linha_executada_no_final>) {
<corpo>
}
a <linha_executada_no_final> pode ser a++ ou ++a.
Somente depois que o for executar todo o seu corpo, ele irá incrementar o a.
se o incremento fosse na <expressao booleana>, aí sim iria fazer diferença.
[quote]
public class PrePosIncremento {
public static void main(String[] args) {
int a=1;
int b=0;
b=a++ + ++a; // b ficará 4
for(a=1; a++<2; a++)
System.out.println("Primeiro for: " + a);
System.out.println("Depois do Primeiro for: " + a);
for(a=1; ++a<2; ++a)
System.out.println("Segundo for: " + a); // esta linha não será executada
System.out.println("Depois do Segundo for: " + a);
}
int x = 1;
x = x++;
System.out.println( x ) ;
imprime 1 ao invéz de 2.
Vamos quebrar em instruções de máquina :
Considere que 'i' está mapeada em EES[ EBX ]
mov ax , EES[ EBX ]; salva o valor de 'i' em um acumulador.
mov di , ax ; instrução de incrementação
inc di ; ...
mov EES[ EBX ] , di ; finaliza incrementação
mov EES[ EBX ] , ax; move o valor do acumulador para 'i' , perdendo
; o incremento.
agora pré-incremento :
mov ax , EES[ EBX ]; salva o valor de 'i' em um acumulador.
inc ax ; ...
mov EES[ EBX ] , ax; finaliza incrementação
mov EES[ EBX ] , ax; move o valor do acumulador para 'i' , neste caso
; essa instrução é inútil ( side-efect do compilador )