C Problemas com o operador x--

[Jardelt]

Boa tarde! Minha dúvida é em relação a o seguinte programa:int main()

{
    int x=10,;
    x=x--;

printf ("%d", x);
} 

Eu sei sobre operador pós-fixado e sei que quando faço x=x--, inicialmente o valor de X será x e não x-1. Minha dúvida é a seguinte: ao terminar o comando x-- , o valor de X deveria ter seu valor reduzido para x-1, mas quando peço para exibir o valor de x, ele NÃO é x-1 e sim X, logo o compilador entende x ao invés de x--. Por que isso ocorre?

//programa original

int main()
{
    int x=10,;
    x=x--;

printf ("%d", x);
} 



//como o compilador entende:

int main()
{
    int x=10,;
    x=x;

printf ("%d", x);
} 

 

Porque ele simplesmente ignora o --?????

 

 

 

[isrnick]

Na linha:

x=x--;

Primeiro x-- retorna o valor de x, que é 10, então a expressão da linha do código fica como "x=10".

Segundo x-- decrementa o valor atual de x, ou seja x passa a ter valor 9.

Terceiro a expressão x=10 é executada, atribuindo o valor 10 a variável x.

 

Logo, o valor final de x é 10.

[Felipe Electronic]

como mencionado pelo @isrnick, isso está acontecendo pois o compilador entendeu que independente de colocar o incremento ou simplesmente atribuir o valor, o resultado será o mesmo, assim ele sempre vai partir pra abordagem de reduzir o número de instruções para um mesmo resultado, é a chamada otimização, que por default (considerando um GCC) é -O3 que sai otimizando tudo que ele achar redundante.

[Asrety]

Olá @Jardelt, acredito que já tenha entendido o motivo disso a partir das explicações acima, e para fazer acontecer o que você quer, é necessário decrementar antes, ai ficaria com o valor 9.

x = --x;

 

[Ansi C]

Em 27/11/2018 às 15:07, Jardelt disse:

Por que isso ocorre?

Claro que ocorreu, antes de x receber o valor 10 ele é 9. O valor foi modificando quando a variável foi lida pela segunda vez na esquerda. Ou seja, a primeiro vez é na direita e a segunda vez é na esquerda

x= x--; é a mesma coisa que x= x - 1, x= 10;

 

[Jardelt]

 

Em 27/11/2018 às 19:26, Felipe Electronic disse:

@isrnick, isso está acontecendo pois o compilador entendeu que independente de colocar o incremento ou simplesmente atribuir o valor, o resultado será o mesmo, assim ele sempre vai partir pra abordagem de reduzir o número de instruções para um mesmo resultado, é a chamada otimização, que por default (considerando um GCC) é -O3 que sai otimizando tudo que ele achar redundante.

Muito obrigado! A otimização eu sei que ocorre, mas não entendo porque em x=x-1 ele fica 9 e em x=x-- ele fica 10. Em ambos ele recebe o valor de x e decrementa, mas os resultados são diferentes. Por que?

adicionado 8 minutos depois

Em 27/11/2018 às 15:32, isrnick disse:

Na linha:

x=x--;

Primeiro x-- retorna o valor de x, que é 10, então a expressão da linha do código fica como "x=10".

Segundo x-- decrementa o valor atual de x, ou seja x passa a ter valor 9.

Terceiro a expressão x=10 é executada, atribuindo o valor 10 a variável x.

 

Logo, o valor final de x é 10.

Muito obrigado pela sua resposta. Mas não consegui entender porque na terceira expressão o valor de x=10 é executado se na linha anterior o valor deste foi modificado para 9. Ele está fazendo x=10 duas vezes, quando eu só pedi para ele fazer 1 vez. Então para mim ficou sem sentido. Passo a passo:

Primeiro: x-- retorna o valor de 10. Beleza faz sentido, afinal ele vai diminuir logo tem que saber quanto vale x.

Segundo: x-- irá decrementar o valor ficando 9. Ok

Terceiro: mesmo tendo dado 9 na expressão anterior o compilador faz x=x, ao invés da expressão x=9. Seria isso? Então ele está usando x posterior da expressão da direita duas vezes, uma vez na primeira operação e outra vez aqui. Então isso não seria um erro afinal o x só aparece 1 vez sendo considerado duas vezes?

