Newsgroup: it.comp.lang.c++
Titolo: Un alternativa a questo :

        //init
        a *pa = new a();
        a *pa2 = new a();
        pa->a = 10;
        b *pb = new b();
        pb->a = 20     ;
        void *x;
        // da a  to void  > step 1
        x = (void*)pa;
        //da void to a > step 2
        pa2 = (a*)x;
Mi potete trovare una alternativa a questo ?
Allora immaginate che ogni step sia un passaggio da una classe ad un'altra 
io ho questa situazione
schema
|-----c-------|
a     temp      b
^      ^           ^
|____|______|
Quello che io devo fare è trovare un modo generico per passare(tramite un 
metodo)  valori (classi) da a a b tramite temp
a ,temp b sono classi
a e b conosco la classe che devono usare (c)  temp no quindi deve essere 
pronta a tutto (non so se mi spiego)
Io stavo cercando una soluzione sensa cast ma non riesco a trovarla in più 
non volevo neanche usare il void
ma questa è stata l'unica soluzione . Ultima nota temp è template

...sempre piu' criptico ;-)
il tuo esempio non fa nessun riferimento a 'temp' o a 'b',
mentre per copiare pa in pa2 basta un semplice assegnamento (essendo
entrambi puntatori allo stesso tipo) quindi immagino che abbia fatto un
po' di confusione (come al solito) forse vuoi assegnare un a* a un b* ?
passando per un temp ?
la prossima volta, prima di postare, prova a rileggere il tuo post come
se non sapessi nulla del problema e controlla che ci siano tutti gli
elementi necessari per una risposta significativa...
Saluti,
Fabio

 Allora immaginate che ogni step sia un passaggio da una classe ad un'altra
Ma queste 2 classi sono di tipi differenti? Perche' nel tuo esempio pa e pa2
sono entrambe di tipo a*.
Ciao

 ha scritto nel messaggio 
news:4229b517$1...@x-privat.org...

Ed anche nel caso concreto 'possono' essere dello stesso tipo !
Quello che ho proposto non è detto sia la soluzione ottimale... (anzi!!!) 
c'è una classe di mezzo fra a e b che si chiama temp
perchè temp non sa che classi deve manipolare per fare un esempio il tutto 
dovrebbe andare anche se io ho classi di tipo b (su entrambi i lati )
a1 instanza di a ,o b, o c, o d deve comunicare con a2 istanza di a ,o b, o 
c, o d
unica cosa in comune, entrambe le classi conoscono l'oggetto che si devono 
passare che può essere istanza di
a ,o b, o c, o d . ma non possono direttamente (problemi di architettura) ma 
solo tramite la classe  temp (nel mio caso template)
Questo problema (se così si può chiamare ) è causato da un famosissimo 
pattern chiamato
Facthory Method Parametrico.
il client in questo pattern conosce solo una interfaccia (il prodotto) che 
gli viene restituita da un metodo
(facthory method) che istanzia la classe concreta in base ad un parametro e 
poi ritorna un classe prodotto. in termini di codice :
...
interfacciaProdotto* return  new concreteClass(); // derivata da 
interfacciaProdotto
Questo è buono perchè evita che il client usi direttamente quello che sta 
dentro il prodotto
(nel mio caso una Form) però nel caso in cui serve che il client "passi" 
qualcosa alla form o viceversa le cose si complicano.
Aggiungo :
Nel mio caso concreto il prodotto è una classe template così fatta
template <typename type>
class c_prodotGeneric : public c_prodotForm{
public:
        c_prodotGeneric(enModApertura tipoApertura):
        c_prodotForm(tipoApertura) {
          obj = new type(Application,tipoApertura);
        }
        ~c_prodotGeneric() {
                form_delete();
        }
        bool show() {
                        obj->ShowModal();
        }
        bool form_delete() {
                        delete obj;
        }
public:
         type *obj;
};
perchè essendo utilizzata come "contenitore" di form posso evitare (come 
dice il manuale del pattern) di derivare una classe concreta per ogni 
prodotto ,type rapprensenta appunto la form.
dalla fachory method la istanzio così
.....
        if (IDFORM == enIdlistini) {
        return new c_prodotGeneric<formListini>(tipoApertura);
        }
....

 solo tramite la classe  temp (nel mio caso template)
Voglio farti altre domande per inquadrare meglio il problema :P
Sai quanti sono i tipi delle possibili istanze? Sono 4 (a, b, c, d)?
Inoltre in che senso queste istanze devono comunicare tra loro? C'e' un
metodo di una che agisce sull'altra? Entrambe lavorano sullo stesso oggetto?
Ciao

 oggetto?
