Newsgroup: it.comp.lang.c++
Titolo: relazione tra classi

Ciao a tutti.
Programmo in c++ da poco tempo, e il mio problema più grande è
determinare, e in seguito implementare in c++, le relazioni tra
classi.
Per esempio:
Un calcolatore gestisce un numero arbitrario di telefoni,
caratterizzati da un identificativo, e con i quali e' possibile
chiamare un numero esterno ed eventualmente interrompere la chiamata.
Alcuni telefono hanno il vivavoce, quelli che non hanno il vivavoce
possono avere la rubrica; infine esistono telefoni moderni con rubrica
che hanno un registro chiamate e che puo' essere modificato andando a
leggere la rubrica.
Il grafico del mio progetto: (tra parentesi tonde le classe
implementate, tra quadre le relazioni)
     [associazione?]
(pc) --------------> (tel)
                      /\ 
              [is-a] /  \ [is-a]
                    /    \              [has-a]
         (t_vivavoce)    (t_rubrica)   --------> (rubrica)
		            |
                            | [is-a]
                            |                [has-a]
                   (t_avanzati_con_rubrica)  -------> (registro
chiamate)
primo problema: Relazione pc-tel--> Il pc usa il telefono, non ha un
telefono. La mia idea era implementare un metodo di pc che ritorni un
ptr di tipo tel, ma facendo in questo modo, per utilizzare tutti i
metodi delle classi derivate, dovrei dichiararli tutti (virtuali)
nella classe base. E sinceramente non mi sembra una grande soluzione,
dato che ogni classe ha diversi metodi.
D'altra parte anche l'altra mia idea è poco fattibile: diversi metodi
simili che a seconda dell'identificativo restituiscano un oggetto di
tipo tel, t_vivavoce, t_rubrica e t_avanzati_con_rubrica. Neanche
questa mi sembra una grande soluzione!
Come fare?
secondo problema: Elevare a dignità di classe la rubrica e il registro
chiamate è una buona soluzione?
Devo fare diverse elaborazione che interessano la rubrica ed il
registro, ma dichiarandole classi e mantenendo le proprietà protected,
la comunicazione tra l'esterno (main), l'oggetto composto e il
corrispondente oggetto contenuto diventa decisamente complicato;
inoltre sono costretto a dichiare metodi set e get pubblici (e
leggendo diversi post ho captato che questa non è la
soluzione ideale).
domanda: Ha senso la struttura del mio progetto?  
Spero che qualcuno di voi possa aiutarmi, posto che il mio discorso
non sia stato troppo contorto. Grazie a tutti.


Dovresti spiegare meglio  l'effetivo scopo della tua applicazione, per
coglierne le operazioni e le relazioni fondamentali, comunque da quello
che hai scritto, le relazioni di ereditarieta' le vedrei meglio cosi':
(pc) --------------> (tel)
                      /\
              [islike-a] /  \ [islike-a]
                    /    \              [has-a]
         (t_vivavoce)    (t_rubrica)   --------> (rubrica)
                            |
                            | [islike-a]
                            |                [has-a]
                   (t_avanzati_con_rubrica)  -------> (registro
chiamate)
per le altre relazioni occorrono maggiori dettagli.
Ivan Molella

Ciao, innanzitutto grazie per avermi risposto.
Io vorrei che premendo un tasto del pc, questo si colleghi
automaticamente ad
uno dei tanti telefoni a disposizione (tramite un generico bus di
comunicazione). A quel punto, sempre da pc, vorrei chiamare un numero
esterno e, se il modello del telefono lo permette, utilizzare le
funzionalità aggiuntive (per esempio il vivavoce, oppure
l'impostazione della rubrica).
La chiamata ad un numero esterno puo' essere diversa a seconda dei
modelli; per esempio nel caso dei telefoni avanzati, durante la
chiamata, il registro dovrebbe aggiornarsi automaticamente andando a
leggere la rubrica del telefono utilizzato (se trova il numero in
rubrica aggiorna il registro chiamate).
In conclusione vorrei servirmi di un oggetto di tipo pc, che sia in
grado di collegarsi (tramite bus, ma quello non m'interessa) a oggetti
di tipo telefono o derivati da telefono.
Il progetto utilizzato come esempio è un esercizio di un tema d'esame,
e tutto (o quasi) quello che si evince dal testo è quello che ho
scritto.
Se sono stato poco chiaro, e non è possibile ne' identificare la
relazione pc-telefono, ne' tantomento implementarla in c++, mi
potresti spiegare con qualche esempio in c++, anche banale, come
implemetare relazioni che non siano di contenimento o di
erediteriata'?

Andrea wrote:

In sostanza facendola beve la cosa si potrebbe struturare cosi':
Tutti i telefoni a disposizione sono conosciuti da un PhoneHolder,che
quindi conterra' una serie di
puntatori ad oggetti Phone.
Phone e' una classe astratta che  esporra'  tutti quei metodi peculiari
di un telefono:
    per sempio: call(), end_call(),ring(),setOption(),isBusy(),.....
da cui:
calss Phone_rubrica : pubic Phone{
    public:
       call() { aggiorna un eventuale rubrica e fa la chiamata; }
...
};
calss Phone_vivavoce : pubic Phone;
class PhoneHolder  {
public:
    list<Phone*> phones;
    Phone * getPhone() { criterio in base a ci restituire un telefono
(es: restituisci il primo libero }
...
};
class PC {
   PhoneHolder& phHolder;
   Phone *  phone;
public:
       // Il pc prendera' come argomento un PhoneHolder,
          e non dovra'  essere responsabile della gestione dei telefoni.
    PC(PhoneHolder& holder);
    onKeyPress() { attachPhone(); }
    attachPhone() { phone = phHolder.getPhone(); }
    call()
    {
            // L'opzione e' settata solo se il telefono sara' predisposto
       phone->setOption(USA_RUBRICA|USA_VIVAVOCE);
      phone->call(number);
     }
.....
};
Questa e' una bozza di come potrebbe essere strutturata la cosa, ma ci
sono ampi margini di miglioramento,
come per esempio disaccopiare il PhoneHolder, e la strategia di
restituzione di un telefono.
Ivan Molella

Grazie per l'aiuto...ora meditero' sulla soluzione da te proposta. Ciao.