Newsgroup: it.comp.lang.c++
Titolo: Operatori unari

Sto studiando a scuola gli operatori unari di postincremento e di
postdecremento. Verrei chiedervi se ho capito bene visto che gli esempi del
mio libro non sono proprio il massimo.
Sia l'operatore di postincremento che di preincremento sommano uno alla
variabile a cui sono applicati. La differenza sta però nel valore restituito
dall'espressione. Nel caso dell'operatore di postincremento il valore
restituito è uguale a quello della variabile prima dell'incremento, nel caso
invece di quello di preincremento il valore restituito è quello della
variabile dopo l'incremento.
Ho capito giusto? Per fortuna che ho il ng, tre ore di informatica a scuola
non servono a nulla.
Grazie.
Ramses

 Ho capito giusto?
Si
--
Andrea Ferro
---------
Brainbench C++ Master. Scored higher than 97% of previous takers
Scores: Overall 4.46, Conceptual 5.0, Problem-Solving 5.0
More info 
http://www.brainbench.com/transcript.jsp?pid=2522556



Ehilà Ramses, siamo nello stesso team ma ci becchiamo sul NG iclc++
^_^.
Cmq si hai capito giusto ^_^.
----
Lawrence "Rhymes" Oluyede
rhy...@myself.com

...

Quello che tu dici è vero ma è un effetto della reale differenza. La
differenza tra i due operatori (anche quando non è contemplato alcun
ritorno di valore) è che il post incremento incrementa la variabile
dopo averla usata in una qualunque operazione o sistema di
indicizzazione, quello di pre incremento lo fa prima.
...è "quasi" uguale.

 ...è "quasi" uguale.
La reale differenza non e' questa che dici tu.
La reale:
    il post incremento: effettua una copia dell'istanza
        incrementa l'originale e restituisce la copia fatta
        prima;
    il preincremento: incrementa l'originale e lo restituisce.
//pre incremento
X& operator++()
 {
  //operazione di incremento (dipende da come e' fatta la classe X)
    .......
  return *this;
 }
//post incremento
 X operator++(int a)
 {
  X ret  *this;
  //incremento (dipende da come e' fatta la classe X)
    .....
  return ret;
 }
Ciao
Gaetano.
-- 
Posted from 
nts-03.mm.eutelsat.org
 [194.214.173.15] 
via Mailgate.ORG Server - 
http://www.Mailgate.ORG

 ...è "quasi" uguale.
La descrizione fatta da Ramses a me pare perfetta. Persino più simile a
quella dello standard che non la tua (ma sinceramente la tua non l'ho
capita fino in fondo).


    il preincremento: incrementa l'originale e lo restituisce.
Questo è quello che fai quando definisci tu gli operatori. Ma non è
garantito essere così per gli operatori predefiniti. La descrizione di
Ramses è la più corretta.
Nota che è perfettamente legale per un operatore di preincremento fare
una copia, incrementarla e resituire il risultato e in un secondo tempo
incrementare anche l'originale.
Idem per l'operatore di post incremento che puo' restituire l'originale
e rimandare a dopo il suo incremento.
I side effects (compresa quindi la variazione del valore della
variabile) possono avvenire in un qualunque momento purchè prima del
sequence point successivo.


 incrementare anche l'originale.
Ovviamente.
E' anche legale da questo punto di vista farne 10 di copie sceglierne
una a caso e incrementarla.
Non capisco come puo' un operatore dopo che ha
restituito il risultato incrementare in un secondo tempo l'originale.
Con un thread ? Alla chiamata successiva ?
Ciao
Gaetano.
-- 
Posted from 
dell-01.mm.eutelsat.org
 [194.214.173.17] 


 Gaetano.
 
Ciao
Fabio.
 
-- 
Posted from 
flopiano.mm.eutelsat.org
 [194.214.173.28] 


 Con un thread ? Alla chiamata successiva ?
In pseudo codice macchina:
++i :
carica i in un registro
incrementa il registro
copia il registro in cima allo stack
copia il registro su i
i++ :
carica i in un registro
copia il registro in cima allo stack
incrementa il registro
copia il registro su i
Ciao,
Nicola

 wrote in message
Y_xK7.137858$sq5.6...@news.infostrada.it...

Precisamente, inoltre tieni presente che nel caso del preincremento viene
ritornato un riferimento all'oggetto incrementato, mentre nel postincremento
viene ritornato un valore destro... Se non capisci di cosa parlo, allora
lascia perdere la seconda parte della frase e considera solo il
"Precisamente" :)

    il preincremento: incrementa l'originale e lo restituisce.
A questo proposito il mio libro fa un esempio e dice che:
i++;
č come dire:
temp = i, i = i + 1, temp
++i;
č come dire:
v = v + 1;
Ho capito quello ch intende, ma nel primo caso il compilatore veramente va a
dichiarare ed ad allocare spazio per la variabile temp oppure č solo
l'esempio che fa cosě?
Grazie a tutti.
Ramses

 "Precisamente" :)
Si, ho capito tutto. Intendi un R-value?
Ramses

 l'esempio che fa cosě?
Diciamo che lo fa ... e poi la ottimizza.
Per esempio:
a=m[i++]
diventa:
a = *(m+ (temp1 = i, i = i + 1, temp1) )
e quindi si semplifica in
a = (temp2 = m + i, i = i + 1, *temp2)
ovvero in
a = *(m + i), i = i + 1, a


 Ramses
"praticamente" si
//post incremento
 X operator++(int a)
 {
  X ret this;
  //incremento (dipende da come e' fatta la classe X)
    .....
  return ret;
 }
questo per quanto riguarda i tipi scritti da te.
Per i tipi primitivi il compilatore ci comporta diversamente.
Questo e' il comportamento di g++ 3.0:
void f()
{
    int i, a;
    a  ++i;
}
diventa:
        pushl   %ebp
        movl    %esp, %ebp
        subl    $8, %esp                // crea spazio sullo stack per i, a
        leal    -4(%ebp), %eax      // eax punta a i
        incl    (%eax)                    // incrementa eax ( i )
        movl    -4(%ebp), %eax   // copia i su eax
        movl    %eax, -8(%ebp)   //mette eax su a
        movl    %ebp, %esp
        popl    %ebp
        ret
void g()
{
    int i, a;
    a  i++;
}
diventa:
        pushl   %ebp
        movl    %esp, %ebp
        subl    $8, %esp                    // crea spazio sullo stack per
i, a
        movl    -4(%ebp), %eax        //copia i su eax
        movl    %eax, -8(%ebp)        //copia eax su a
        leal    -4(%ebp), %eax          //eax punta a i
        incl    (%eax)                        //incrementa eax ( i )
        movl    %ebp, %esp
        popl    %ebp
        ret
PS. Spero di non avere scordato nulla in questi anni
      che non mastico ASM.
Ciao
Gaetano.
-- 
Posted from 
dell-01.mm.eutelsat.org
 [194.214.173.17] 
