Problème d'instanciation de classe C++

**gilims** · 21/10/2010, 14h27

Bonjour à tous.
Voilà j'ai un petit doute et j'aimerais votre avis pour être sur de ne pas faire d'erreur.

Soit la classe A définit comme suit :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
class A
{
private: int x;
  public: A(); ~A();
}

et la classe B et C qui hérite de la classe A :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
class B: public A { }
classe C: public A{}

Jusque là rien de bien spécial.

Maintenant, j'ai une fonction de lecture, appelons là Lect(string filename); qui est censé renvoyer un objet dont les fonctions sont dans la classe A.
Le problème est qu'actuellement, je ne peux définir avec cette fonction que des objets définit par la classe A, mais pas par la classe B et C.

Que dois-je ajouter lors de la définition de ma fonction pour que je puisse, indépendamment du fait que c'est une instanciation de la classe B ou C, n'avoir qu'une seule et même fonction de lecture, qui utilise donc les fonctions de la classe A mais qui renvoie un objet B ou C.

Merci d'avance !

**vingt sens** · 21/10/2010, 15h52

Bonjour,
Si j'ai bien compris, tu as trois classes et tu as une fonction 'à part' qui doit renvoyer l'une des classes. Dans ce cas, la solution qui me semble la plus adapté est de la templater.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
 
class A
{
        public:
        int x;
        A(){x=1;}
};
 
class B : public A
{
        public:
        B(){x=2;}
};
 
class C : public A
{
        public:
        C(){x=3;}
};
 
template<class T>
T lect()
{
        T v;
        v.x = 4;
        return v;
}
 
int main()
{
	A a;
	B b;
	C c;
 
	std::cout << a.x << " " << b.x << " " << c.x << "\n";
 
	a = lect<A>();
	b = lect<B>();
	c = lect<C>();
 
	std::cout << a.x << " " << b.x << " " << c.x << "\n";
 
	return 0;
}

**Astraya** · 21/10/2010, 15h58

Bonjour gilims,

Maintenant, j'ai une fonction de lecture, appelons là Lect(string filename); qui est censé renvoyer un objet dont les fonctions sont dans la classe A.

Dis moi si je me trompe, la signature correspondrais à ceci?

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

A Lect(string filename);

Si c'est le cas, tu dois utiliser une notion appelée le polymorphisme.
La fonction Lect(string filename) de A devra être déclarée avec le mot clé "virtual". Tu ne pourras pas renvoyer un objet mais un pointeur vers l'objet car le polymorphisme ne fonctionne que avec des objets dynamiques (Attention à bien faire la destruction de l'objet donc, ou utilise les pointeurs intelligents du standard ou de boost).

Donc la signature deviendrai :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
A* Lect(string filename);
//ou 
auto_ptr<A> Lect(string filename);
//ou
shared_ptr<A> Lect(string filename);

Tu devras ainsi redéfinir dans B et C , la fonction Lect(string filename) sans la mot clé "virtual" cette fois-ci.

Lors de la création de ton objet à renvoyer, tu devras créer l'objet a retourner comme suit :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
A * pA = new B; // ou new C;
return pA;

Il y a d'avantages de renseignements la dessus sur la FAQ:
http://cpp.developpez.com/faq/cpp/?page=virtual

**gilims** · 21/10/2010, 18h05

@vingt sens : j'avais déjà essayé les templates, mais il me dit à chaque fois symbol not found !!

@Astraya : Il y a une légère mésentente. En voulant simplifier le probleme, je me suis surement mal expliqué.

J'ai une classe, (que l'on va nommer Reader) et qui est charger de lire un fichier. Elle s'instancie simplement en faisant ca :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

Reader MRead(filename);

La classe reader contient une fonction, appelé Get_Data(), qui est censé lire le fichier et récuperer les données. Ces données sont en réalité des molécules, que l'on diviser en 2 catégories, la catégorie B (protéine par exemple) et la catégorie C (ligand). Ces deux catégories sont définit par mes classes B et C. Ces deux classes héritent de la classe A (la classe molécule), qui définit de façon générique les atomes et les liaisons, pour en ajouter ou en supprimer, bref le standard.
Ma question c'est comment je peux faire pour définir la fonction Get_Data() une seule fois sans avoir à définir 2 fois cette meme fonction afin de retourner B et C. C'est à dire de pouvoir librement faire :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
B *Proteine = Get_Data(); 
C *Ligand = Get_Data();

sans avoir à réécrire 2 fois le code.

**Nudger** · 21/10/2010, 18h30

