Newsgroup: it.comp.lang.c++
Titolo: Domanda Idiota...

Sul Lippman nel quarto capitolo, quando si parla degli operatori di
incremento e decremento c'e' una domanda che a me pare completamente stupida
(oltre che assurda): "Perche' il C++ non e' stato chiamato ++C?". E'
veramente una domanda deficiente (con risposta deficiente, quindi) oppure ha
una risposta sensata?
Ciao.
Stefano

Il senso e' :"prima di imparare il C++, bisogna conoscere il C".
Ciao e buono studio Gianni
--
Posted from 
c000-h011.c000.muc.cp.net
 [209.228.29.35] 
via Mailgate.ORG Server - 
http://www.Mailgate.ORG

 Il senso e' :"prima di imparare il C++, bisogna conoscere il C".
Non credo... Io penso si riferisca al fatto che C++ č considerato
l'evoluzione di C, ovvero la versione successiva. In C e C++, il ++ dopo
la variabile indica C=C+1, ma se č messo dopo intende "prima usa la
variabile, poi aggiungici uno", invece se si mette davanti diventa
"aggiungici uno e poi usa la variabile".
Per cui, secondo questa logica, se vuoi usare la versione successiva di
C devi prima incrementare la sua variabile, con il ++ davanti! :)
E' un po' incasinato, ma credo sia cosě! :)
Bye,
Norman


Io non ho mai capito l'umorismo della cosa. Mi hanno detto due cose:
1) C++ prima valuta C e poi incrementa; ++C prima incrementa C e poi
valuta... La qual cosa sembra migliore.
2) E' possibile fare l'overload di entrambi gli operatori, ma quello
postfisso (prima valuta poi incrementa) ha un argomento in piu' per
distinguerlo da quello prefisso.
prefisso:
const Myclass& operator++(Myclass& );
postfisso
const Myclass operator++(Myclass& ,int);
E questo "dovrebbe" ridurne l'efficienza....

valuta... La qual cosa sembra migliore.
Secondo quale principio è migliore?
Luc.

 E questo "dovrebbe" ridurne l'efficienza....
No.
Il parametro in piu' serve solo per fare capire al compilatore
quale versione di operator ++ stai definendo. Dal punto di vista
della chiamata non esiste un overhead specifico in se' (il codice
generato dal compilatore non passa nulla a operator++(int)).
C++ e' pero' intrinsecamente meno efficiente perche' comporta
sempre la copia dell'oggetto; infatti l'oggetto deve essere modificato
ma il valore di ritorno e' quello precedente la modifica. Questo
significa che la cosa comportera' la creazione di un oggetto copia
temporaneo, l'incremento dell'istanza corrente e il ritorno della
prima copia (che spesso comporta una seconda copia per il return
value).
Con il preincremento invece non esiste nessuna copia in quanto si
ritorna un reference a *this dopo aver "incrementato" l'istanza
corrente; esiste un solo oggetto e viene ritornato per reference
(una bella differenza).
C C::operator++(int)
{
  C temp(*this); // Prima copia
  // incrementa
  return temp;   // Seconda copia necessaria per return
}
C& C::operator++()
{
  // incrementa
  return *this;
}
Andrea
--
----------------------------------------------------------------
 <\___/>  Andrea        email: agriff at tin dot it
 / . . \  "6502"          irc: _6502_@EFNET#italia
(  (")  ) Griffini   homepage: 
http://www.netservers.com/~agriff
Sent via Deja.com 
http://www.deja.com/
Before you buy.

Che l'autore fosse ubriaco al momento della stesura di questa frase non vi
va vero ???
;-)
Per quello che ho potuto sperimentare io col mio apprendimento (ancora in
corso) C e C++ sono due mondi diversi.... magari della stessa galassia ma
niente di piů. Si pensa in modo completamente diverso.... almeno a me pare
cosi...
Bye,
Sebastiano

La domanda e' intesa in senso faceto, ma serve comunque a verificare se
si e' capito come funzioniano gli operatori di incremento. Il punto e'
che l'espressione C++ vale C, mentre ++C vale C + 1, quindi se si vuole
qualcosa di piu' del C bisognerebbe scrivere ++C.
Ciao,
Nicola
P.S. A giudicare da alcune risposte, direi che la domanda e' piu' seria
di quanto no sembri...