[c] ma queste righe non sono uguali?

[NA01]

stavo riguardando uno dei primi esercizi di uno dei corsi dell'università. robbbbba facile, e poi io sono beccio, quell'esame me lo sono mangiato... mmmmmmmh.. forse no, mi sono venuti dei dubbi :sofico: :cool: :mbe:
la linea dell'umiliazione è questa :D


mq->lg=((mq->lg+1)%MAX);


ooooookey!
data mq un puntatore a struttura perfettamente allocata nella mia mente doveva sommarci uno, farci un banale modulo 16 (è questo che vale MAX) e riassegnarlo a lg....
nono, col cavolo che lo fa!
alemeno non su quel codice...

però lo fa questa linea...

mq->lg++ % MAX;


che non avrei mai scritto non sapendo dove è che avviene l'assegnazione.
ok, al di là che l'ultima opzione non mi sarei nemmeno sognato di scriverla non capisco che differenza ci sia tra le due righe....

sapete illuminarmi? :confused:

ciao ciao! :D

[andbin]

Entrambe le istruzioni sono corrette sintatticamente ma ... il risultato è molto differente.
mq->lg=((mq->lg+1)%MAX);Questa espressione funziona proprio come ci si aspetta (non capisco perché dici che non funziona :confused: ). Per prima cosa calcola mq->lg più 1, poi ne calcola il modulo 16 e il risultato lo riassegna in mq->lg. Questo vuol dire che mq->lg può valere al massimo 15 e se prima della espressione vale 15, fa il "rollover" e riparte da 0. Questa, in sintesi è la logica di funzionamento.

mq->lg++ % MAX;Questa invece non è una assegnazione. Attenzione: viene prima calcolato il modulo mq->lg % MAX e poi solo dopo viene incrementato mq->lg. Non è un comportamento strano! È dovuto al post-incremento che viene eseguito solo dopo che è stata usata la variabile.
Il risultato del modulo però non va a finire in mq->lg (perché non è una assegnazione) ma va a finire nel risultato della espressione. Messa così una espressione ... non serve a niente, perché il risultato del modulo ... si "perde".

Supponiamo di avere il seguente codice (supponiamo che lg sia un intero):
mq->lg = 14;

printf ("espr: %d\n", mq->lg++ % MAX);
printf ("mq->lg: %d\n", mq->lg);

printf ("espr: %d\n", mq->lg++ % MAX);
printf ("mq->lg: %d\n", mq->lg);

printf ("espr: %d\n", mq->lg++ % MAX);
printf ("mq->lg: %d\n", mq->lg);

printf ("espr: %d\n", mq->lg++ % MAX);
printf ("mq->lg: %d\n", mq->lg);Questo codice stamperebbe:
espr: 14
mq->lg: 15
espr: 15
mq->lg: 16
espr: 0
mq->lg: 17
espr: 1
mq->lg: 18Come vedi, mq->lg viene sempre incrementato (dopo l'uso della espressione) e il risultato della espressione, invece di "perdersi" va a finire nel parametro della printf.

Spero di essere stato chiaro, naturalmente. ;)