Newsgroup: it.comp.lang.c++
Titolo: incremento & decremento

Credo di non aver capito bene gli operatori post e prefissi, Facciano un 
esempio:
int x,z=2;
x=(++z)-1;   // x = 2, z =3
e questo mi sembra abbastanza logico, perchè succede:
z viene incrementato di 1 e quindi z =3
z-1 == 3-1 = 2 quindi x =2
-------
int x, z=2;
x=(z++)-1 // x = 1, z =3
per z non ci sono problemi, ma non ho capito perchè x è unguale a 1?
Dove sbaglio?
grazie
-- 
Abruzzo Silvio
studente, 16 anni
goku_...@libero.it
silvi...@aruba.it
 <---old e-mail address
http://utenti.tripod.it/abruzzosilvio/
 
^____^

Dove sbaglio?
x = (z++) - 1;
equivale a:
{
   x = z - 1;
   z++;
}
--
Andrea Laforgia (mica uno qualunque...)

 
-- 


perchè aggiunge 1 al valore di z
No, perche' esegue un pre-incremento, cioe' un incremento
precedente all'utilizzo del valore della variabile.
Anche z++ aggiunge 1 al valore di z, ma non nello stesso
istante di ++z.
--
Andrea Laforgia - walkietalkie(at)
libero.it
http://www.geocities.com/AndreaLaforgia

 istante di ++z.
si daccordo, ma in (z++)-1
lui non calcola prima il valore interno alle parentesi e poi lo restituisce 
al programma che esegue la sottrazione, cioè:
z = 2;
(z++)-1 
(2++)-1
(3)-1 == 3-1
2
cosa c'è di sbagliato qui?


 perchè aggiunge 1 al valore di z
Forse e' piu' semplice se provi a considerare quello che sarebbe il codice di
operator++ nei due casi quando il tipo in gioco e' un int.
il caso prefisso funziona cosi':
{
    valore = valore + 1;
    return valore;
}
il caso postfisso funziona cosi':
{
    int oldVal = valore;
    valore = valore + 1;
    return oldVal;
}
In altre parole
- l'espressione ++z incrementa z e ha come valore il valore di z DOPO
l'incremento (prefisso pertanto l'incremento avviene prima di prendere il
valore).
- l'espressione z++ incrementa z e ha come valore il valore di z PRIMA
dell'incremento (postfisso pertanto l'incremento avviene dopo aver preso il
valore).
Puoi anche vederla cosi':
x = ((++z) - 1);
significa:
z += 1;
a  = z;
a -= 1;
x  = t;
x = ((z++) - 1);
significa:
a  = z;
z += 1;
a -= 1;
x  = t;
dove a e' l'accumulatore dei valori parziali durante il calcolo delle
sotto-espressioni (che corrispondono alle parentesi).
--
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

cosa c'č di sbagliato qui?
Tutto quanto :)
Se dico che il risultato di 2+2 e' 4, anche il risultato di
(2+2) e' 4.
Se il risultato di z++ e' z, anche il risultato di (z++) e'
z.
Occhio che la scrittura 2++ e' illegale, perche' 2 non e' un
l-value.


sotto-espressioni (che corrispondono alle parentesi).
Attenzione al fatto che non e' affatto garantito che z venga
incrementato tra le prime due istruzioni.
E', cioe', perfettamente lecito che il compilatore traduca
in :
a  = z;  
z += 1;  
a -= 1;  
x  = a;  
oppure in :
a  = z;  
a -= 1;  
z += 1;  
x  = a;  
oppure in:
a  = z;  
a -= 1;  
x  = a;  
z += 1;  


 incrementato tra le prime due istruzioni.
cioè tui stai dicendo che le 2 definizioni del l'operatore ++ pre e post di 
Andrea non sono giuste?


Andrea non sono giuste?
Certo che sono giuste, l'Omonimo non ha detto nulla di
sbagliato.
Volevo solo puntualizzare che l'ordine in cui la singola
operazione di incremento di z si colloca tra le altre, non
e' determinabile in modo preciso.
L'Omonimo l'ha piazzata come seconda istruzione, ma non e'
detto che lo sia.  
Resta il fatto che il risultato dell'operazione e' sempre lo
stesso.


