Newsgroup: it.comp.lang.c++
Titolo: Puntatori e reference intercambiabili?

Da questa definizione, del tutto legale,
MyClass& MyClass::f() {
//...
  return *this;
}
Perché allora non restituisce un MyClass*?
Per una questione di migliore "gestione sintattica" del reference ritornato?

nembo kid ha scritto:

this e' un puntatore..............................

 this e' un puntatore..............................
Appunto dico, perché alla funzione non si fa ritornare un MyClass*?

 Appunto dico, perché alla funzione non si fa ritornare un MyClass*?
perchè sarebbe un errore visto che il tipo di ritorno e' un Myclass&...

nembo kid ha scritto:

Puoi utilizzare indifferentemente i puntatori o i reference, vedi te 
cosa preferisci usare.
I reference sono stati introdotti per eliminare ambiguità 
nell'overloading degli operatori, in quanto se tu scrivessi:
&val1 + &val2
il compilatore non capirebbe tu volessi sommare gli indirizzi o se 
passare all'operatore + l'indirizzo delle variabili. Per questo 
nell'overload degli operatori si usano i reference, ma sono nati solo 
per risolvere questa ambiguità. Tu li puoi usare indifferentemente negli 
altri casi.

Perché allora non restituisce un MyClass*?
Perché refernce e puntatori sono due cose diverse. NON sono
intercambiabili.

Appunto dico, perché alla funzione non si fa ritornare un MyClass*?
Perché no. Si vuole che restituisca l'istanza *this come reference,
appunto.

cosa preferisci usare.
Sì ma attenzione: reference e puntatori sono cose ben distinte. Il
termine "intercambiabile" usato nel subject implica troppe ambiguità.

Andrea Laforgia ha scritto:

Sì, intendevo o si usano i puntatori o (esclusivo) i reference per 
risolvere uno stesso problema, ovviamente non si possono mischiare 
perchè sono due cose distinte

 termine "intercambiabile" usato nel subject implica troppe ambiguità.
Opinione di uomo della strada che viene dal C: secondo me questi 
reference hanno complicato le cose a iniziare dalla scelta del carattere &.

 intercambiabili.
Eckel nel su Thinking C++ scrive
"Un reference è come un puntatore costante che viene automaticamente 
deferenziato"
La confusione aumenta.


L'uomo della strada, se non vuole rimanere sulla strada suddetta,
farebbe bene a compiere uno sforzo per capire perche' i reference sono
indispensabili e perche' in diversi casi sono meglio dei puntatori.
L'alternativa a un linguaggio complesso e' che tutti, ma tutti
sprechino fatica a ovviare ai limiti di astrazione dei linguaggi
"semplici". Per carita', c'e' sicuramente un punto di equilibrio tra
complessita' del linguaggio e comodita d'uso, ed il C++ non e' che lo
centri cosi' bene, ma il C e' indiscutibilmente piu' lontano.
Ciao,
Nicola

-----BEGIN PGP SIGNED MESSAGE-----
Hash: SHA1

Ciao, guardando il resto della discussione mi sembra ci sia qualche
equivoco su cosa sia un riferimento.
	int pippo = 1;
	int* puntatoreAPippo = &pippo;
	int& superPippo = pippo;
puntatoreAPippo è l'indirizzo in memoria della variabile pippo. Se lo
stampi con std::cout, otterrai un numero esadecimale (abbastanza
casuale), qualcosa come 0x38FA930.
Il riferimento a una variabile è semplicemente un altro nome per la
variabile stessa: per ottenere il valore di pippo con il puntatore, devi
scrivere:
	cout << *puntatoreAPippo;
Cioè «Vai all'indirizzo "puntatoreAPippo", estrai il valore int che c'è
lì, e mandalo a cout».
Invece, con il riferimento, non hai un puntatore, ma un nome di
variabile con lo stesso esatto contenuto di pippo:
	cout << superPippo;
Ora, il concetto basilare è che superPippo *non è una copia* di pippo,
*è* pippo. In pseudocodice disneyano:
pippo = il nostro eroe;
puntatoreAPippo = via Vai 1;
*puntatoreAPippo = chi abita in via Vai 1 (cioè il nostro eroe);
superPippo = l'identità segreta del nostro eroe: sono la stessa persona.
Se cambi il valore di superPippo ne leggerai le modifiche in pippo, e
viceversa:
	superPippo = 2;
	cout << pippo;	// scrive «2»
	pippo = 1;
	cout << superPippo;	// scrive «1»
Logicamente, se dò una mazzata in testa a superPippo, anche pippo avrà
mal di testa perché, appunto, sono la stessa persona.
A cosa servono i riferimenti? Servono a fare barbatrucchi come
l'operatore[]:
int& Array::operator[]( int index );
siccome questa funzione restituisce un riferimento, non un valore,
possiamo assegnare i valori della classe Array in questo modo:
	Array x(10);	// array con 10 elementi
	x[5] = 0;
