Ola distintos amigos em um texte para certificacao caiu o seguinte trecho de codigo
y=0;
y =y++;
o que imprime???Bom eu coloquei 1 mas ERREI!!o resultado é ZEROnao acreditei pois em c o resultado é um!!pois é, alguem sabe pq??
essas provas sao a nivel tao baixo de compucao???Poxa essa questao foi CRUEL
y = y++ - a atribuição acontece antes do incremento.
y = ++y - a atribuição acontece depois do incremento.
no caso aí, primeiro “acontece” o y=y e depois o y++…
entendeu?
Oi,
acontece o seguinte,
quando passado isso:
int y = 0;
System.out.println(y = y++); // Resultado 0
ele está mostrando e depois calculando.
quando mostrado isso:
int y = 0;
System.out.println(y = ++y); // Resultado 1
Ele esta calculando e depois mostrando…
Mas acredito que y = y++ ou y = ++y está absurdamente errado, pois deveria ser somente: y++ ou ++y.
Tchauzin!
++ é um operador unário, ou seja, que só tem um operando.
Pode-se pensar que “y++” faz o mesmo trabalho que “y = y + 1”
O operador pode ser pré-fixado ou pós-fixado ao operando.
Quando pré-fixado (ex.: ++y), primeiro ocorrerá a soma (y+1) e depois será feita a leitura do valor resultante.
Quando pó-fixado (ex.: y++), primeiro ocorrerá a leitura de y e depois será feita a soma (y+1).
Pode-se pensar da seguinte forma:
//código equivalente a ++y (supondo que o valor de y passado ao método vai ser alterado, o que não acontece em java)
public int incrementoPreFixado(int y) {
y = y + 1; //atualiza o valor de y.
return y; //exibe o novo valor de y, depois do incremento.
}
//código equivalente a y++
public int incrementoPosFixado(int y) {
int retorno = y; //guarda o valor de y, antes do incremento
y = y + 1; //atualiza o valor de y.
return retorno; //exibe o antigo valor de y, antes do incremento.
}
public static void main(String[] args) {
int y = 0;
SysoutincrementoPosFixado(y); //exibe 0 e muda o valor de y pra 1
Sysout(incrementoPreFixado(y)); // exibe 2 e muda o valor de y pra 2
}Claro que esses métodos só não funcionarão exatamente como os operadores pois não teria como alterar valor de y passado ao método, pois em Java não existe passagem de valores por referência, apenas por cópia.
Isso aí é válido porque y++ ou ++y são operações que retornam um valor e, por isso, podemos atribuir tal resultado a uma variável.
I
[quote=rissato]y = y++ - a atribuição acontece antes do incremento.
y = ++y - a atribuição acontece depois do incremento.
no caso aí, primeiro “acontece” o y=y e depois o y++…
entendeu?[/quote]
Isso que me falaste nao é nada de novo leia por favor de novo a minha mensagem!!
class A{
int y=0;
y=y++;
System.out.println(y);//resultado é Zero ao invez de "1"pois em c em varios outros compiladores é 1 essa. Essa é a minha duvida e nao sobre o que é ++y ou y++ pré-incremento e pós-incremento
}
valeu!
[quote=rissato]y = y++ - a atribuição acontece antes do incremento.
y = ++y - a atribuição acontece depois do incremento.
no caso aí, primeiro “acontece” o y=y e depois o y++…
entendeu?[/quote]
Eu tbm não entendi.
primeiro acontece y=y
depois acontece y++
Logo se vc tivesse:
System.out.println(y=y++);
System.out.println(y);deveria imprimir:
0
1
mas…não é o q ocorre?
pq? afinal de contas…depois acontece y++, então pq na segunda linha não imprimiu 1?
A atribuição é sempre a última operação a ser realizada… veja no passo a passo mais ou menos o q aconteceu:
int y = 0; //inicializou y com zero
y = y++;
/*
- primeiro, será feita a avaliação dos operandos, do lado direito temos uma operacao y++… qual o resultado dela? ZERO, pois o operador foi pos-fixado… entao, a JVM já sabe que o valor a ser atribuido eh ZERO.
- Em seguida, o valor de y é incrementado em 1 e o valor de y passa a ser 1.
- Mas, por fim, aquele valor que foi lido inicialmente (ZERO) será atribuido a y (por causa do operador de atribuição)
- Então, no final de tudo, nesse caso, o valor de y vai ser ZERO.
*/
Ou seja, se tivessemos apenas y++, o resultado de y seria 1, mas como tinhamos y = y++, entao o valor final eh zero.
se fosse usar a analogia dos metodos q eu fiz eh como se fizesse:
y = incrementoPosFixado(y); //após encerrar o método, temos que o retorno dele foi zero e o valor de y é 1… mas aih estamos pegando o resultado, que foi zero, e atribuindo a y, que passa a ser zero.
[]'s
[quote=RafaelVS]++ é um operador unário, ou seja, que só tem um operando.
Pode-se pensar que “y++” faz o mesmo trabalho que “y = y + 1”
O operador pode ser pré-fixado ou pós-fixado ao operando.
Quando pré-fixado (ex.: ++y), primeiro ocorrerá a soma (y+1) e depois será feita a leitura do valor resultante.
Quando pó-fixado (ex.: y++), primeiro ocorrerá a leitura de y e depois será feita a soma (y+1).
Pode-se pensar da seguinte forma:
//código equivalente a ++y (supondo que o valor de y passado ao método vai ser alterado, o que não acontece em java)
public int incrementoPreFixado(int y) {
y = y + 1; //atualiza o valor de y.
return y; //exibe o novo valor de y, depois do incremento.
}
//código equivalente a y++
public int incrementoPosFixado(int y) {
int retorno = y; //guarda o valor de y, antes do incremento
y = y + 1; //atualiza o valor de y.
return retorno; //exibe o antigo valor de y, antes do incremento.
}
public static void main(String[] args) {
int y = 0;
SysoutincrementoPosFixado(y); //exibe 0 e muda o valor de y pra 1
Sysout(incrementoPreFixado(y)); // exibe 2 e muda o valor de y pra 2
}Claro que esses métodos só não funcionarão exatamente como os operadores pois não teria como alterar valor de y passado ao método, pois em Java não existe passagem de valores por referência, apenas por cópia.
Isso aí é válido porque y++ ou ++y são operações que retornam um valor e, por isso, podemos atribuir tal resultado a uma variável.[/quote]
Olha sinceramente acho que isso tem mais aver com o fato que o método vai ficar no heap ou algo assim e a variavel local na pilha, o compilador dever dar algun tipo de preferencia considerando o pós e o pré ,que eu nao sei
int y=0;
y =y++;
System.out.prinltn(y);resultado é zero mas ja em c e outros compiladores é um
[quote=RafaelVS]A atribuição é sempre a última operação a ser realizada… veja no passo a passo mais ou menos o q aconteceu:
int y = 0; //inicializou y com zero
y = y++;
/*
- primeiro, será feita a avaliação dos operandos, do lado direito temos uma operacao y++… qual o resultado dela? ZERO, pois o operador foi pos-fixado… entao, a JVM já sabe que o valor a ser atribuido eh ZERO.
- Em seguida, o valor de y é incrementado em 1 e o valor de y passa a ser 1.
- Mas, por fim, aquele valor que foi lido inicialmente (ZERO) será atribuido a y (por causa do operador de atribuição)
- Então, no final de tudo, nesse caso, o valor de y vai ser ZERO.
*/
Ou seja, se tivessemos apenas y++, o resultado de y seria 1, mas como tinhamos y = y++, entao o valor final eh zero.
se fosse usar a analogia dos metodos q eu fiz eh como se fizesse:
y = incrementoPosFixado(y); //após encerrar o método, temos que o retorno dele foi zero e o valor de y é 1… mas aih estamos pegando o resultado, que foi zero, e atribuindo a y, que passa a ser zero.
[]'s[/quote]
hmmmm…
agora entendi! Eu acreditava que o pós-incremento era sempre a última coisa a acontecer num comando. Ainda acho que isso seria o mais lógico, mas enfim, pra ter sido feito assim era pq deveria ter sua necessidade…
valeu Rafael!
[quote=fabioEM]
Olha sinceramente acho que isso tem mais aver com o fato que o método vai ficar no heap ou algo assim e a variavel local na pilha, o compilador dever dar algun tipo de preferencia considerando o pós e o pré ,que eu nao sei
int y=0;
y =y++;
System.out.prinltn(y);resultado é zero mas ja em c e outros compiladores é um[/quote]
Essa explicação que eu dei não foi em relação ao resultado de y = y++… foi apenas explicando o que eh pre e pos incremento. A explicação sobre o que realmente acontece foi a que eu respondi em seguida:
[quote=RafaelVS]A atribuição é sempre a última operação a ser realizada… veja no passo a passo mais ou menos o q aconteceu:
y = incrementoPosFixado(y); //após encerrar o método, temos que o retorno dele foi zero e o valor de y é 1… mas aih estamos pegando o resultado, que foi zero, e atribuindo a y, que passa a ser zero.
[]'s[/quote]
Como o retorno é um valor e existe outro valor??
y = incrementoPosFixado(y); //após encerrar o método, temos que o retorno dele foi zero e o valor de y é 1…
essa parte nao entendi quantas variaveis tem entao 2,uma na pilha??e a outra?Mas as variaves locais nao ficam todas la?
e desde ja agradeço sua atencao!!
se vc olhar o corpo do método, perceberá que tem uma variavel “retorno” que guarda o valor a ser retornado.
quote=RafaelVS]A atribuição é sempre a última operação a ser realizada… veja no passo a passo mais ou menos o q aconteceu:
y = incrementoPosFixado(y); //após encerrar o método, temos que o retorno dele foi zero e o valor de y é 1… mas aih estamos pegando o resultado, que foi zero, e atribuindo a y, que passa a ser zero.
[]'s[/quote]
[/quote]
Tudo bem mas me tira outra duvida
y++ é igual a y=y+1
System.out.println(y);//imprime 1;ok!!
entao por essa logica
y=y++ é igual y=y=y+1
deveria imprimir 0 ok?,mas…
class A{
public static void main(String a[]){
int y=0,a=0;
y=y++;
System.out.println(y);//tenho um resultado que é zero
//se fizer
a=a=a+1;
System.out.println(a);//tenho 1 outro resultado!!
Como fica??
}
}
veja…
quando vc usa y++ vc ta usando um operador unário pós-fixado… ele tem um funcionamento especial… como é esse funcionamento? primeiro lê-se o valor inicial do operando (que será o valor da expressão) e depois incrementa seu valor… o significado é: “incremente o valor de y e mas retorne o valor antigo dele”
quando vc usa a = a + 1, vc nao está usando um operador unário… não tem nenhum funcionamento especial aqui… então o que acontece? eu estou somando o valor de a, em seguida estou atribuindo esse valor a a… o operador “atribuição” também retorna um valor… e o valor que ele retorna é igual ao valor que foi atribuido. Assim sendo, como a + 1 retornou 1, então o valor da atribuição é 1.
Ou seja, se vc manda exibir y++, será exibido 0… se vc manda exibir a = a + 1, será exibido 1. Assim sendo, não será diferente se tentarmos atribuir essese valores a uma variável. Então, temos que:
y = y++; // valor final de y = 0
a = a = a + 1; // valor final de a = 1
pra concluir entao, sem testar, qual é o resultado dos sysouts?
[code]int x, y = 0;
y = y++;
y = y++;
x = y;
System.out.println(x);
System.out.println(y);[/code]
0 e 0
como assim o seria se fizesse:
int y = 0;
y = y++;
y = y++;
y = y++;
y = y++;
y = y++;
y = y++;
/…
y = y++;
y = y++;
y = y++;
y = y++;
y = y++;
y = y++;
sysout(y); // exibe 0
e agora?
[code]int x, y = 0;
y = y++;
x = y;
x = y++;
System.out.println(x);
System.out.println(y);[/code]
agora x eh 0 e y eh 1, ja que o valor de y na segunda operacao nao foi atribuido a y.
agora faz esse aqui, sem testar tb:
int x, y = 0;
y = y++;
x = x++;
x = y;
sysout(x);
sysout(y);
0,0 em java.
então, eu li que cada compilador trata do pos incremento de uma maneira diferente, ou seja, o resultado varia de compilador pra compilador.
testei em g++ o resultado foi outro.
[quote=formigaotts]0,0 em java.
então, eu li que cada compilador trata do pos incremento de uma maneira diferente, ou seja, o resultado varia de compilador pra compilador.
testei em g++ o resultado foi outro.[/quote]
Errado…
em Java isso vai dar erro de compilação, pois a variável x está tentando ser acessada sem antes ter sido inicializada:
int x, y=0;hehehhehehe (é esse tipo de pegadinha que lasca o cara na prova da certificação)