++z    viene incrementato z al primo giro :))
z++   invece al prossimo :))))
questo non vale per cicli tipo for :))
ciao
--
-------
sito: 
www.dadev.it
ultime: Ocx per irc testi freeware
-------

questo non vale per cicli tipo for :))
mi sembra una definizione degna de "La Routa della Fortuna"
ps. il povero Mike Bongiorno si rivolterebbe nella tomba....ah si, è
ancora vivo :-))
--
Rhymes
--------------------------
rhy...@myself.com
http://www.foxhound-games.it
http://embyte.mascanc.net
--------------------------
Linux User #219707

 ancora vivo :-))
ahhahah si vero...perň sicuramente piů chiara di tante altre :))


questo non vale per cicli tipo for :))
cosa?
-- 
Marco Barisione (ICQ 84277092)

ahhahah si vero...però sicuramente più chiara di tante altre :))
Piu' chiara ?
A me non sembra affatto chiara, visto che non spieghi che
cos'e', secondo te, il "prossimo giro".


 cos'e', secondo te, il "prossimo giro".
č chiaro che il tono ironico non si č capito,ma era cosě poco evidente ?
va beh scriviamo due righe:))
in un loop ,usando z++ ,la stessa viene incrementata alla seconda
chiamata,invece usando ++z l'incremento č immediato :)
ops ma forse adesso sono troppo serio :)


chiamata,invece usando ++z l'incremento č immediato :)
Falso.
A parte il fatto che qui non si sta parlando di loop, ma del
singolo statement (i messaggi leggeteli): 
x = (z++)-1 ;
Quello che affermi e' assolutamente errato : in un loop z
viene incrementato ad ogni ciclo corrente, non al ciclo
successivo.


 successivo.
assolutamente no .. ma sono fatti apposta :)
l'incremento non avviene (come ho gia detto nel mio primo post)solo nel caso
sia una variabile di incremento di ciclo ..esempio :
for(;;++z) in questo caso il *fisso non c'entra nulla viene cmq incrementata
alla seconda chiamata
cmq non sto giocando a chi č piů bravo e se magari usassi toni piů
pacati ci capiremmo meglio :))

 riferivo solo al for o while che tu voglia :)
C'è qualche altro tipo di ciclo che esegue istruzione ripetutamente?
Ciao
--
Luigi
http://web.tiscali.it/luigi_web
ICQ #46240443

pacati ci capiremmo meglio :))
I miei toni sono pacatissimi e non sto affatto giocando, sto
solo aspettando che tu ti renda conto che quanto affermi e'
sbagliato.


Grazie Andrea, finalmente ho capito, ed è stato anche molto interessante il 
discordo sui loop.


 sbagliato.
anch'io aspetto la stessa cosa
cmq mi sono accorto che ci stiamo girando intorno alla "cosa" ma in fin dei
conti stiamo dicendo le "stesse cose" :))
bye


passaggio :))
Falso.  Ti ho gia' spiegato il perche', se insisti ancora ti
consiglio di leggere il K&R II edizione.
Non intendo parlare ulteriormente con chi non ha la minima
idea di come funzioni un loop e insiste ad affermare cose
sbagliate.
Ciao.


imparare ad utilizzare i termini corretti.
anche qui non hai cpaito una cippa :))
chiaramente mi riferivo al controllo nel ciclo for come ultimo confronto con
la variabile ....
addios :))
--


anche qui non hai cpaito una cippa :))
Io non avro' cpaito ma tu sicuramente non hai cpaito come
funziona un loop e non hai cpaito cosa e' un post-incremento
:)), oltre a non aver cpaito cosa e' un pre-incremento :)).
Se vuoi davvero essere sicuro di aver cpaito questi
argomenti :)), ti consiglio di leggere un buon manuale del
linguaggio :)).
Se mi prometti di leggerlo tutto e di fare tutti gli
esercizi inclusi :)), ti offro un caffe' :)), appena ti
incontro :)).
Arrivederci :)).


 Arrivederci :)).
