O que significa i = (i, ++ i, 1) + 1; Faz?

Depois de ler esta resposta sobre comportamento indefinido e pontos de sequência, escrevi um pequeno programa:

#include <stdio.h>

int main(void) {
  int i = 5;
  i = (i, ++i, 1) + 1;
  printf("%d\n", i);
  return 0;
}

A saída é 2. Oh Deus, eu não vi o decréscimo chegando! O que esta acontecendo aqui?

Além disso, ao compilar o código acima, recebi um aviso dizendo:

px.c: 5: 8: aviso: o operando esquerdo da expressão de vírgula não tem efeito

  [-Wunused-value]   i = (i, ++i, 1) + 1;
                        ^

Por quê? Mas provavelmente será respondido automaticamente pela resposta da minha primeira pergunta.

Na expressão (i, ++i, 1), a vírgula usada é o operador de vírgula

o operador de vírgula (representado pelo token ,) é um operador binário que avalia seu primeiro operando e descarta o resultado, avalia o segundo operando e retorna esse valor (e tipo).

Como descarta seu primeiro operando, geralmente é útil apenas quando o primeiro operando tem efeitos colaterais desejáveis . Se o efeito colateral no primeiro operando não ocorrer, o compilador poderá gerar um aviso sobre a expressão sem efeito.

Portanto, na expressão acima, a extremidade esquerda iserá avaliada e seu valor será descartado. Em seguida ++i, será avaliado e aumentará i1 e novamente o valor da expressão ++iserá descartado, mas o efeito colateral para ié permanente . Então 1será avaliado e o valor da expressão será 1.

É equivalente a

i;          // Evaluate i and discard its value. This has no effect.
++i;        // Evaluate i and increment it by 1 and discard the value of expression ++i
i = 1 + 1;  

Observe que a expressão acima é perfeitamente válida e não invoca um comportamento indefinido porque há um ponto de sequência entre a avaliação dos operandos esquerdo e direito do operador de vírgula.

Citando C11, capítulo 6.5.17, operador de vírgula

O operando esquerdo de um operador de vírgula é avaliado como uma expressão nula; existe um ponto de sequência entre sua avaliação e a do operando certo. Então o operando certo é avaliado; o resultado tem seu tipo e valor.

Então, no seu caso,

(i, ++i, 1)

é avaliado como

1. i, é avaliado como uma expressão nula, valor descartado
2. ++i, é avaliado como uma expressão nula, valor descartado
3. finalmente, 1valor retornado.

Então, a declaração final parece

i = 1 + 1;

e ichega a 2. Acho que isso responde às duas perguntas,

• Como iobtém um valor 2?
• Por que existe uma mensagem de aviso?

Nota: Fwiw, como existe um ponto sequência presente após a avaliação do operando mão esquerda, uma expressão como (i, ++i, 1)não invocação UB, como uma pode geralmente pensar por engano.

i = (i, ++i, 1) + 1;

Vamos analisá-lo passo a passo.

(i,   // is evaluated but ignored, there are other expressions after comma
++i,  // i is updated but the resulting value is ignored too
1)    // this value is finally used
+ 1   // 1 is added to the previous value 1

Então, obtemos 2. E a tarefa final agora:

i = 2;

O que quer que estivesse em i antes de ser substituído agora.

O resultado de

(i, ++i, 1)

é

1

Para

(i,++i,1) 

a avaliação ocorre de tal forma que o ,operador descarta o valor avaliado e retém apenas o valor mais correto que é1

assim

i = 1 + 1 = 2

Você encontrará boas leituras na página wiki do operador Vírgula .

Basicamente,

... avalia seu primeiro operando e descarta o resultado, avalia o segundo operando e retorna esse valor (e tipo).

Isso significa que

(i, i++, 1)

por sua vez, avaliará i, descartará o resultado, avaliará i++, descartará o resultado e, em seguida, avaliará e retornará 1.

Você precisa saber o que o operador de vírgula está fazendo aqui:

Sua expressão:

(i, ++i, 1)

A primeira expressão i,, é avaliada, a segunda expressão ++i,, é avaliada e a terceira expressão 1, é retornada para toda a expressão.

Assim, o resultado é: i = 1 + 1.

Para sua pergunta de bônus, como você vê, a primeira expressão inão tem efeito algum, então o compilador reclama.

A vírgula tem uma precedência "inversa". É isso que você obtém de livros antigos e manuais C da IBM (anos 70/80). Portanto, o último 'comando' é o que é usado na expressão pai.

No C moderno, seu uso é estranho, mas é muito interessante no antigo C (ANSI):

do { 
    /* bla bla bla, consider conditional flow with several continue's */
} while ( prepAnything(), doSomethingElse(), logic_operation);

Embora todas as operações (funções) sejam chamadas da esquerda para a direita, apenas a última expressão será usada como resultado para 'while' condicional. Isso impede o manuseio de 'goto's' para manter um bloco de comandos exclusivo a ser executado antes da verificação da condição.

EDIT: Isso evita também uma chamada para uma função de manipulação que pode cuidar de toda a lógica nos operandos da esquerda e, portanto, retornar o resultado lógico. Lembre-se de que não tínhamos função embutida no passado de C. Portanto, isso poderia evitar uma sobrecarga de chamada.