Problème d'instanciation de classe C++

Version imprimable

21/10/2010, 14h27
gilims

Problème d'instanciation de classe C++
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:

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:

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 !

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:

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;
}

21/10/2010, 15h58
Astraya
Bonjour gilims,

Citation:

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:

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:

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:

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
21/10/2010, 18h05
gilims
@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:

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:

1 2 B *Proteine = Get_Data(); C *Ligand = Get_Data();
sans avoir à réécrire 2 fois le code.
21/10/2010, 18h30
Invité
Bonjour,

Alors le prototype de Get_Data c'est:

Code:

A* Get_Data();

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

Code:

A* a;

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

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

Code:

return a;

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

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:

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:

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:

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:

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

Et enfin le reader :

Code:

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:

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 ...

21/10/2010, 19h46
Astraya

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.

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

Code:

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.

21/10/2010, 22h36
Joel F

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.
22/10/2010, 13h13
Astraya

Citation:

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.

Citation:
Envoyé par gilims
Le MoleBase.h (classe A dans l'exemple)
Code:

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); };
Citation:

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 :

Citation:

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 :roll:

22/10/2010, 15h01
gilims

Citation:

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 ... :cry: Merci !!
22/10/2010, 15h39
Astraya

Citation:

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 :D
22/10/2010, 15h51
gilims

Si ca peut te rassurer ... MOI NON PLUS !!! :mrgreen::aie:

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:

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

22/10/2010, 16h20
Joel F

Citation:

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
22/10/2010, 16h23
Astraya

Citation:

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

On n'a pas du ce comprendre, je disais justement qu'il fallait utiliser les méthodes virtuelles et pas le RTTI qui pour moi est le mal ;)
22/10/2010, 16h28
Joel F

Citation:

Envoyé par Astraya

On n'a pas du ce comprendre, je disais justement qu'il fallait utiliser les méthodes virtuelles et pas le RTTI qui pour moi est le mal ;)

Note pour plus tard: pas poster sans café
22/10/2010, 16h39
gilims

Citation:

Note pour plus tard: pas poster sans café

J'en suis à mon quatrième et ma calvitie ne cesse de s'amplifier !! :P

En tout cas, merci les gars !!! J'ai trouvé mon bonheur dans vos réponses !!! :ccool:Je vais utiliser la méthode d'Astraya !!