[Linguaggi] Prima l-valore o r-valore?

[Gremo]

Ciao a tutti. Sul mio libro c'è un semplice esempio degli effetti collaterali che si possono verificare in merito al calcolo di l-valore e r-valore.
L'esempio è il seguente (a è un vettore):

b = 0;
a[f(3)] = a[f(3)] + 1;

int f (int n)
{
   if (b == 0)
   {
      b = 1;
      return 1;
   }
   else
      return 2;
}

Quello che si ottiene è assegnare il valore di a[1] + 1 ad a[2] (secondo il libro). Ma negli assegnamenti lo l-valore non deve essere calcolato prima?

Grazie dell'aiuto

[Z80Fan]

Originariamente inviato da Gremo

Ciao a tutti. Sul mio libro c'è un semplice esempio degli effetti collaterali che si possono verificare in merito al calcolo di l-valore e r-valore.
L'esempio è il seguente (a è un vettore):

b = 0;
a[f(3)] = a[f(3)] + 1;

int f (int n)
{
   if (b == 0)
   {
      b = 1;
      return 1;
   }
   else
      return 2;
}

Quello che si ottiene è assegnare il valore di a[1] + 1 ad a[2] (secondo il libro). Ma negli assegnamenti lo l-valore non deve essere calcolato prima?

Grazie dell'aiuto

No, il compilatore genera il codice per prima calcolare il r-value, poichè è quello che gli serve per portare avanti l'espressione: se analizzi un codice più semplice:
a=b+3;
prima viene eseguito b+3, poi viene eseguito a=x dove x è il risultato di b+3.
per questo viene eseguito il f(3) del a[f(3)] + 1, perchè i passi che esegue per portare avanti l'espressione sono:
- Trova l'indice del vettore ( chiama f(3) nel r-value)
- preleva l'elemento a quella posizione nel vettore (p. es: 5 )
- esegui 5+1
- trova l'indice del vettore nella l-value
- memorizza il risultato precedente nella posizione del vettore calcolata.

Generalmente tieni presente che un'espressione viene valutata da destra verso sinistra, ma anche questa non è una regola fissa, sopratutto in espressioni più complesse, metti:
a[ f(1) ] = ( a[ f(2) ] +4 ) * a[ f(3) ] ;
Viene prima eseguita la chiamata f(2), poi la f(3) e quindi la f(1).

Spero di essere stato chiaro

[Gremo]

Originariamente inviato da Z80Fan

No, il compilatore genera il codice per prima calcolare il r-value, poichè è quello che gli serve per portare avanti l'espressione: se analizzi un codice più semplice:
a=b+3;
prima viene eseguito b+3, poi viene eseguito a=x dove x è il risultato di b+3.
per questo viene eseguito il f(3) del a[f(3)] + 1, perchè i passi che esegue per portare avanti l'espressione sono:
- Trova l'indice del vettore ( chiama f(3) nel r-value)
- preleva l'elemento a quella posizione nel vettore (p. es: 5 )
- esegui 5+1
- trova l'indice del vettore nella l-value
- memorizza il risultato precedente nella posizione del vettore calcolata.

Generalmente tieni presente che un'espressione viene valutata da destra verso sinistra, ma anche questa non è una regola fissa, sopratutto in espressioni più complesse, metti:
a[ f(1) ] = ( a[ f(2) ] +4 ) * a[ f(3) ] ;
Viene prima eseguita la chiamata f(2), poi la f(3) e quindi la f(1).

Spero di essere stato chiaro

Ciao, innanzitutto grazie mille Il discorso è abbastanza chiaro, anche se non campisco perchè il compilatore in x = b + 3 debba prima valutare l'r-valore: il risultato, qualsiasi esso sia, deve essere memorizzato in x, quindi occorre in ogni caso valutare anche la locazione, e questa valutazione può essere fatta anche prima...o sbaglio?
Inolte nel tuo ultimo esempio non mi è chiarissimo perché viene prima f(2), poi f(3) e poi f(1): gli esercizi che devo svolgere sono proprio di questo tipo, vorrei cercare di capirli bene...
Ti ringrazio per l'aiuto

[Z80Fan]

Originariamente inviato da Gremo

Ciao, innanzitutto grazie mille Il discorso è abbastanza chiaro, anche se non campisco perchè il compilatore in x = b + 3 debba prima valutare l'r-valore: il risultato, qualsiasi esso sia, deve essere memorizzato in x, quindi occorre in ogni caso valutare anche la locazione, e questa valutazione può essere fatta anche prima...o sbaglio?
Inolte nel tuo ultimo esempio non mi è chiarissimo perché viene prima f(2), poi f(3) e poi f(1): gli esercizi che devo svolgere sono proprio di questo tipo, vorrei cercare di capirli bene...
Ti ringrazio per l'aiuto

Proviamola a mettere in questo modo: come sai gli operatori matematici ( + - * / ) hanno una precedenza ben definita, così pure tutti gli operatori del C(++), ad esempio un po' di operatori messi in ordine decrescente di precedenza (in alto quello con più precedenza, presi dal mio libro di c++):
( ) Parentesi
[ ] Indicizzazione di un array
. selezione di un membro tramite oggetto
++ postincremento
& indirizzo
* moltiplicazione
/ divisione
+ somma
- sottrazione
(altri)
= assegnazione
+= assegnazione con somma

come vedi le assegnazioni (ce ne sono altre) sono gli operatori con la minor precedenza (tralasciando l'operatore virgola), quindi la loro esecuzione viene eseguita per ultima, in questo esempio:
k = c * (a+b) - 4
la priorità maggiore ce la ha (a+b), perchè è racchiusa tra parentesi, poi viene *c, perchè ha la precedenza sul -4, poi viene la sottrazione - 4 ed infine l'assegnazione su k, poichè l'assegnazione ha la precedenza inferiore.
A noi può sembrare un po' strano, perchè siamo tenuti a leggere da sinistra a destra, ma il compilatore lavora solo sulle precedenze e le regole di precedenza gli dicono di gestire l'assegnazione per ultima.
Tornando all'esempio precedente:
a[ f(1) ] = ( a[ f(2) ] +4 ) * a[ f(3) ] ;
Il compilatore valuta (a[ f(2) ] +4) per prima per via delle parentesi, ma per farlo deve valutare a[ .. ] poichè l'indicizzazione ha precedenza superiore alla somma, e per trovare l'indice deve eseguire f(2). Solo dopo che ha risolto questo calcolo ed esaurito la precedenza può analizzare a[ f(3) ], di nuovo, prima gli operatori [ ] (quindi esegue f(3) ), poi la moltiplicazione con il semitotale che aveva calcolato prima, quindi ha il risultato finito e può eseguire l'assegnazione, esegue l'ultimo [ ] e quindi effettua definitivamente l'assegnazione.
Meglio così?