Newsgroup: it.comp.lang.c++
Titolo: reference

Salve,
vorrei un consiglio, o meglio un'assicurazione sull'uso dei reference
non solo come uso nei parametri formali delle funzioni/metodi.
Quello che ho capito fino ad adesso è quanto segue:
* un reference ad un oggetto, allocato sull'heap o sullo stack,
rappresenta l'oggetto, *è* l'oggetto, come se fosse un puntatore che
viene automaticamente deferenziato.
* l'indirizzo di memoria di un reference *è* l'indirizzo di memoria
dell'oggetto referenziato.
* quando un reference esce dal suo scope, *non* viene chiamato il
distruttore dell'oggetto a cui si riferisce.
* è assolutamente legale, corretto e senza sorta di dubbio scrivere
codice del genere:
        T& t = *new T();
        if ( &t ) {
                t.doit();
                delete &t;
        }
equivalente in tutto e per tutto a
        T* t = new T();
        if ( t ) {
                t->doit();
                delete t;
        }
* Thinking in C++ 1, cap. 11, dice che "2. Once a reference is initialized
to an object, it cannot be changed to refer to another object." Facendo
int a,b; int& r = a; r = b; mi compila, ma vuol dire che r = b non
cambia il reference ma assegna il valore di b ad a.
Saluti
-- 
int


Dal momento che assegni una reference ad un oggetto, ogni volta che 
infili in un'istruzione la reference in questione e' come se utilizzassi 
l'oggetto a cui l'hai associato inizialmente, come in effetti ti 
dimostra la parte di codice che hai eseguito.
Il punto e' che non puoi fare ( per test ):
int & r;
r = a;
r = b;
otterresti un compile time error per non aver inizializzato la 
reference, perche' la prima istruzione deve essere
int & r = a;
da quel momento
r = b
equivale ad
a = b.
Ciao

         }
come sopra
-- 
sbi

 Quello che ho capito fino ad adesso è quanto segue:
A me sembra tutto corretto.
EMG
--
EMAG Software Homepage:     
http://www.emagsoftware.it
The EMG's ZX-Spectrum Page: 
http://www.emagsoftware.it/spectrum
The Best of Spectrum Games: 
http://www.emagsoftware.it/tbosg

 
In generale, è vero che lo scope di un reference non incide sul lifetime di
un oggetto. C'è un'unica eccezione. Se un reference a un oggetto const
viene inzializzato con un temporaneo, questo rimane "magicamente" in vita
finché il temporaneo non esce di scope.
   {
       const T & tr = T();
 
   } // il temporaneo viene distrutto qui
M

 legale, non "corretto":
Ok grazie, sapevo che non era exception-safe. Comunque, &t mi serviva
per chiedere conferma che l'indirizzo di t corrisponda all'indirizzo
dell'oggetto creato nell'heap. Qui č banale, ma per me lo era meno
quando ci si passava reference a membri di oggetti che l'avevano
ottenuto in reference da altre parti e cosě via.
Ho iniziato a programmare in c, un po' d'assembler, poi il c++ col
lippman e un'altro libro che non ricordo, lavorato in c++ e c, poi
lavorato in java, poi tornato in c ed ora al c++ e devo dire che la
confusione, dopo tutti questi anni regna sovrana! Spesso mi servono
delle sicurezze/delucidazioni, coltivando contemporaneamente la vana
speranza di trovare ore preziose per leggere eckel da cima a fondo come
tentativo di iniziare a colmare le mie lacune sul c++.
Saluti
-- 
int

    } // il temporaneo viene distrutto qui
Forse volevi dire che il temporaneo rimane in vita finché il reference
non esce di scope ?
E se tr venisse ritornato, il temporaneo continuerebbe a vivere fuori
dalla funzione/metodo ?
-- 
int

 dalla funzione/metodo ?
Intendi una cosa come:
T & f() { return T(); }
In questo caso il temporaneo *non* sopravvive.
Ciao,
Nicola

 In questo caso il temporaneo *non* sopravvive.
max parlava di oggetti const.
const T& f() { return T(); }
In questo caso ?
-- 
int

Il const non cambia le cose.
Ciao,
Nicola