Eu tenho uma pergunta, como o compilador opera no seguinte código:
#include<stdio.h>
int main(void)
{
int b=12, c=11;
int d = (b == c++) ? (c+1) : (c-1);
printf("d = %i\n", d);
}
Eu não sou certo porque o resultado é d = 11
.
Eu tenho uma pergunta, como o compilador opera no seguinte código:
#include<stdio.h>
int main(void)
{
int b=12, c=11;
int d = (b == c++) ? (c+1) : (c-1);
printf("d = %i\n", d);
}
Eu não sou certo porque o resultado é d = 11
.
Respostas:
Em int d = (b == c++) ? (c+1) : (c-1);
:
c++
é o valor atual de c
11. Separadamente, c
é incrementado para 12.b == 11
é falso, pois b
é 12.(b == c++)
é falso, (c-1)
é usado. Além disso, o incremento de c
até 12 deve ser concluído neste ponto.c
é 12, c-1
é 11.d
é inicializado com esse valor, 11.De acordo com o padrão C (operador condicional 6.5.15)
4 O primeiro operando é avaliado; existe um ponto de sequência entre sua avaliação e a avaliação do segundo ou terceiro operando (o que for avaliado). O segundo operando é avaliado apenas se o primeiro comparar com 0; o terceiro operando é avaliado apenas se o primeiro for comparado a 0; o resultado é o valor do segundo ou terceiro operando (o que for avaliado), convertido para o tipo descrito abaixo.110)
Então, na expressão inicial desta declaração
int d = (b == c++) ? (c+1) : (c-1);
a variável b
é comparada com o valor da variável c
porque o operador pós-incremento retorna o valor do seu operando antes de incrementá-lo.
Como os valores não são iguais entre si ( b
é definido como 12 enquanto c
é definido como 11), a subexpressão (c-1)
é avaliada.
De acordo com a citação, existe um ponto de sequência após a avaliação da condição do operador. Isso significa que após a avaliação da condição c
tem o valor 12
após a aplicação do operador pós-incremento à variável c
. Como resultado, a variável d é inicializada pelo valor 1
( 12 - 1
).
?:
. Como normalmente em C, combinar ++
com outras operações no mesmo operando é um comportamento indefinido. E esse código só funciona previsivelmente porque ?:
possui várias regras especiais de floco de neve.
Porque a condição é falsa, portanto, o false
caso acontecerá :, c-1
mas desde que você incrementou c
a condição em c++
, portanto, c
é agora 12
. O resultado é 12-1, que é 11.
EDIT: O que OP entendeu mal foi o pós-incremento.
Então, o que realmente acontece é assim:
#include<stdio.h>
int main(void)
{
int b=12, c=11;
int d;
if (b == c) { // 12 == 11 ? -> false
c = c + 1;
d = c + 1;
} else { // this executes since condition is false
c = c + 1; // post increment -> c++ -> c = 12 now
d = c - 1; // 12 - 1 = 11 -> d = 11
}
printf("d = %i\n", d);
}
c++
a condição. A condição é falsa, mas o valor original de c
é usado para calcular c - 1
, não a versão incrementada.
c++
e++c
c++
é o operador pós- incremento. O valor de c++
é 11, com o efeito colateral de fazer c == 12
. ++c
teria o valor de 12.
Consulte Operador ternário.
Sintaxe
doença ? value_if_true: value_if_false
Então você escreveu
int d = (b == c++) ? (c+1) : (c-1);
Nessa situação, o resultado será 11 porque, após as verificações, o valor 'c' é aumentado (c + 1 = 12) e somente depois disso define o valor 'd' como c (12) -1, que é 11.
Se você usou, por exemplo:
int d = (b == ++c) ? (c+1) : (c-1);
O valor "c" seria aumentado antes de verificar a instrução, portanto seria verdadeiro e o valor "d" seria c (12) +1, que é 13.