Newsgroup: it.comp.lang.c++
Titolo: La vera differenza tra Puntatore e &

Scusate, una domanda
                 ho chiaro cosa in teoria prevede il passaggio di parametri
per Riferimento ( & ) e quello per                             puntatori e
li uso indistintamente; Ma la vera differenza quale è se comunque sono
entrambi                             espedienti per realizzare il passaggio
di valori per riferimento ?
                -->Forse la portabilità del codice ?
Ciao e grazie.....


Beh non so se a livello di implementazione ci sono sostanziali
differenze
tra le due soluzioni. Ma che io sappia l'unica differenza e' di tipo
stilistico, cioe' utilizzando il passaggio per riferimento tu puoi
accedere alla variabile senza doverla dereferenziare, cosa che devi fare
quando usi i puntatori, quindi usando le variabili passate per reference
il codice e' piu' leggibile.
-- 
  _  _  >>Now at work<<  _     || ICQ number.................Non lo uso
 | \| |___ _____ ___ ___|_|___ || Home-Page ................Non ce l'ho
 | .` | -_|     | -_|_ -| |_ -||| E-Mail................Non l'avrai mai
 |_|\_|___|_|_|_|___|___|_|___||| Un Nemesis che ha pochi e-contatti ;)

 writes:

Ci sono casi (copy constructor, assignment operator) in cui la
semantica richiede il passaggio di un oggetto, non di un puntatore.
-- 
Maurizio Loreti                         
http://www.pd.infn.it/~loreti/mlo.html
Univ. of Padova, Dept. of Physics - Padova, Italy            
lor...@pd.infn.it

 ha scritto nel messaggio
news:rmu1xjz...@mlinux.pd.infn.it...


Se devi lavorare sull'oggetto effettivo, passi per riferimento. Passi per
valore se ti serve lavorare su una copia temporanea dell'oggetto, che poi
sarà distrutta alla fine della funzione.
Ciao
--
Luigi
byte...@hotmail.com
http://web.tiscali.it/luigi_web
ICQ #46240443

di valori per riferimento ?
Il passaggio tramite puntatore non e' un passaggio per
riferimento, ma un retaggio del C.
Il vero passaggio per riferimento, in C++, e' tramite i
reference.
-- 
Andrea Laforgia - walkietalkie(at)
libero.it

ov77 wrote:

Effettivamente puntatori e references sembrano in molti casi equivalenti.
Credo che i references siano stati aggiunti al C++ per consentire il 
passaggio di oggetti senza effettuare una copia (cosa necessaria, ad 
esempio, per i vari operatori =,+, << etc.) . Ovviamente, i passaggi per 
puntatori sono dovuti restare per motivi di compatibilita' con il C.
In generale, vista la possibilita' di scegliere tra puntatori e reference 
quando si vuol passare un oggetto come parametro a un metodo,
si usa spesso la convenzione di passare un puntatore se l'oggetto
passato potrebbe essere nullo, un reference se si e' sicuri che l'oggetto 
esiste. 
es.
void f( Obj *obj )
{
    if ( obj == 0 ) // obj potrebbe essere nullo
    {
        // ...
    }
}
void g( Obj &obj )
{
   // obj deve esistere, non occorre controllarlo
}
Ovviamente questa e' una convenzione tra chiamante e chiamato.
E' sempre possibile scrivere
Obj * p = 0;
f( *p );  // BOMB
Saluti,
Fabio
-- 
Posted from 
flopiano.mm.eutelsat.org
 [194.214.173.28] 
via Mailgate.ORG Server - 
http://www.Mailgate.ORG

 esiste.
Concordo.
Ciao,
Nicola

 Nicola
Per questo stesso motivo quando chiedi ad un metodo di darti una
istanza di classe (ad una factory ad esempio) l'unico metodo pulito
e veloce e' farsi ritornare un puntatore.
Altrimenti che torni se non l'hai potuta istanziare per un motivo qualsiasi?
So che ci sono 1000 ed un metodo per fare la stessa cosa con i reference
ma uno pulito non l'ho trovato.
Ciao,
Gaetano.
-- 
Posted from 
dell-01.mm.eutelsat.org
 [194.214.173.17] 


 ma uno pulito non l'ho trovato.
Il problema infatti e' che con i puntatori hai modo di gestire la "vita"
dell'oggetto, mentre con i reference questo controllo non esiste. Di
fatto mi pare che l'unico caso in cui e' "sicuro" restituire un
reference si ha quando una funzione membro restituisce l'oggetto stesso,
ad es.:
struct C {
  C & me() { return *this; }
};
Ciao,
Nicola

 Nicola
Oppure, quando torni una variabile statica ( in un singleton ad esempio):
class C {
    private:    
        C() {}
    public:
        C& instance() { 
            static C c;
            return c;
    }
}
Ciao,
Gaetano


 }
Non amo neanche questo. Per quanto i problemi siano piu' rari, in C++
sostanzialmente non sai quando una variabile statica viene creata ne
quando viene distrutta. Tutto funziona se il tuo programma ha *una sola*
variabile statica, ma quando ne hai due... I miei singleton sono
allocati dinamicamente (questo non elimina il problema, lo rende
esplicito).
Ciao,
Nicola

 Nicola
Se ne ho due che non si usano a vicenda nessun problema.
Se ne ho due che si usano a vicenda il buon "Alexandrescu" 
docet.


 docet.
Io preferisco Singleton gestiti via smart pointer.
Ciao,
Nicola

 f( *p );  // BOMB
No. Non e' possibile. Questo e' "undefined behaviour". Potresti pensare che
questo programma:
#include <iostream>
int foo( int &r ) { return 2; }
int main()
{
    int *p=0;
    std::cout << foo(*p) << std::endl;
}
debba avere come effetto lo scrivere 3 sulla console. Ma stando allo standard
non e' cosi'. Se scrivesse "ciao, come stai?" il compilatore sarebbe
perfettamente conforme.
--
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

 che questo programma:
[snip]
Il commento // BOMB stava a significare, appunto, che, nella piu' probabile
delle ipotesi, il programma avrebbe avuto una "terminazione anormale".
Tra le ipotesi meno probabili puo' succedere di tutto (tra cui la 
'classica' formattazione dell'Hard-Disk)
Fabio Lopiano


 Fabio Lopiano
Per non parlare della famosa lettera minatoria alla
mailing list dell'azienda per cui lavori e a quella
che ti stava per assumere.....
Ciao
Gaetano.
-- 
Posted from 
dell-01.mm.eutelsat.org
 [194.214.173.17] 



Molto più perfida la divulgazione, tramite e-mail, del frammento di programma
errato per una completa screditazione del programmatore :-)
Ciao  Manlio Perillo

> debba avere come effetto lo scrivere 3 sulla console.
Al massimo 2!


 Al massimo 2!
ROTFL.
Hai ragione. Ma ovviemente avevo scritto che oltre a 2 anche 3 sarebbe stato
valido, poi ho deciso di cambiare la frase, poi di cambiarla ancora, poi ancora.
Insomma un pastcciciaccio di cut&paste e ctrl-Z (undo in OL). E alla fine c'e'
rimasto il tre invece del 2.
Pero' il bello e' che ha perfettamente senso aspettarsi che l'output fosse
appunto 3 (almeno quanto avrebbe senso aspettarsi un 2).


 Nicola
Se si usano a vicenda non riesci comunque a sincronizzarli.
E poi o smart pointer o istanze statiche essendo singleton
non cambia nulla a parte il fatto che se una istanza e' statica
viene istanziata prima della chiamata dell'entry-point, se 
invece usi uno smart-pointer rimandi all'effettivo momento di
utilizzo. Forse non ho capito come usi gli smart pointer in un 
Singleton, e che vantagi hai.
Ciao
Gaetano.

 Singleton, e che vantagi hai.
L'utilizzo di smart pointer con reference count ha il fondamentale
vantaggio di forzare l'ordine corretto di *distruzione* di singleton
interdipendenti nella maggior parte dei casi.
Questo e' un buco sia nei singleton basati su allocazione dinamica (alla
"Design Patterns") che in quelli basati su variabili locali statiche
(alla S. Meyers), che si limitano a garantire il corretto ordine di
*costruzione* di singleton interdipendenti.
Utilizzando invece smart pointer, con il solo vincolo che un singleton
non acquisisca mai un puntatore ad un altro singleton nel proprio
distruttore, sei sicuro che ciascun singleton venga distrutto solo
quando tutti gli altri singleton che si riferivano ad esso sono gia'
stati distrutti.
Trovo questo approccio decisamente meno macchinoso di quello basato su
std::atexit() suggerito ad esempio da A. Alexandrescu. Tra l'altro lo
smart pointer potrebbe se necessario incapsulare eventuali meccanismi di
accesso esclusivo al singleton in ambito multi threaded.
Ciao,
Nicola