i = i ++; è indefinito. Anche i = foo (i ++) è indefinito?

Question

Per esempio:

int foo(int i) { return i; } 

int main() 
{ 
    int i = 0; 

    i = i++;  // Undefined 
    i = foo(i++); // ? 

    return 0; 
} 

Quale sarebbe l'attuale standard ISO C++ specificare per questo caso?

EDIT:

Ecco dove mi confondo:

Salvo quando diversamente indicato, valutazioni di operandi dei singoli operatori e di sottoespressioni delle singole espressioni sono non in sequenza.

Se un effetto collaterale su un oggetto scalare è non in sequenza rispetto a uno altro effetto collaterale sullo stesso oggetto scalare o un valore di calcolo utilizzando il valore dello stesso oggetto scalare, e non sono potenzialmente concomitanti (1.10), il comportamento è indefinito.

In tutti i casi, l'assegnazione viene sequenza dopo il valore calcolo degli operandi destro e sinistro, e prima che il valore calcolo dell'espressione assegnazione

ogni valutazione in funzione chiamante (comprese altre chiamate di funzione) che non è altrimenti specificatamente sequenziato prima o dopo l'esecuzione del corpo della funzione chiamata è sequenzialmente indeterminato con rispetto all'esecuzione della funzione chiamata.

Così sembra si potrebbe avere un calcolo del valore sul lato sinistro della cessione (appena i), e un effetto collaterale sul lato destro (la modifica di i da i++) che non sono in sequenza rispetto a vicenda.

EDIT2:

Per chi si trova qui, c'è davvero un grande spiegazione su sequenziamento che ho trovato here.

Answer 1

L'ultima frase nel tuo preventivo dice "non altrimenti specificamente sequenziato prima o dopo l'esecuzione del corpo della funzione chiamata" quindi la domanda è se l'incremento e l'assegnazione sono "altrimenti specificatamente sequenziati prima o dopo" il corpo della funzione.

1.9 [intro.execution] p15 ha la risposta:

Quando si chiama una funzione (se la funzione è in linea), ogni valore calcolo e lato effetto associato con qualsiasi espressione argomentazione, oppure con l'espressione postfissa che designa la funzione chiamata è sequenziata prima dell'esecuzione di ogni espressione o istruzione nel corpo della funzione chiamata.[Nota: I calcoli del valore e gli effetti collaterali associati alle diverse espressioni di argomento sono stati annullati. - nota end]

Quindi l'incremento di i accade prima che il corpo della funzione, e l'assegnazione di i accade dopo la funzione ritorna, quindi è perfettamente definiti.

Nella terminologia pre-C++ 11, la chiamata di funzione introduce un punto di sequenza tra l'incremento e l'assegnazione.

Answer 2

i = foo(i++); va bene, perché i++ viene eseguito prima che venga chiamato foo(). Viene eseguita una copia di i, quindi viene incrementato i, quindi la copia viene passata a foo(). E 'lo stesso di fare questo in modo esplicito:

int tmp = i++; 
i = foo(tmp);