Bonjour,

Alors le prototype de Get_Data c'est:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

A* Get_Data();

Dans l'implémentation de cette méthode, tu déclare un A*

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

A* a;

Et un peu plus loin de manière conditionnée tu as:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
if(<condition>) {
  a = new B();
} else {
  a = new C();
}

Et enfin plus loins:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

return a;

Et ça marchera si B et C héritent de A.

**gilims** · 21/10/2010, 19h20

Je crois qu'on va passer au code source

, ca marche pas ...
Voici le message d'erreur : error: invalid conversion from in main.cpp : IChemos::MoleBase*' to 'IChemos::Ligand*'

Voici mon main.cpp :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
 
#include "molereader.h"
#include "ligand.h"
 
int main(int argc, char *argv[])
{
    MoleReader MolRead("/Users/ethane.mol2",MOL2);
 
     Ligand *Mols = MolRead.Read_MOL2();
cout << Mols->__ToString()<<endl; // Affiche les données de la molécule.

Le MoleBase.h (classe A dans l'exemple)

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
 
class MoleBase
{
private :
        vector<Atom*> atoms;			/*!< Contain All Atoms */
        vector<Bond*> bonds;			/*!< Contain All Bonds */
public:
    MoleBase();
    ~MoleBase();
     void Add_Atom(Atom *_atome);
     void Add_Bond(int _Atom1, int _Atom2, BondType Type);       
 
};

Le ligand.h (classe B dans l'exemple)

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
 
 
#include "molebase.h"
 
class Ligand:public MoleBase
{
public:
    Ligand();
};

Le protein.h (classe C dans l'exemple)

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
 
#include "MoleBase.h"
 
class Protein:public MoleBase
{
public:
    Protein();
};

Et enfin le reader :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
 
#include "Protein.h"
#include "Ligand.h"
 
class MoleReader
{
private:
        std::string		filename;         /*!< Name of the molecule file */
        FILE*		finput;           /*!< Pointer of the file */
        bool		       EOFile;           /*!< END OF FILE */
        FileFormat        format;              /*!< Format */
 
 
 
public:
        MoleReader(std::string _Filename);
 
        MoleBase* Read_MOL2(bool debug=false);
 
};

Et le contenu de la fonction Read_MOL2 :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
 
MoleBase* MoleReader::Read_MOL2(bool debug)
{
    string typemol = "Ligand";
    MoleBase* Mol=NULL;
    if (typemol = "Ligand") Mol= new Ligand();
    // la lecture s'effectue ici
   return Mol;
 
}

J'ai essayé ta technique Nudger, mais j'ai du rater quelque chose ...

**Astraya** · 21/10/2010, 19h46

Ceci est normal.
Le principe est simple, l'héritage c'est comme une rock-star, le fils connait son père mais son père connait pas son fils.
Donc le compilateur peut transformé un fils en père mais il ne peut pas faire du père un fils car le père ne connait pas son fils.

Tu ne pourras pas obtenir un fils directement comme ça dans ton main.

Plusieurs solutions, ou tu utilises le polymorphisme, ou tu ajoutes un renseignement dans le père indiquant quel est son fils pour pouvoir le caster.
Sinon il existe l'idiome CRTP, ou truc de Barton-Nackman qui permet, avec de la programmation générique, d'informer le parent qui est son enfant. Idiome très simple à mettre en œuvre.

**Chatanga** · 21/10/2010, 21h57

C'est peut-être le bon moment pour découvrir le RTTI du C++ ?

Code C++ :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
class MoleBase
{
public:
    // L'information RTTI est stockée dans la vtable or celle-ci
    // n'est générée que s'il existe au moins une méthode virtuelle.
    virtual ~MoleBase() {}
};
 
class Ligand : public MoleBase
{
public:
    void useLigand()
    {
        // ...
    };
};
 
class Protein : public MoleBase
{
public:
    void useProtein()
    {
        // ...
    };
};
 
MoleBase * Read_MOL2() 
{
    // ...
}
 
void readAndUse()
{
    MoleBase * pMolecule = Read_MOL2();
 
    if (Ligand * pLigand = dynamic_cast<Ligand *> (pMolecule))
    {
        pLigand->useLigand();
    }
    else if (Protein * pProtein = dynamic_cast<Protein *> (pMolecule))
    {
        pProtein->useProtein();
    }
    else
    {
        // ...
    }
}

En l'absence de RTTI (par exemple parce qu'un abruti aurait décrété que c'est mal) et plutôt que d'ajouter une donnée membre pour jouer ce rôle, j'aurais créé une fonction de lecture Read_MOL2 prenant un visiteur en paramètre.

**Joel F** · 21/10/2010, 22h36

la RTTI c'est pour les faibles :o
le but du polymorphisme est justement de ne pas avoir à demander son type à une variable.

Donc, visiteur.

**Astraya** · 22/10/2010, 13h13

le but du polymorphisme est justement de ne pas avoir à demander son type à une variable.

Bas justement, au lieu de travailler avec une 30ène de molécule et de classes différentes, travailler avec son abstraction et spécialiser les actions entreprises par les molécule dans chaque classes.

**Chatanga** · 22/10/2010, 14h52

Envoyé par gilims

Le MoleBase.h (classe A dans l'exemple)

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
 
class MoleBase
{
private :
        vector<Atom*> atoms;			/*!< Contain All Atoms */
        vector<Bond*> bonds;			/*!< Contain All Bonds */
public:
    MoleBase();
    ~MoleBase();
     void Add_Atom(Atom *_atome);
     void Add_Bond(int _Atom1, int _Atom2, BondType Type);       
 
};

Envoyé par Astraya

Bas justement, au lieu de travailler avec une 30ène de molécule et de classes différentes, travailler avec son abstraction et spécialiser les actions entreprises par les molécule dans chaque classes.

Ca semble déjà être le cas vue la déclaration de ModeBase et, par ailleurs, ligand et protéine ne désignent pas des molécules précises mais bien des familles aux comportements spécifiques et non interchangeables :

Envoyé par Wikipedia

In biochemistry, a protein ligand is an atom, a molecule or an ion which can bind to a specific site (the binding site) on a protein.

D'un autre côté, moi et la biochimie

**gilims** · 22/10/2010, 15h01

Ca semble déjà être le cas vue la déclaration de ModeBase et, par ailleurs, ligand et protéine ne désignent pas des molécules précises mais bien des familles aux comportements spécifiques et non interchangeables :

Je suis tout à fait d'accord avec toi Chatanga !! Les protéines et les ligands sont toutes les deux des molécules (définit via MolBase) mais qui n'ont absolument pas les memes fonctions (chimiques). Elles sont cependant une base commune, à savoir un ensemble d'atomes et de liaisons, que je suis censé lire dans un fichier. Un fichier de protéine sera lu de la même façon qu'un fichier de ligand, mais cependant, il faut que je les enregistre dans des classes différentes car elles ont un comportement différent.

Est-ce que, au regard de mes codes, vous pourriez m'écrire le code qui prends en compte le polymorphisme, car j'ai essayé tout hier soir, et ce n'était qu'un vulgaire echec ...

Merci !!

**Astraya** · 22/10/2010, 15h39

Ca semble déjà être le cas vue la déclaration de ModeBase et, par ailleurs, ligand et protéine ne désignent pas des molécules précises mais bien des familles aux comportements spécifiques et non interchangeables :

Bas je suis pas biochimiste alors bon

**gilims** · 22/10/2010, 15h51

Si ca peut te rassurer ... MOI NON PLUS !!!

**Astraya** · 22/10/2010, 16h16

Donc, les molécules ont toutes un comportement différent, mais on un comportement. Voici donc une fonction polymorphique spécifique à chaque type de molécule ou famille, j'en sais rien.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
class MoleBase
{
 private :
        vector<Atom*> atoms;            /*!< Contain All Atoms */
        vector<Bond*> bonds;            /*!< Contain All Bonds */
 public:
    MoleBase();
    ~MoleBase();
    void Add_Atom(Atom *_atome);
    void Add_Bond(int _Atom1, int _Atom2, BondType Type);
    virtual void comportementSpecifique();
 
};
 
  class Ligand : public MoleBase
{
 public:
    void comportementSpecifique()
    {
        // Comportement de Ligand...
    };
};
 
 
//Utilisation  
 
int main()
{
 
    MoleReader MolRead("/Users/ethane.mol2",MOL2);
 
    MoleBase *Mols = MolRead.Read_MOL2();
    Mols->comportementSpecifique(); //ici le comportement spécifique le plus spécialisé sera appelé
     return 0;
}

Tu peux améliorer d'avantage avec le CRTP

**Joel F** · 22/10/2010, 16h20

Envoyé par Astraya

Bas justement, au lieu de travailler avec une 30ène de molécule et de classes différentes, travailler avec son abstraction et spécialiser les actions entreprises par les molécule dans chaque classes.

c'ets le rôle des méthodes virtuelles pas de la RTTI