Newsgroup: it.comp.lang.c++
Titolo: significato di *&

Salve,
 non riesco a trovare sui libri di testo di C++ cosa si intenda per *&.
Mi spiego meglio
Ho un metodo di questo tipo
bool
state_set::was_present(state *& in)
{
   return simple_was_present(in)
}
e dovrei trasformarlo in modo tale da memorizzare "in" in una variabile che
si trova in memoria condivisa e un altro processo legga questa variabile
condivisa e mi faccia la chiamata al metodo simple_was_present.
simple_was_present č cosě realizzato e non puň essere modificato:
bool
state::simple_was_present(state *& in)
{
//codice
}
grazie per l'attenzione
Andrea

  non riesco a trovare sui libri di testo di C++ cosa si intenda per *&.
Significa "indirizzo di un puntatore";
-- 
SiMoStro

 ha scritto nel messaggio
news:qkC4d.296161$OR2.13...@news3.tin.it...


 e quindi come va interpretato?
Se un puntatore lo passi ad una funzione per
riferimento, la funzione non lavora su una copia
che si lascia sullo stack ma sul puntatore "effettivo"
della procedura chiamante.
Se invece un puntatore lo passi senza la "&", la
procedura lavora su una copia lasciata sullo stack
e quando esci dalla procedura ne perdi la visibilitą.
Esempio:
//-----------------------
#include <iostream>
using namespace std;
void stampa_int_by_ptr(int* pi){
  cout<<endl<<*pi<<endl;
}
void func(int*& pi){
  pi=new int;
  *pi=4;
  stampa_int_by_ptr(pi);
}
int main(){
  int* p;
  func(p);
  stampa_int_by_ptr(p);
  return 0;
}
//-----------------------
Prova ad eseguire il codice sopra *con* e *senza*
la "&" nella procedura func()
-- 
SiMoStro

 ha scritto nel messaggio
news:8eD4d.375826$5D1.17...@news4.tin.it...


 condiviso. Per l'appunto per esempio:
Andrea, non ti incartare :-)
a parte che non so cosa deve fare la tua procedura,
il "significato" del discorso è essenzialmente questo:
- passare per valore "le cose" alle procedure significa
effettuarne una copia sullo stack e dentro la procedura
lavorerai con quella *copia*: l'unico modo per non
perderne il contenuto è restituirla in uscita; ad esempio,
quanto segue è una versione "diversa" di quello che abbiamo
visto prima e funziona ugualmente poichè restituiamo l'indirizzo
dell'oggetto costruito con new e lo assegnamo al puntatore
della procedura chiamante:
int* func(int* pi){
  pi=new int;
  *pi=4;
  return pi;
}
int main(){
  int* p;
  p=func(p);
  return 0;
}
non è molto bello a vedersi, ma funziona.
- passare per riferimento "le cose" alle procedure
significa permettere all'istanza della procedura
di lavorare *direttamente* sull'oggetto senza il bisogno
di "restituire" alcunché per non perdere l'oggetto
I puntatori non fanno differenza.
Le zone di memoria condivisa (mmap()-shared o quello che è...)
sono visibili ai due processi e ciò che viene costruito lì dentro
lì rimane: puoi passare semplicemente il puntatore alla zona
di memoria condivisa purché l'oggetto di memoria sia stato
costruito "prima" di ogni possibile chiamata a procedura che lo
utilizzi;
è come fare una new prima della chiamata di procedura:
void stampa_int_by_ptr(int* pi){
cout<<endl<<*pi<<endl;
}
void func(int* pi){
*pi=4;
stampa_int_by_ptr(pi);
}
int main(){
int* p;
p= new int;
func(p);
stampa_int_by_ptr(p);
return 0;
}
Spero di non averti confuso le idee.
-- 
SiMoStro

 ha scritto nel messaggio
news:WcR4d.299155$OR2.13...@news3.tin.it...