adicionado 12 minutos depois

49 minutos atrás, AnsiC disse:

Claro que ocorreu, antes de x receber o valor 10 ele é 9. O valor foi modificando quando a variável foi lida pela segunda vez na esquerda. Ou seja, a primeiro vez é na direita e a segunda vez é na esquerda

x= x--; é a mesma coisa que x= x - 1, x= 10;

 

Mas se o valor de X é 9, porque ele recebe 10? E porque a variável é lida duas vezes. Então o compilador utilizar o x para fazer x-- e utiliza o mesmo x para x=x ao invés de x=x-1? Para mim, o x ia receber o valor de 10, ficando x=--. Não entendi porque a variável é lida duas vezes? O x não está a esquerda, então não seria: x=x--, não seria a mesma coisa que: x=10, x=x-1?

[isrnick]

x-- faz 2 coisas, primeiro retorna o valor atual da variável x, e só depois decrementa 1 do valor de x.

 

Em x = x--, primeiro todas as operações do lado direito do = são realizadas, e só depois a operação atribuição é feita para a variável no lado esquerdo do =.

 

Logo, x-- primeiro retorna o valor atual 10, depois diminui x em 1 ficando igual a 9, mas este novo valor de x não é retornado.

 

Agora todas operações no lado direito do = foram realizadas, mas note que ainda não foi feita a operação de atribuição =, ainda falta realizar essa operação, mas como o valor retornado por x-- foi o valor original 10, a operação de atribuição ficou assim x = 10. E quando esta última operação é realizada o valor de x volta a ficar igual a 10.

[Ansi C]

2 horas atrás, Jardelt disse:

Mas se o valor de X é 9, porque ele recebe 10?

Porque esse foi o valor retornado pela variável antes de receber o decremento. O decremento acontece na esquerda para depois receber o 10 que já estava na direita.

[Simon Viegas]

O que eu entendi das explicações:

 

1#

Sobre:

x=x--;

 

Acontece algo como:

//primeiro faz o lado direito ao =, ficando com algo análogo a:
valorQueVouRetornar = x;
x = x-1;

//após faz o que está no lado esquerdo do =, ficando com algo análgo a:
x = valorQueVouRetornar; //logo, x, que tinha 9 quando foi decrementado acima, passou a ficar com 10 novamente

 

X é atualizado duas vezes.

 

 

 

2#

Sobre:

x=--x;

 

Acontece os mesmos passos, apenas com a diferença que é atualizando antes!

//primeiro faz o lado direito ao =, ficando com algo análogo a:
x = x-1;
valorQueVouRetornar = x;

//após faz o que está no lado esquerdo do =, ficando com algo análgo a:
x = valorQueVouRetornar; //logo, x, que tinha 9 quando foi decrementado acima, passou a ficar com 9 (o novo valor é igaul ao antigo)

Logo:

x=--x

é uma redundância, pois estará dando um valor igual para x duas vezes.

 

bastaria fazer:

--x;

 

 

 

3#

Concordando com o 2#, fica visível que x=x--, mesmo que funcionasse, seria também redundante..., pois um objetivo do -- antes ou depois da variável, está na possibilidade de [1] usar o valor da variável E [2] atualizar a variável, numa instrução só (como já citado, colocar -- antes ou depois entrará na questão da ordem das operações), ou seja, no seu código, você utiliza esses dois recursos para fazer a mesma coisa... no caso, o [1] para futuramente servir para atualizar o x lá no igual, mas isso já será feito no [2].

Para seu contexto, usaria algo como:

--x;

ou ainda:

x--;

ou

x=x-1;

ou

x-=1

ou

x=-1; //tô brincado!!! aqui vai simplesmente deixar x com o valor -1, rs

etc.

 

***

 

O que acham?

[Ansi C]

@Simon Viegas É isso aceitou da maneira correta. O mecânica de leitura e escrita é perfeita, pois todo declaração é avaliada aqui distitamente em dois tipo o lvalue, rvalue @Jardelt com isso a máquina sabe quem cede e quem recebe a informação em transito no código.