Nel senso io l'ho pensata così il client chiama un metodo del prodotto 
titpoSetValue e gli passa una classe qualsiasi (il valore da passare)
la form richiama un metodo del prodotto tipo getValue e se ce qualcosa 
capisce che chi la sta costruendo gli sta anche passando dei parametri ne 
prende atto e se li copia dentro
stesso discorso visto al contrario :
la form chiama un metodo di prodotto per "dargli" una classe  titpoSetValue 
(il valore da passare) in questo caso la form dovrebbe avere un puntatore al 
parent (chi la contiene) ma questo è facile e cmq ora non voglio complicare 
le cose...
e poi il client prima di eliminare l'oggetto prodotto
form_delete()
chiamerà un'altro metodo tipo  getValue per sapere se il form gli voleva 
passare qualche classe (il valore da passare)
...spero di aver chiarito ... se ha altri dubbi su quello che voglio fare e 
mi serve io sono qui ...

 prodotto)
Umh... allora non so se dico bene ma forse questo problema e' un po legato
ad aspetti di programmazione un po' specifici relativi all'uso di form,
dialogs etc... in ogni caso mi sembra molto articolato come progetto per
essere discusso "a spezzoni". Io non ho esperienza in questo genere di
problemi, perche' non provi a chiedere su it.comp.programmare.win32?
Per quanto riguarda il cast, hai provato con reinterpret_cast?
Ciao


Si ok cmq non č legato alle interfacce intese come form in fin dei conti le 
form sono classi oggetti
nulla di piů
Grazie Comunque ma credo che su win32 non si occuppino di queste cose visto 
che sono prettamene OO
e nel caso specifico legate a c++ (template ecc.)
Ciao :-) 

Credo di cominciare a capire.
In qualche modo vuoi che gli effetti di una modifica in un form si
propaghino verso altri form, senza che ogni tipo di form conosca
direttamente gli altri.
Il design pattern "Mediator" potrebbe essere la soluzione.
In generale, il mediator e' una classe che conosce tutti i form
concreti e che e' conosciuto da essi. Quando un form cambia qualcosa
avvisa il mediator (chiamando un suo metodo) e questi avvisa i form a
cui propagare l'informazione (chiamando opportuni metodi delle classi
concrete).
In questo scenario il mediator conosce tutte le classi concrete, e
quando ne aggiungi una nuova devi aggiornarlo, ma almeno ogni classe
concreta non ha bisogno di conoscere le altre.
Se i tuoi form sono cosi' "dinamici" da dover poterne aggiungere di
nuove a volonta' senza voler modificare il codice del mediator, allora
puoi provare con il pattern "Observer" (questo e' un po' piu'
complicato ma anche piu' flessibile).
Se non l'hai gia', procurati "Design Patterns" e dagli un'occhiata (ma
forse puoi trovare qualcosa anche su Google).
Buon lavoro,
Fabio


OK più o meno ci sei quei pattern che hai citato gli conosco entrambi ma non 
vanno bene per mio caso perchè non si tratta di eventi veri e propri bisogna 
ragionare in questi termini ,
non di form ! ma di prodotto che contiene il form lo scopo del pattern 
fachory method principalmente è quello di "isolare" x funzionalità nel mio 
caso la form
in modo che se si dovessero cambiare non bisogna mettere mano al codice che 
si basa sull'interfaccia.
Volendo semplificare io potevo creare per ogni form o per la form base le 
altre derivano tutte da questa un metodo tipo : tornaRigaSelezionata(riga*);
ma nel momento in cui vorrei l'ultimo bottone selezionato di un form dovrei 
scrivere un altro metodo tipo: tornaUltimoBottoneSelezionato(bottone*) ;
questo all'infinito! io voglio evitare questo.
nel mio caso riga e bottone sono le classi che su entrambi i lati (classe a 
e classe b conoscono -> c(riga , bottone)) form1 form2 sono appunto a,b temp 
la fachory class.
Così facendo io potrei far "dialogare" form1 con form2 tramite temp senza 
che esse si conoscano faccio un ultimo esempio
E come quando si prende il valore di ritorno da un MessageBox (nel mio caso 
sarebbe temp) solo che il message box è limitato a INT (mi pare)
nel mio caso dovrebbe essere qualsiasi "cosa" (classe) se ero limitato ad un 
tipo il tutto era molto semplice come ho spiegato sopra.
si potrebbe avere un flusso del genere : Sequence diagrams
utente    client
     |            |
     |             ----create prodotto(form1) -> prodotto
     |            |                                                   |
     | 
             ---------create ------> form
     |            |----showmodal()--------->------| 
|
     | 
             -------showmodal() ->--- |
     ---------------seleziona un riga  preme ok>------------------------ >|
                 |                                                  | 
|
                 | 
|<--setta valori riga-------- |
                 |                                                  | 
|---|
                 |                                                  | 
|    <    self->close
                 -prendi  valori riga selazionata-->| 
|
                 -----destroy------------->----- -| ---------delete----------->|
Ecco questo lo schema (spero sappiate leggerlo mi son fatto un culo :P)
:) ciao 

 ha scritto nel messaggio 
news:EezWd.1012241$35.37...@news4.tin.it...

si è sputtanato tutto lo schema :|
-_-