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

salve ragazzi mi serve un rinfreschina di c++ spero di non essere OT
dunque devo capire un meccanismo:
ho una classe che definisce un overload dell'operatore
in questo modo :
inline nomeclasse& operator=(const nomeclasse& aLcb);
nel codice viene fatta una cosa del genere:
nomeclasse *pnomeclasse;
pnomeclasse = new nomeclasse() ;
*pnomeclasse = altranomeclasse; //definita sorpa non puntatore
la mia domanda era perchč *pnomeclasse e non pnomeclasse ?
Io ho pensato che cosě lui (il compilatore )avrebbe visto l'indirizzo di 
&pnomeclasse e non il valore
su "cui gestire il reference" perchč cosě *pnomeclasse
sto prendendo il valore di  pnomeclasse.
Forse č poco chiaro come lo spiegato "credo" e preciso credo di averlo 
capito
ma forse non riesco a spiegarlo bene . Qualcuno sarebbe disposto a darmi una 
rinfrescatina ?
Ciao.... 

 ha scritto nel messaggio 
news:nVa_e.25011$pJ6.1...@news4.tin.it...

Scusate ho detto una bagianata ho capito
CIao .

 ha scritto nel messaggio 
news:J7b_e.25058$pJ6.1...@news4.tin.it...

cmq un commento sarebbe ben gradito (Scusate ancora il thread un pň 
convulso)
ciao

 convulso)
Tipo: non si capisce un tubo di quello che scrivi?
Ciao,
Nicola

 ha scritto nel messaggio 
news:1127825753.9...@z14g2000cwz.googlegroups.com...


ops :(
Riscrivo tutto :
//l'overload di nomeclasse è dichiarato  in questo modo :
inline nomeclasse& operator=(const nomeclasse& aLcb);
//nel codice viene fatta una cosa del genere:
nomeclasse *pnomeclasse;
pnomeclasse = new nomeclasse() ;
*pnomeclasse = altranomeclasse; //definita sorpa non puntatore
//la mia domanda era perchè *pnomeclasse e non pnomeclasse ?
pnomeclasse = altranomeclasse;
//Stavo leggendo nel NG ad un certo punto mi sono reso conto di avere dei 
grossi dubbi che devo
//assolutamente levarmi,sull'uso dei puntatori.
//se qualcuno mi vuole rispondere gli sarò grato
//seconda domanda perchè (sebrerà banale per voi, per me no)
//se chiamo un metodo di un puntatore faccio (generalmente)
nomeoggetto->nomemetodo();
//e che differenza c'è tra
*nomeoggetto->nomemetodo();
//e
&nomeoggetto->nomemetodo();
//un ultima cosa:
//generalmente quando leggi dei libri sulla programmazione (parlo di c++) 
vedi sempre esempi del tipo:
int x = 10;
int *pint=&x;
//e poi scrivono cose del tipo
//*p significa il valore  della variabile  a cui punta p (giustissimo)
//ma quando si parla di oggetti come ad esempio in questo caso.
nomeclasse *nomeoggetto;
*nomeoggetto; //cosa significa ?<
//e questo
&nomeoggetto;
grazie ciao

 &nomeoggetto;
Non ci sono differenze:
date le dichiarazioni sopra:
- x e' di tipo int;
- pint e' di tipo puntatore a int;
- &x e' di tipo puntatore a int;
- nomeoggetto e' di tipo puntatore a nomeclasse;
- *nomeoggetto e' di tipo nomeclasse (o reference a nomeclasse);
- &nomeoggetto e' di tipo puntatore a puntatore a nomeclasse;
Ciao,
Nicola

 
PS Hai dei dubbi bruttini... ti consiglio di leggerti un buon libro
introduttivo sul C++, come "Thinking in C++" di Bruce Eckel.
Lo trovi scaricabile liberamente da Internet qui:
http://www.mindview.net/Books/TICPP/ThinkingInCPP2e.html
Ciao,
-- 
Matteo Settenvini
FSF Associated Member
Email : 
mat...@member.fsf.org
-----BEGIN GEEK CODE BLOCK-----
Version: 3.12
GCS d--(-) s+:- a-- C++ UL+++
P?>++ L+++>$ E+>+++ W+++ N++ o?
w--- O- M++ PS++ PE- Y+>++
PGP+++ t+ 5 X- R tv-- b+++ DI+
D++ G++ e h+ r-- y?
------END GEEK CODE BLOCK------

>- &nomeoggetto e' di tipo puntatore a puntatore a nomeclasse;
Non sono riuscito a farmi capire bene comunque le tue risposte sono tutte 
chiarissime.
Intanto grazie per la pazzienza.
Dunque io volevo sapere cosa significa "non per noi ma per il compilatore".
Tu mi hai spiegato il significato di quello ho scritto.
A me interessava capire come si comportava il compilatore internamente.
Faccio un esempio sul codice che non riesco a capire .
nomeclasse *nomeoggetto;
..new etc.
*pnomeclasse = altranomeclasse;  //come dici tu *nomeoggetto e' di tipo 
nomeclasse (o reference a nomeclasse);
fin quando metti un puntatore ad intero riesco a capirlo perchè sapendo come 
è strutturata la memoria è facile
"immaginare" che vada all'indirizzo in cui si trova l'intero e prelevi il 
valore.
Ma in questo caso.
grazie ancora capiro... se non hai voglia di rispondermi...

 Ma in questo caso.
Non e' facilissimo capire cosa non capisci :-) Provo a scrivere un
esempio completo.
Supponi di avere
class A {
  int i;
  double d;
};
A a1;
A a2;
A * p1 = &a1;
A * p2 = &a2;
A questo punto scrivere
a1 = a2;
*p1i = a2;
a1 = *p2;
*p1 = *p2;
E' assolutamente equivalente, d'accordo? Quindi il problema e' solo
cosa fa il compilatore quando scrivo
a1 = a2;
Semplicemente se io non definisco un operatore di assegnamento per la
mia classe il compilatore ne "sintetizza" uno che effettua la copia
membro a membro; e' come se la mia classe A avesse un membro definito
come
A & operator= (const A & a) {
  i = a.i;
  d = a.d;
  return *this;
}
Ed e' questo che viene chiamato per effettuare l'assegnamento scritto
sopra. E' piu' chiaro?
Ciao,
Nicola