Me ajudem. Estou com uma grande dúvida

Programação Java
#1

Estou com algumas dúvidas sobre pós-incremento e pré-incremento.

suponde que:
int a=1;

  1. a=a++; a resposta será 1

  2. a=++a; a resposta será 2

  3. a=a++ +a; resposta será 3

  4. a=++a +a; resposta será 4

  5. for(a=1; a<2; ++a) resposta será 1

  6. 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?

#2

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?

[]s

#3

Camila, dá uma olhada no tópico abaixo, que esse assunto está bem discutido:

http://www.guj.com.br/forum/viewtopic.php?t=2853

#4

resposta para o 5 e 6 :slight_smile:
é que em java, o incremento do for é executado sempre apos o loop, não importando se ele é utilizado pré ou pós incremento :slight_smile:
ja no C, no loop ele tem comportamento diferente :slight_smile:

#5

eu costumo pensar da seguinte maneira para pré e pos incremento:

int a = 1;
int b = 0;
int c = 0;

b = ++a; // b = 2 e a =2;
c = a++; // c = 2 e a =3;

abrindo o codigo
b=++a ; equivale a: a += 1;
b = a;

c=a++ ; equivale a: c = a;
a += 1;

Não sei se deu para entender, espero ter ajudado

#6

deixa eu corrigir uma coisa para ficar mais claro.

int a = 1;
int b = 0;
int c = 0;

b = ++a; // b = 2 e a =2;
c = a++; // c = 2 e a =3;

abrindo o codigo:

b=++a ;

equivale

a: a += 1;
b = a;

e

c=a++ ;
equivale a:

c = a;
a += 1;

#7

Deu pra entender legal o que você escreveu.
Veja se eu estou certa.

int a=1;
int b=0;

b=a++ + ++a; // b ficará 4

Mas quanto ao:
for(a=1; a<2; a++) ou
for(a=1; a<2; ++a) não deu pra entender. Quando será contado mais 1 na variável a?

#8

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++&lt;2; a++) 
		System.out.println("Primeiro for: " + a);
		
	System.out.println("Depois do Primeiro for: " + a);
	
	for(a=1; ++a&lt;2; ++a) 
		System.out.println("Segundo for: " + a); // esta linha não será executada
		
	System.out.println("Depois do Segundo for: " + a);
}

}[/quote]

[/b]

#9

Existe uma forma simples de saber o porque de

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 )

Claudio Gualberto

#10