[C] risultato di: a=a++;

[gege_63]

il quesito è il seguente:
cosa viene stampato come valore di a dal seguente frammento di sw:

a=0;
a=a++;
printf(a);

ora:
lo so che a=a++; non ha senso pratico, ma qualcuno sa spiegarmi perchè il valore finale di a è 0 e non 1?
O meglio: è vero che l'incremento avviene dopo l'assegnazione, però riguarda sempre la variabile a.
Riassumendo: ero convinto che a alla fine valesse 1 ed invece vale 0.
grazie a che vorrà aiutarmi con questo problema esclusivamente teorico e poco pratico.

[Agat]

Ma a e' int ?

Supposto sia int, fa proprio 1

  int a=0;
  a=a++;
  printf("a=%d\n", a);

Edit: Dimenticavo che il perche', e' la precedenza inferiore dell'assegnamento rispetto all'incremento

[Black imp]

Originariamente inviato da gege_63

il quesito è il seguente:
cosa viene stampato come valore di a dal seguente frammento di sw:

a=0;
a=a++;
printf(a);

ora:
lo so che a=a++; non ha senso pratico, ma qualcuno sa spiegarmi perchè il valore finale di a è 0 e non 1?
O meglio: è vero che l'incremento avviene dopo l'assegnazione, però riguarda sempre la variabile a.
Riassumendo: ero convinto che a alla fine valesse 1 ed invece vale 0.
grazie a che vorrà aiutarmi con questo problema esclusivamente teorico e poco pratico.

scusa tu stai compilando con qualche livello di ottimizzazione?

l'ho appena compilato e mi dà 1.

[Galdor]

In effetti dovrebbe stampare 1 anche secondo me...

[flx2000]

a=0 !!!!

1. Il buffer si predispone per fare a = a ponendo la seconda a nello stack
2. Il buffer incrementa a di 1 la a nello stack
3. Il buffer esegue a = a considerando la a PRIMA dell'incremento perché è a++ e non ++a
4. Lo stack viene eluso dalla precedenza
5. Il buffer esce con a = 0

[agente mm8]

Provato e stampa 1... come mi sembra anche logico, del resto.

[flx2000]

Originariamente inviato da Antonio23

quindi secondo te l'incremento quando viene fatto? mica l'ho capita la spiegazione che hai dato... e soprattutto, l'hanno compilato e stampa 1 (non ho tempo di provarlo personalmente ora...)

E' un tipico caso di programmazione che dipende dal compilatore.

L'ho verificato io stesso pochi istanti fa con VS C++ e C# e dà 0.
Dovrei provare con g++ per vedere se dà 1.

Di fatto, la "logica" naturale (del gcc ad esempio) vuole che si legga in questo modo: "Viene eseguita l'operazione a destra e alla fine assegnata alla parte sinistra".
Allora è chiaro che le fasi sarebbero:
1. Eseguo l'incremento (a passa da 0 a 1)
2. Lo assegno a se stesso (a resta a, cioè 1)

Diversi compilatori possono generare diversi risultati se si trovano a lavorare su funzioni di questo tipo perché dipende tutto da come usano lo stack, che non a caso è una delle cose che differenzia maggiormente tra loro i compilatori.

[||ElChE||88]

a viene usato sia come come lvalue che rvalue nell'ambito dello stesso sequence-point, quindi (secondo lo standard C++) il risultato di quell'espressione non è definito.

[gege_63]

non mi aspettavo risposte così numerose al mio quesito: grazie.
il mio risultato , cioè 0, lo ottengo sia con DEVC++ che con visual C#.

vorrei sapere, da chi ottiene 1, con che compilatore lavora.
grazie ancora a tutti.

[gege_63]

Originariamente inviato da flx2000

Di fatto, la "logica" naturale (del gcc ad esempio) vuole che si legga in questo modo: "Viene eseguita l'operazione a destra e alla fine assegnata alla parte sinistra".
Allora è chiaro che le fasi sarebbero:
1. Eseguo l'incremento (a passa da 0 a 1)
2. Lo assegno a se stesso (a resta a, cioè 1)

