Newsgroup: it.comp.lang.c++
Titolo: Problema con i template

Ciao a tutti, ho un problema di questo tipo: ho una classe base che ha due
costruttori
class MyBaseClass
{
public:
MyBaseClass() { };
MyBaseClass(int Var) { m_Var = Var; };
private:
int m_Var;
};
e una classe template derivata dall'argomento template che ha un solo
costruttore che non prende parametri
template <class T>
class MyTemplateClass : public T
{
public:
MyTemplateClass() { };
};
derivo una classe dalla mia classe template passando come argomento del
template la classe base originaria
class MyDerivedClass : public MyTemplateClass <MyBaseClass>
{
public:
MyDerivedClass() { };
};
La domanda è questa:
Esiste un modo per richiamare il costruttore di MyBaseClass che accetta un
parametro da MyDerivedClass senza modificare MyTemplateClass?
La soluzione "brutta" sarebbe infatti dichiarare :
template <class T>
class MyTemplateClass : public T
{
MyDerivedClass() { };
MyTemplateClass(int Var) : T(Var) { };
}
e da MyDerivedClass :
 class MyDerivedClass : public MyTemplateClass <MyBaseClass>
{
public:
MyDerivedClass() { };
MyTemplateClass(int Var) : MyTemplateClass <MyBaseClass>(Var) { };
};
Ma non mi piace...
Qualcuno mi può aiutare? (sempre che esista la soluzione...)
Grazie in anticipo

 };
Ciao,
Nicola
-- 
Posted via Mailgate.ORG Server - 
http://www.Mailgate.ORG

 > };
Come mai questa soluzione non ti piace? Porta degli svantaggi? A me č
piaciuta parecchio...
Grazie comunque,
ciao

 inizializzate dalla classe piu' derivata:
Una seconda domanda che prima mi era sfuggita...cosa comporta dichiarare la
classe base come virtuale (oltre a risolvere il mio problema...)?

 un parametro da MyDerivedClass senza modificare MyTemplateClass?
devi usare l'ereditarieta` virtuale:
template <class T>
class MyTemplateClass : public virtual T
{
        ...
};
Anche se non sono sicuro che un design del genere sia il migliore 
possibile. Se ci spieghi cosa e perche` vuoi fare forse possiamo darti 
una risposta migliore.
ciao Anto
-- 
"Computer science is not about computers any more than astronomy
is about telescopes." -- EW Dijkstra

 una risposta migliore.
Spiegando il perchè vado OT, in ogni caso lo accenno soltanto visto che me
lo hai chiesto.
Sto creando un'estensione di MFC e una delle tante idee è estendere la
classe CWnd che, come forse qualcuno qui sa , è la classe base per tutte le
finestre: voglio quindi che se creo la classe CMyListCtrl derivata da
CListCtrl, questa debba avere tutti i metodi della mia CMyWnd oltre che
quelli di CListCtrl (essendo derivata ovviamente...).
L'idea è questa:
class CMyListCtrl : public CMyWnd <CListCtrl>
...
Andando,ad esempio, a creare la classe CMyDialog (CMyDialog : public CMyWnd
<CDialog>) devo passare, in uno dei costruttori di CMyDialog, l'ID del
template a CDialog. Ecco quindi spiegato il problema.
Mi scuso per la piccola digressione...
In ogni caso, tornando al C++ puro, cosa comporta  l'ereditarieta` virtuale?
Qualcuno mi può chiarire questo concetto ?
Grazie ancora

 una risposta migliore.
Spiegando il perchè vado OT, in ogni caso lo accenno soltanto visto che me


...

Normalmente se una classe eredita da piu' superclassi, queste
costituiscono gerarchie di eredita' distinte:
class A {};
class B : A {};
class C : A {};
class D : B, C {};
corrisponde a 
A   A
^   ^
B   C
^   ^
+-+-+
  D
L'eredita' virtuale permette a due superclassi di una data classe di
condividere eventuali classi base comuni:
class A {};
class B : virtual A {};
class C : virtual A {};
class D : B, C {};
corrisponde a
  A
  ^
+-+-+
B   C
^   ^
+-+-+
  D
Ciao,
Nicola

 piaciuta parecchio...
Non mi piace usare un meccanismo per uno scopo diverso da quello per
il quale e' stato pensato. Tra l'altro l'eredita' virtuale introduce
inefficenze inutili.
Avendo letto il tuo altro thread penso che farei cosi':
class BaseA {
  public:
    BaseA() {}
};
class BaseB {
  public:
    BaseB(int i) {}
};
template <typename Base> class TemplateClass : public Base
{
  public:
    TemplateClass() {}
    template <typename A> TemplateClass(A a) : Base(a) {}
    template <typename A, typename B> TemplateClass(A a,B b) :
Base(a,b) {}
};
In questo modo puoi dichiarare:
class MyA : public TemplateClass<BaseA> {};
class MyB : public TemplateClass<BaseB> {
  public:
    MyB(int i) : TemplateClass<BaseB>(i) {}
};
Ovviamente TemplateClass dovra' contenere un overload per ciascuna
cardinalita' presentata dai costruttori delle tue classi base. Non
sono pero' sicuro che questa soluzione funzioni correttamente con
VC++. Prova.
Ciao,
Nicola