ehhehe ho gia detto che non vorrei più entrare nell'argomento
cmq libri sul c*  ne ho gia letti 15 anni fa :)
vale lo stesos il caffè ?
heheh
bye


vale lo stesos il caffè ?
Certo... :))))))
p.s.: cos'e' il c* ?


> p.s.: cos'e' il c* ?
ahhahahha
beh le wildcard ti dicono nulla ?
dimentico che devo specificare fino ai minimi particolari
intendevo dire sia libri sul c che c++ e di qualsiasi altra argomentazione
attinente all'argomento :))
ciao :)))


beh le wildcard ti dicono nulla ?
Ma fammi il piacere... 
Statti bene...


 cosa?
Se non lo hai detto per scherzo, ecco la spiegazione.
Praticamente for (int z = 0; z < 10; z++);      e
               for (int z = 0; z < 10; ++z);
sono la stessa cosa visto che l'incremento avviene cmq dopo aver eseguito 
tutte le istruzioni del blocco operativo.
Ciao
-- 
Luigi
--
bug windows [5] = {"95", "98", "NT", "Me", "2000"};
Email: 
byte...@hotmail.com
Web Site: 
http://web.tiscali.it/luigi_web
ICQ #46240443

tutte le istruzioni del blocco operativo.
Immaginavo ma non era chiaro quello che voleva dire, cmq questo fatto
dipende da come sono gestiti i cicli for, non tanto dall'operatore di
post e pre incremento.


 ahhahah si vero...perň sicuramente piů chiara di tante altre :))
 La piu' chiara ti e' gia stata data e te la rinnovo:
supponi di avere la seguente classe:
class X {
        int value;
    public:
        X(): value(0) {}
        ~X()
};
e vuoi implementare i due operatori di preincremento e di incremento:
allora questi vanno cosi' implementati:
post-incremento:
    X X::operator++(int) {     // prende come parametro un int per
distinguerlo dal pre-incremento
       X oldValue = *this;
       ++(*this);
        return oldValue;
    }
pre-incremento:
   X& X::operator++() {
       ++v;
        return *this;
   }
nota che il pre-incremento deve tornare un reference infatti cosi' facendo
puoi
scrivere qualche cosa come:
    X x;
    ++++x;
ed avere correttamente x incrementata due volte.
Come anche puoi vedere il post-incremento e' molto + pesante del
pre-incremento
(copia locale per tornarti il valore prima dell'incremento e ritorno di una
copia
invece che un reference) e va usato solo quanto serve, ad esempio e' inutile
e dispendioso usarlo in casi come:
for (X x;  ;  x++ ) {
}
sarebbe meglio:
for (X x; ; ++x) {
}
questo ti fa anche capire perche non puoi ad esempio scrivere:   x++++;
Credimi per capire la differenza devi partire da queste considerazioni.
Spero di non aver detto ca@@ate.
Ciao
Gaetano.
-- 
Posted from 
flopiano.mm.eutelsat.org
 [194.214.173.28] 
via Mailgate.ORG Server - 
http://www.Mailgate.ORG

Oltre che nella scarsa chiarezza di alcuni compagni di newsgroup :-), la
difficolta' sta nel fatto che gli operatori pre e post incremento fanno
due cose distinte contemporaneamente: 
1) incrementano la variabile
2) restituiscono un valore
Il preincremento prima incrementa la variabile e poi ne restituice il
valore, mentre il postincremento prima preleva il valore, poi incrementa
la variabile e quindi restituisce il valore "preservato".
Ciao,
Nicola

 p.s.: cos'e' il c* ?
un nuovo linguaggio nato per contrastare C#.
il contrasto è ovvio perchè i due simboli (# e *) si trovano sulla tastiera d
qualunque telefono.
:-D
ciao :: xaero

 stesso.
Si. Ma senza usare un grafo (nel senso proprio di grafico con i nodi e gli archi
alla lavagna!) e senza introdurre il concetto di sequence point non sapevo come
spiegare la cosa senza limitarmi ad accennarla. Quindi ho sorvolato. Tanto in
C++ (almeno per quanto riguarda un programma conforme e non multithreaded) la
cosa oltre che irrilevante e' irrilevabile.
--
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