[C/C++]: Classe dentro un'altra classe

[Tobler]

Ciao a tutti, spero che questo post risulti chiaro e poco tedioso

Facciamo finta che io abbia una palla (classe Palla) che rimbalza in una scatola (classe Box):

class Palla {
  public:
  int x, y;

  private:
  Palla();
  void muovi(int,int);
} 

La classe Box non la riporto nemmeno; c'è solo un metodo che mi dice quanto è profonda. Mi piacerebbe, nel momento in cui sviluppo il metodo "muovi" della classe Palla poter dire una cosa del genere:

se x è maggiore di fondo del box rimbalza indietro.

Il problema è che così facendo devo richiamare l'altra classe Box e non saprei proprio come fare; creare una sua istanza dentro Palla mi sembra azzardato e forse poco utile. Avete qualche idea? Ho come la sensazione che ci voglia un puntatore... o mi sbaglio?

:master:

[alka]

Quale linguaggio? :master:

[fastcoder]

Prima del codice ci sta scritto PHP, ma credo che l'idea riguardi in genere un linguaggio OO. Se in effetti con il metodo muovi intendi indicare il movimento in un Box, credo che l'idea corretta sia quella di passare l'oggetto Box all'interno della chiamata a muovi, poi questo lo puoi fare (in C++) con un puntatore o meglio un reference.
Ti volevo comunque far notare che hai definito i membri come pubblici e i metodi come privati
normalmente è il contrario.
Se invece con muovi intendi un metodo che date le coordinate x,y cerca il box a quelle coordinate e poi esegue il test sul rimbalzo...forse è meglio definire una classe mondo che contiene i box e far diventare il medoto muovi un metodo della classe mondo a cui viene passata una istanza di palla.
Spero di esserti stato d'aiuto.

[Tobler]

Ragazzi scusate ma in questi giorni il caldo mi debilita.
Il linguaggio era C++ e ho sbagliato a definire i membri, come giustamente mi fa notare Fastcoder...

In effetti io immagino che Box possa avere un metodo del tipo "get_fondo()" che mi restituisca appunto il punto più basso della scatola. Dunque come suggerisci tu, Fastcoder, si dovrebbe usare un reference... indicato con & ? Adesso mi devo documentare

Nel frattempo grazie per le risposte!

[Tobler]

Peggio di quanto pensassi

Provengo da Java e sapevo che la storia dei puntatori sarebbe stata drammatica.

credo che l'idea corretta sia quella di passare l'oggetto Box all'interno della chiamata a muovi, poi questo lo puoi fare (in C++) con un puntatore o meglio un reference.

Il problema è che non riesco a districarmi tra & e *... fin'ora ho capito che * è il puntatore e & è il "bersaglio", se così si può dire. Vado errato?

[fastcoder]

Un po' si ti consiglio di leggere le pillolle di saggezza presenti in cima al forum.
Comunque per farla molto breve distinguiamo inanzitutto tra un puntatore ed un reference: i puntatori sono gli unici usabili in C, i reference sono stati introdotti in C++ per ridurre la complessità di usare i puntatori essenzialmente per implementare il passaggio 'by reference' che in C era possibile solo usando i puntatori.
Per dichiarare un puntatore usi come hai detto l'operatore * es: int *v; per ottenere l'indirizzo di una variabile, e quindi ottenere un puntatore, usi l'operatore &.
Per i reference si usa invece ancora l'operatore & nella dichiarazione es: int &v, reference ad un intero. I reference hanno poi parecchi vincoli d'uso.
Per dichiarare muovi con un reference a questo usi: void muovi(int x, int y, Box &b). Per chiamarla non fai altro che passare un istanza di tipo Box es:

Box tmp_box;
muovi(1, 2, tmp_box);

Con i puntatori avresti definito: void muovi(int x, int y, Box *b) e la chiamata:

Box tmp_box;
muovi(1, 2, &tmp_box);

Ti chiederai perchè sono comodi i reference se in fondo bastavano i puntatori? Prima di tutto è che se usi i reference eviti il controllo che qualcuno ti passi un puntatore non inizializzato, in quanto un reference è garantito che si riferisca a qualcosa...con i puntatori puoi ad esempio fare così e si schianta tutto:
Box *tmp_box;
muovi(1, 2, tmp_box);
Secondo ti potresti chiedere perchè usare i reference ed i puntatori se in fondo non vuoi modificare il parametro (cioè non hai necessità del passaggio by reference): è una questione di ottimizzazione...passare un parametro così:

void muovi(int x, int y, Box b);

Box tmp_box;
muovi(1, 2, tmp_box);

funziona lo stesso ma viene invocato il costruttore di copia e se non l'hai definito ne viene creato uno di default e non sempre fa quello che dovrebbe. Ecco perchè in questi casi (es. muovi) la dichiarazione corretta è:

void muovi(int x, int y, const Box &b);

dichiarata così non fai altro che usare i vantaggi del by reference (niente copie e parametri temporanei inutili) garantendo che non modifichi l'istanza passata.
Spero di averti chiarito un poco di più le idee...comunque leggi le pillole

[Tobler]

Fastcoder, sei un grande.
Buona la dritta delle pillole; fin'ora tutto quello che so l'ho appreso da cplusplus. Sei stato molto chiaro... mi scateno con le pills