Heritage : appel de fonctions membre de classe parent
1 réponse
PurL
Bonjour,
Je veux manipuler des types de données
j'ai des classes décrivant chaque type de donnée
class CCalcul
{
...
};
class CVariable
{
...
};
Dans mon programme je veux manipuler des listes des différents types.
Comme ces manipulations sont communes (ajouter, supprimer, libelle, ...)
j'ai écrit une classe parent :
template <class type>
class CList
{
public:
Ajouter (type objet);
NbObjet(); //methode permettant de connaitre le nombre d'objets
présent dans la liste
...
};
et je créé des classes enfants dérivant de cette classe :
class CListCalculs : public CList<CCalcul>
{
};
class CListVariables : public CList<CVariable>
{
};
et les objets correspondants :
CListCalculs *listCalculs = new CListCaculs;
CListVariables *listVariables = new CListVariables;
Ensuite j'utilise une liste de pointeurs contenant les objets listVariables,
listCalculs (je présente mon code avec deux types : calcul et variable mais
je peux en avoir une dizaines).
Donc ma_liste[0] pointe sur listVariables et ma_liste[1] pointe sur
listCalculs.
Mon probleme :
J'aimerais accéder à la fonction NbObjets de ma classe parent comme ceci :
for (int i = 0; i < nbtype; i++) qqch = ma_liste[i]->NbObjets();
le pb c'est que le compilateur ne connait plus le type des pointeurs stockés
dans ma_liste donc ne peut pas appeler la méthode NbObjets :(
de plus je ne peux pas transtyper avec CList puisqu'on a à faire à une
classe template...
Cette action est irreversible, confirmez la suppression du commentaire ?
Signaler le commentaire
Veuillez sélectionner un problème
Nudité
Violence
Harcèlement
Fraude
Vente illégale
Discours haineux
Terrorisme
Autre
Benoit Rousseau
PurL wrote:
Bonjour,
Je veux manipuler des types de données j'ai des classes décrivant chaque type de donnée class CCalcul class CVariable
Dans mon programme je veux manipuler des listes des différents types. template <class type> class CList tu n'as pas pensé à utilise std::list ?
et je créé des classes enfants dérivant de cette classe :
class CListCalculs : public CList<CCalcul> class CListVariables : public CList<CVariable>
et les objets correspondants : CListCalculs *listCalculs = new CListCaculs; CListVariables *listVariables = new CListVariables;
Ensuite j'utilise une liste de pointeurs contenant les objets listVariables, listCalculs (je présente mon code avec deux types : calcul et variable mais je peux en avoir une dizaines). Donc ma_liste[0] pointe sur listVariables et ma_liste[1] pointe sur listCalculs. Comme tu le dis toi même, CList<CCalcul> et CList<CVariable> ne sont pas
du même type... pense aussi à utiliser std::vector pour ton tableau
En général, on fait dériver le CCalcul et les CVariable d'un même type CExpression et on applique un Composite Pattern. Je suppose en effet que CCalcul sera dérivé pour faire un CAddition ? Dans ce cas, CExpression serait ton type de base, avec une fonction eval() virtuelle qui te retourne le resultat de l'expression.
En simplifiant, tu pourrais faire class CAddition : public CExpression { public: CAddition( CExpression* g, CExpression* d ) : gauche( g ), droite( d ) {}; CVariable eval() { return gauche->eval() + droite->eval(); //Operateur + a définir } protected: CExpression* gauche; CExpression* droite; };
class CVariable : public CExpression { ... CVariable eval() { return *this; } };
A partir ce ca, tes CCalcul et CVariable ont le même type de base et tu peux construire des list<CExpression*> qui sont "compatible"
-------------------------------------------- Benoît Rousseau : roussebe at spray dot se Jouez en programmant : http://realtimebattle.sourceforge.net/
PurL wrote:
Bonjour,
Je veux manipuler des types de données
j'ai des classes décrivant chaque type de donnée
class CCalcul
class CVariable
Dans mon programme je veux manipuler des listes des différents types.
template <class type> class CList
tu n'as pas pensé à utilise std::list ?
et je créé des classes enfants dérivant de cette classe :
class CListCalculs : public CList<CCalcul>
class CListVariables : public CList<CVariable>
et les objets correspondants :
CListCalculs *listCalculs = new CListCaculs;
CListVariables *listVariables = new CListVariables;
Ensuite j'utilise une liste de pointeurs contenant les objets listVariables,
listCalculs (je présente mon code avec deux types : calcul et variable mais
je peux en avoir une dizaines).
Donc ma_liste[0] pointe sur listVariables et ma_liste[1] pointe sur
listCalculs.
Comme tu le dis toi même, CList<CCalcul> et CList<CVariable> ne sont pas
du même type...
pense aussi à utiliser std::vector pour ton tableau
En général, on fait dériver le CCalcul et les CVariable d'un même type
CExpression et on applique un Composite Pattern.
Je suppose en effet que CCalcul sera dérivé pour faire un CAddition ?
Dans ce cas, CExpression serait ton type de base, avec une fonction
eval() virtuelle qui te retourne le resultat de l'expression.
En simplifiant, tu pourrais faire
class CAddition : public CExpression {
public: CAddition( CExpression* g, CExpression* d ) :
gauche( g ), droite( d ) {};
CVariable eval() {
return gauche->eval() + droite->eval();
//Operateur + a définir
}
protected:
CExpression* gauche;
CExpression* droite;
};
class CVariable : public CExpression {
...
CVariable eval() {
return *this;
}
};
A partir ce ca, tes CCalcul et CVariable ont le même type de base et tu
peux construire des list<CExpression*> qui sont "compatible"
--------------------------------------------
Benoît Rousseau : roussebe at spray dot se
Jouez en programmant : http://realtimebattle.sourceforge.net/
Je veux manipuler des types de données j'ai des classes décrivant chaque type de donnée class CCalcul class CVariable
Dans mon programme je veux manipuler des listes des différents types. template <class type> class CList tu n'as pas pensé à utilise std::list ?
et je créé des classes enfants dérivant de cette classe :
class CListCalculs : public CList<CCalcul> class CListVariables : public CList<CVariable>
et les objets correspondants : CListCalculs *listCalculs = new CListCaculs; CListVariables *listVariables = new CListVariables;
Ensuite j'utilise une liste de pointeurs contenant les objets listVariables, listCalculs (je présente mon code avec deux types : calcul et variable mais je peux en avoir une dizaines). Donc ma_liste[0] pointe sur listVariables et ma_liste[1] pointe sur listCalculs. Comme tu le dis toi même, CList<CCalcul> et CList<CVariable> ne sont pas
du même type... pense aussi à utiliser std::vector pour ton tableau
En général, on fait dériver le CCalcul et les CVariable d'un même type CExpression et on applique un Composite Pattern. Je suppose en effet que CCalcul sera dérivé pour faire un CAddition ? Dans ce cas, CExpression serait ton type de base, avec une fonction eval() virtuelle qui te retourne le resultat de l'expression.
En simplifiant, tu pourrais faire class CAddition : public CExpression { public: CAddition( CExpression* g, CExpression* d ) : gauche( g ), droite( d ) {}; CVariable eval() { return gauche->eval() + droite->eval(); //Operateur + a définir } protected: CExpression* gauche; CExpression* droite; };
class CVariable : public CExpression { ... CVariable eval() { return *this; } };
A partir ce ca, tes CCalcul et CVariable ont le même type de base et tu peux construire des list<CExpression*> qui sont "compatible"
-------------------------------------------- Benoît Rousseau : roussebe at spray dot se Jouez en programmant : http://realtimebattle.sourceforge.net/