x[5] vuol dire «prendi il sesto elemento e dammene un riferimento»:
siccome il riferimento *è* la variabile, non una sua copia come nel caso
in cui la funzione fosse stata int Array::operator[](...), se gli
assegni un valore è come assegnarlo alla variabile interna che sarà
imboscata da qualche parte nelle parti private di Array.
Se avessi avuto un operatore dichiarato come:
int Array::operator[]( int index );
e del codice come:
	Array x(10);
	x[5] = 0;
il risultato sarebbe stato:
* Prendi il sesto elemento dell'array;
* *fanne una copia*, perché stiamo restituendo int, non int&;
* assegna alla copia il valore 0;
* la copia scompare nel nulla, visto che non le abbiamo dato un nome.
* x[5] continuerebbe a restituire lo stesso valore di prima, invece di
quello che pensavamo di avergli assegnato.
Spero di aver chiarito!
Ciao,
- -Federico
-----BEGIN PGP SIGNATURE-----
Version: GnuPG v1.4.5 (GNU/Linux)
Comment: Using GnuPG with SUSE - 
http://enigmail.mozdev.org
iD8DBQFIdc8bBIpu+y7DlLcRAoFCAKCio3Ynpedf8uJt7Kd+4f9aaEd20QCfWEqW
Yrn8tP4yTz/4d0GeSLsPOeI=
=l19m
-----END PGP SIGNATURE-----

 La confusione aumenta.
Non capisco perché tu abbia confusione. E' in quel "come" e in quel
"automaticamente" il succo del discorso. E se tu non ti limitassi a
leggere una frase singola, ma ti sforzassi di comprendere il concetto
di reference ben ampliato su quel libro, ti accorgeresti di quel che
l'autore vuol dire. Non sta dicendo che un reference è un puntatore,
ma che *è come un puntatore costante* che viene *automaticamente*
deferenziato. Mi sembra che il succo sia chiaro. Non mi sembra che
quanto dica Eckel sia ambiguo o talmente ambiguo da far desumere che
puntatori e reference siano intercambiabili.

 reference hanno complicato le cose a iniziare dalla scelta del carattere &.
Obiezione superficiale. I linguaggi, prima di essere giudicati, vanno
studiati.
Il C++ è sicuramente un linguaggio più complesso del C++, ma la sua
complessità è voluta. I reference sono importantissimi in questo
linguaggio e grazie ad essi si può evitare l'uso di puntatori in molti
casi. Da uomo della strada che viene dal C sei troppo abituato ai
puntatori. Ed è una brutta abitudine.

mal di testa perché, appunto, sono la stessa persona.
Non pensavo che si dovesse arrivare a dare spiegazioni in questi
termini. Che tristezza (non ce l'ho con te).

 Spero di aver chiarito!
Sei stato eccezionale e chiarissimo.
Grazie

 termini. Che tristezza (non ce l'ho con te).
Secondo me e` stato molto didattico.
Molto piu` chiaro di come spiegano il concetto di reference diversi libri.
Bye,
  Gabry

Quoto con Andrea ....
e aggiungo : bisogna sforzarsi di studiare prima un argomento e fare
qualche esempio per fissare le idee e magari poi fare delle domande
chiarificatorie . Il problema è che scrivere una domandina sul NG
è più veloce di leggersi un capitolo !
bye.
_ _
Detesto quello che dici ma difenderò fino alla morte il tuo diritto di 
dirlo. Voltaire.
"Andrea Laforgia" <a.laf...@andrealaforgia.it.invalid> ha scritto nel 
messaggio news:rljc749f8a8ek1njt...@4ax.com...


 Molto piu` chiaro di come spiegano il concetto di reference diversi libri.
Altri libri, non Thinking in C++ (che è quello, se non erro, che nembo
kid sta leggendo). D'altronde non si sta parlando di fisica delle
particelle. Premetto che non ce l'ho con Federico (che è stato gentile
e ha offerto una spiegazione), ma sono contrario a una banalizzazione
estrema dei concetti che finisce per essere soltanto una
mortificazione. Insomma, c'è una dignità anche nella didattica e se
uno ha bisogno di sentirsi dire che Super Pippo e Pippo sono la stessa
persona e che quindi se dai una botta in testa all'uno si fa male
anche l'altro, per capire bene il concetto di reference, stiamo messi
DAVVERO male. Tanto vale che a pranzo si presenti qualcuno che gli
mette un bavaglino e gli faccia l'aeroplano col cucchiaio. Insomma,
che capperi, un po' di serietà nello studio. Non credo che il concetto
di reference sia così astruso e non credo che Bruce Eckel non sappia
spiegarlo.
Chiudo qui, non voglio polemizzare.