Cosa significa i = (i, ++ i, 1) + 1; fare?

Dopo aver letto questa risposta su comportamenti indefiniti e punti di sequenza, ho scritto un piccolo programma:

#include <stdio.h>

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

L'output è 2. Oh Dio, non ho visto arrivare il declino! Cosa sta succedendo qui?

Inoltre, durante la compilazione del codice precedente, ho ricevuto un avviso che diceva:

px.c: 5: 8: avviso: l'operando di sinistra dell'espressione virgola non ha alcun effetto

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

Perché? Ma probabilmente riceverà automaticamente risposta dalla mia prima domanda.

Nell'espressione (i, ++i, 1), la virgola utilizzata è l' operatore virgola

l'operatore virgola (rappresentato dal token ,) è un operatore binario che valuta il suo primo operando e scarta il risultato, quindi valuta il secondo operando e restituisce questo valore (e tipo).

Poiché scarta il suo primo operando, è generalmente utile solo quando il primo operando ha effetti collaterali desiderabili . Se l'effetto collaterale sul primo operando non si verifica, il compilatore può generare un avviso sull'espressione senza alcun effetto.

Quindi, nell'espressione precedente, iverrà valutata la parte più a sinistra e il suo valore verrà scartato. Quindi ++iverrà valutato e incrementerà idi 1 e ancora il valore dell'espressione ++iverrà scartato, ma l'effetto collaterale iè permanente . Quindi 1verrà valutato e il valore dell'espressione sarà 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;  

Si noti che l'espressione sopra è perfettamente valida e non invoca un comportamento indefinito perché esiste un punto di sequenza tra la valutazione degli operandi sinistro e destro dell'operatore virgola.

Citando da C11, capitolo 6.5.17, Operatore virgola

L'operando di sinistra di un operatore virgola viene valutato come espressione nulla; esiste un punto di sequenza tra la sua valutazione e quella dell'operando giusto. Quindi viene valutato l'operando giusto; il risultato ha il suo tipo e valore.

Quindi, nel tuo caso,

(i, ++i, 1)

viene valutato come

1. i, viene valutato come espressione nulla, valore scartato
2. ++i, viene valutato come espressione nulla, valore scartato
3. infine, il 1valore restituito.

Quindi, la dichiarazione finale sembra

i = 1 + 1;

e iarriva a 2. Immagino che questo risponda ad entrambe le tue domande,

• Come i ottiene un valore 2?
• Perché c'è un messaggio di avviso?

Nota: FWIW, poiché è presente un punto di sequenza dopo la valutazione dell'operando di sinistra, un'espressione simile (i, ++i, 1)non invocherà UB, come si potrebbe generalmente pensare per errore.

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

Analizziamolo passo dopo 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

Quindi otteniamo 2. E il compito finale ora:

i = 2;

Qualunque cosa fosse in me prima che sia sovrascritta ora.

Il risultato di

(i, ++i, 1)

è

1

Per

(i,++i,1) 

la valutazione avviene in modo tale che l' ,operatore scarti il ​​valore valutato e manterrà il valore più giusto1

Così

i = 1 + 1 = 2

Troverai delle buone letture sulla pagina wiki dell'operatore Comma .

Fondamentalmente

... valuta il suo primo operando e scarta il risultato, quindi valuta il secondo operando e restituisce questo valore (e tipo).

Ciò significa che

(i, i++, 1)

a sua volta, valuterà i, scarterà il risultato, valuterà i++, scarterà il risultato, quindi valuterà e restituirà 1.

Devi sapere cosa sta facendo l'operatore virgola qui:

La tua espressione:

(i, ++i, 1)

iViene valutata la prima espressione, la seconda espressione ++i, e la terza espressione,1 viene restituita per l'intera espressione.

Quindi il risultato è: i = 1 + 1 .

Per la tua domanda bonus, come vedi, la prima espressione inon ha alcun effetto, quindi il compilatore si lamenta.

La virgola ha una precedenza "inversa". Questo è ciò che otterrai da vecchi libri e manuali C di IBM (anni '70 / '80). Quindi l'ultimo 'comando' è quello che viene usato nell'espressione genitore.

Nella C moderna il suo uso è strano ma è molto interessante nella vecchia C (ANSI):

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

Mentre tutte le operazioni (funzioni) vengono chiamate da sinistra a destra, solo l'ultima espressione verrà utilizzata come risultato per "while" condizionale. Questo impedisce la gestione di 'goto's per mantenere un blocco unico di comandi da eseguire prima del controllo delle condizioni.

EDIT: Questo evita anche una chiamata a una funzione di gestione che potrebbe occuparsi di tutta la logica degli operandi di sinistra e quindi restituire il risultato logico. Ricorda che, in passato non avevamo una funzione inline. Quindi, questo potrebbe evitare un overhead di chiamata.