non sono tanto daccordo, perchè è un postincremento:
se il codice fosse

a=0;
b=a++;
printf(b);

il risultato sarebbe sicuramente b=0, perchè l'incremento avviene dopo l'assegnazione.

[flx2000]

Originariamente inviato da gege_63

non sono tanto daccordo, perchè è un postincremento:
se il codice fosse

a=0;
b=a++;
printf(b);

il risultato sarebbe sicuramente b=0, perchè l'incremento avviene dopo l'assegnazione.

Se guardi bene anch'io ho dato risposta 0. La spiegazione che citi è un'ipotesi che ho cercato di dare per giustificare i casi in cui è uscito 1 (dando per scontato che qualcuno abbia effettivamente ottenuto 1)

[AnonimoVeneziano]

Al di là del fatto dell'implementazione specifica del compilatore, secondo me il risultato più giusto (e che uno si aspetta da questa operazione) è zero.

La ragione è che una espressione come "a++" viene valutata prima dell'incremento, quindi il valore in cui una espressione come "a++" , se il valore di a prima dell'espressione è 0, è proprio 0.

Ricapitolando quindi :

a=0; viene assegnato ad a il valore 0
a=a++; prima viene valutato "a++" e quindi 0, poi viene effettuato l'incremento, quindi a = 1 , poi però viene effettuato l'assegnamento con il valore 0 memorizzato in precedenza dalla valutazione di a++ e quindi a torna ad essere 0.

Ciao

[Galdor]

Originariamente inviato da gege_63

il mio risultato , cioè 0, lo ottengo sia con DEVC++ che con visual C#.
vorrei sapere, da chi ottiene 1, con che compilatore lavora.
grazie ancora a tutti.

Con Visual C++ 2008 express edition a me stampa 1 che credo sia il risultato più logico...
Pensando a come funzioni lo stack e il compilatore probabilmente è giusto che esca 0, ma per logica dovrei ottenere 1, se metto quel ++ vorrà pur dire che voglio incrementare a no? se lo faccio prima o dopo il risultato non dovrebbe comunque cambiare; mi sembra più un "difetto" del compilatore

[kralizec]

Originariamente inviato da AnonimoVeneziano

Al di là del fatto dell'implementazione specifica del compilatore, secondo me il risultato più giusto (e che uno si aspetta da questa operazione) è zero.

La ragione è che una espressione come "a++" viene valutata prima dell'incremento, quindi il valore in cui una espressione come "a++" , se il valore di ha prima dell'espressione è 0, è proprio 0.

Ricapitolando quindi :

a=0; viene assegnato ad a il valore 0
a=a++; prima viene valutato "a++" e quindi 0, poi viene effettuato l'incremento, quindi a = 1 , poi però viene effettuato l'assegnamento con il valore 0 memorizzato in precedenza dalla valutazione di a++ e quindi a torna ad essere 0.

Ciao

Allora, a++ è un POST incremento, significa che, al contrario di ++a, l'incremento della variabile avviene DOPO l'assegnamento, quindi il programma dovrebbe procedere come segue:

#include <stdio.h>

int main(){
	int a; // Inizializzazione
	
        a=0; // assegnazione di 0 ad "a"

	a=a++;
/* Questa dovrebbe tradursi così:
        a=a; Assegnazione di 0 ad a, di nuovo
        a++; incremento di a, quindi dopo l'istruzione: a = 1;
*/
	printf("a=%i\n", a); // Stampa
}

Questa interpretazione, secondo me, spiega correttamente il fatto che il risultato sia 1, provato su macOS, con gcc 4.4.0 20080801 (experimental) e su macchina virtuale con ubuntu, con gcc 4.4.1 (Ubuntu 4.4.1-4ubuntu9).

Non so come possa venire 0 a qualcuno, a meno di errori di trascrizione del codice, vorrebbe dire che il compilatore usato ha dei problemi rispetto allo standard nella gestione degli operatori come ++

[flx2000]

Originariamente inviato da kralizec

Allora, a++ è un POST incremento, significa che, al contrario di ++a, l'incremento della variabile avviene DOPO l'assegnamento, quindi il programma dovrebbe procedere come segue:

