Newsgroup: it.comp.lang.c++
Titolo: [template] puntatore a template

Salve allora ho questo problema
cercherò di essere il più breve possibile:
ho una finestra (form) questa finestra ha degli stati ( state) e sono
gestiti da (man_state)
i legami fra le classe sono i seguenti:
form conosce state e man_state :
state perchè è questa che deve modificare lo stato della finestra (attivare
disattivare controlli)
man_state perchè è tramite questa che gestisce il cambiamento di
stato.(man_state.cambiastato(state)  )
ora il problema è questo :
trovare il modo di
1) evitare cast se possibile
2) passare form (form è la superclasse  questo meccanismo deve funzionare
anche per le derivate)
a state (state è l'interfaccia da qui derivano statefornitori, statecontatti
ecc.)
una prima soluzione è stata quella di far diventare state template è
funziona. dalla form mi posso permettere una
cosa del genere è va bene
stato<TForm1*>st(Form1); (gli dico il tipo di stato e chi è la finestra che
deve averlo)
il problema si complica con questa soluzione perchè ora non so come
"scrivere" man_state .
man_state dovrebbe "usare" state come parametro e senza sapere chi è state
(quindi i suoi derivati)  chiamare i suoi metodi
ecco uno straccio di codice:
template <typename type>
class ab_stato {
public:
template<typename type> ab_stato() {
};
~ab_stato() {};
virtual go() {};
};
template <typename type>
class stato : public ab_stato<type> {
//class stato : public ab_stato {
public:
template<typename type> stato(type p) {
m_p = p;
};
~stato() {};
type m_p;
go() {
  m_p->Button1->Enabled = false;
}
};
template <typename type>
class stato2 : public ab_stato<type> {
//class stato2 : public ab_stato {
public:
template<typename type> stato2(type p) {
m_p = p;
};
~stato2() {};
type m_p;
go() {
  m_p->Button1->Enabled = true;
}
};
class man {
public:
man() {};
~man() {};
go(????){
}
};
dal client  dovrei poter fare una cosa del genere:
--------------
stato<type_form1*>st(form1);
stato2<type_form1*>st2(form1);
man pman;
pman.go(st); //stato uno
pman.go(st2); //stato2 uno
ho semplificato giusto per rendere l'idea molto
grazie ciao

 ha scritto nel messaggio
news:495md.333700$35.15...@news4.tin.it...

una soluzione l'ho trovata.. mi avrebbe fatto piacere discuterne anche con
voi ... . però....

 voi ... . però....
Pero' ci hai dato meno di cinque ore per rispondere... su iclc++ in real 
time ci stiamo ancora lavorando, attendi fiducioso.
-- 
Mat/tia Belletti - Undergraduate student @ 
cs.unibo.it
ICQ: 33292311    - email: 
mbel...@cs.unibo.it
IRC: RedGlow     - site(s): 
http://mbellett.web.cs.unibo.it/
Jabber: RedGlow  - Linux registered user 299762 @ machine 213003

 stato.(man_state.cambiastato(state)  )
Onestamente, saro' io che a quest'ora (giustamente :P) non ragiono, ma 
non ho capito una cippa da questa descrizione... cos'e' uno "stato" di 
una finestra? A che serve "man_state" (e non rispondermi "a gestire gli 
state" e basta, che altrimenti bastavano dei metodi di state, no? :P)? 
Magari con qualche esempio... senza avere chiaro in mente il sistema che 
vuoi modellare, e' difficile dare suggerimenti di design.


 modellare, e' difficile dare suggerimenti di design.
per stato intendo un concetto astratto concretizzato con ab_stato 
(interfaccia)
un eleneco dei possibile stati in cui si può trovare una windows.
stato normale tutto funzione, stato errore tutti i controlli sono 
disattivati e la finestra non si può chiudere...
forse così è più chiaro :-) 


Non troppo, ma forse abbastanza. Vediamo...
Lo "stato" è un valore che dovrebbe caratterizzare un oggetto di tipo
"finestra". Cioè la singola "finestra" può essere in uno stato true or
false, è così?
Se è come ho interpretato, non si vede la ragione di complicare il codice
con classi "stato", "stato2" e ancora meno con "man".
Dovresti semplicemente creare un metodo (funzione), chiamato ad esempio
"man()", all'interno della classe "finestra" (o "form" come tu la chiami)
che prende un solo parametro bool. A questo punto basterà fare:
 form fm1;
 fm1.man(true); // set stato di fm1 a 'true'
 fm1.man(false); // set stato di fm1 a 'false'
Se non puoi risolverlo così vuole semplicemente dire che non ho capito
niente del tuo problema.
Buon lavoro,
fabiomdf
 
--------------------------------
Inviato via 
http://arianna.libero.it/usenet/

yag wrote:
se ho capito il tuo problema vuoi usare il pattern template method
su ab_stato ed il tuo problema è che ab_stato è una classe template
e da man non sai quale tipo usare visto che ab_stato<Form1> e 
ab_stato<Form2> sono due tipi diversi:
la soluzione è usare una classe base comune, in questo caso visto che 
ab_stato è una interfaccia non vedo motivi per templatizzarla, di 
conseguenza puoi usare lei come classe base comune.
In alternativa, nel caso ti serva templatizzare ab_stato puoi sempre
aggiungere una classe alla base della gerarchia ed usare lei in man::go().
L'altra alternativa è scrivere void man::go(ab_stato& ) come
template<typename T> void man::go(T& p).
struct ab_stato
{
     virtual ~ab_stato() = 0 {}
     virtual void go(){}
};
template <typename T>
class stato1 : public ab_stato{
     T& p_;
  public:
     stato1(T& p): p_(p){}
     void go(){ p_.Button1->Enabled = false; }
};
template <typename T>
class stato2 : public ab_stato{
     T& p_;
  public:
     stato2(T& p): p_(p){}
     void go(){ p_.Button1->Enabled = false; }
};
struct man{
     void go(ab_stato& the_state){ the_state.go(); }
};
...
  stato1<form_type> st1(form1);
  stato1<form_type> st2(form1);
  man the_man;
  the_man.go(st1);
  the_man.go(st2);
...
-- 
sbi

 la soluzione è usare una classe base comune
infatti il mio punto di partenza era quello e man non era template ... poi
mi sono perso pechè appunto su man mi sono bloccato :)
forse mi sono spiegato male ma  se noti il topic si capisce che cercavo quel
pezzo :)
Cmq grazie .