#include <stdio.h>

int main(){
	int a; // Inizializzazione
	
        a=0; // assegnazione di 0 ad "a"

	a=a++;
/* Questa dovrebbe tradursi così:
        a=a; Assegnazione di 0 ad a, di nuovo
        a++; incremento di a, quindi dopo l'istruzione: a = 1;
*/
	printf("a=%i\n", a); // Stampa
}

Questa interpretazione, secondo me, spiega correttamente il fatto che il risultato sia 1, provato su macOS, con gcc 4.4.0 20080801 (experimental) e su macchina virtuale con ubuntu, con gcc 4.4.1 (Ubuntu 4.4.1-4ubuntu9).

Non so come possa venire 0 a qualcuno, a meno di errori di trascrizione del codice, vorrebbe dire che il compilatore usato ha dei problemi rispetto allo standard nella gestione degli operatori come ++

Appena riprovato.
Visual Studio 2008, C#:

{
    int a = 0;
    a = a++;
}

Il breakpoint sulla parentesi conclusiva segna chiaramente a = 0 in fase di esecuzione del codice.

[||ElChE||88]

Originariamente inviato da Galdor

mi sembra più un "difetto" del compilatore

Originariamente inviato da kralizec

vorrebbe dire che il compilatore usato ha dei problemi rispetto allo standard nella gestione degli operatori come ++

E dire che l'ho già scritto sopra...

Originariamente inviato da ISO/IEC 14882:2003(E) C++ Standard

Except where noted, the order of evaluation of operands of individual operators and subexpressions of individual
expressions, and the order in which side effects take place, is unspecified. Between the previous
and next sequence point a scalar object shall have its stored value modified at most once by the evaluation
of an expression. Furthermore, the prior value shall be accessed only to determine the value to be stored.
The requirements of this paragraph shall be met for each allowable ordering of the subexpressions of a full
expression; otherwise the behavior is undefined. [Example:
i = v[i++]; // the behavior is unspecified
i = 7, i++, i++; // i becomes 9
i = ++i + 1; // the behavior is unspecified
i = i + 1; // the value of i is incremented

[Galdor]

Ho capito che lo standard non definisce un comportamento preciso in questo caso, ma se tu dovessi scrivere un compilatore che esegue quelle istruzioni gli faresti tornare 1 o 0 ?
Chiaro che sia che torni uno o l'altro il compilatore rispetterà lo standard, ma IMHO se torna 1 è meglio

[||ElChE||88]

Originariamente inviato da Galdor

Ho capito che lo standard non definisce un comportamento preciso in questo caso, ma se tu dovessi scrivere un compilatore che esegue quelle istruzioni gli faresti tornare 1 o 0 ?
Chiaro che sia che torni uno o l'altro il compilatore rispetterà lo standard, ma IMHO se torna 1 è meglio

Se lo standard dice che non è definito allora il compilatore può restituire quello che gli pare, che ti piaccia o meno.

[kralizec]

ok, abbiamo capito che non è ben definito il comportamento, ma c'è anche da dire che tu hai quotato è dello standard del c++, non del c

per fix2000, Visual Studio, per quanto riguarda la mia esigua esperienza, si rivela spesso discostante da gcc... per non parlare del fatto che tu hai compilato in C# e non in C

io ho solo riportato l'output delle mie compilazioni, che rispecchiano (fortunatamente per me) le mie aspettative

[||ElChE||88]

Originariamente inviato da kralizec

ok, abbiamo capito che non è ben definito il comportamento, ma c'è anche da dire che tu hai quotato è dello standard del c++, non del c

Azz, hai ragione, non so perché pensavo si parlasse di C++.

Comunque non cambia molto

Originariamente inviato da ISO/IEC 9899:TC2 C99 Standard

Between the previous and next sequence point an object shall have its stored value
modified at most once by the evaluation of an expression. Furthermore, the prior value
shall be read only to determine the value to be stored.

This paragraph renders undefined statement expressions such as
i = ++i + 1;
a[i++] = i;