Héritage, Accès aux données ...

Version imprimable

Bonjour,

Je rencontre un problème pour enregistrer certaines données dans mon arborescence de Classes.

Mon programme se construit sur 3 classes héritantes :

Classe A <- Classe B <- Classe C

Si je construit un objet de classe C, est il possible de l'enregistrer dans la classe A ? Comment accèder à l'objet de classe C à partir de la classe A ?

Voici mon programme :

main.cpp : Ici, je désire enregistrer dans classe A l'élément que retourne la fonction Builder.
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 int main (int argc, char *argv[]) { if (argc > 1) { ClasseA first = Builder(argv[1]); } else { cout << "\nVeuillez entrer l' argument." << endl; } cout << endl; system("PAUSE"); }
Builder.cpp : La est le probleme car j'aimerai retourner un objet de type ClasseA contenant les informations que je crentre dans Test lui même de type ClasseC.
Code:

1 2 3 4 5 6 7 8 9 ClasseA ClasseA::Builder(char *nom) { if (strcmpi(nom,"toto") == 0) { ClasseC *Test = new ClasseC(); return Test; }
J'espere ne pas être trop confu dans ma demande :?

27/04/2006, 17h45
Laurent Gomila

Fais une recherche sur le design pattern "factory", c'est un truc qui revient toutes les semaines.

En gros l'idée c'est de renvoyer un pointeur sur A* (qui pourra donc très bien pointer sur un C), et d'exploiter ensuite le polymorphisme via des fonctions virtuelles.
27/04/2006, 18h41
Joad

Merci de ta réponse. J'ai fait quelques recherches via ce forum et Google mais j'avoue que je m'y perd un peu. Et, les expliquation sont quand mêmes assez complexe.
Pourrais tu me fournir une ébauche d'explication mais orientée vers mon propre problème?
27/04/2006, 18h52
Matthieu Brucher

Ici, c'est appelé monteur mais c'est la même chose, en gros.

http://smeric.developpez.com/java/uml/monteur/

Faut quand même mettre l'adresse :oops::oops:

C'est très simple :

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
49
50
51
52
53
54
// Il te faut une classe de base, ici ClasseA visiblement
class ClasseA
{
public :
 
    virtual void DoSomething() = 0;
};
 
// ... puis des dérivées
class ClasseB
{
public :
 
    virtual void DoSomething() {cout << "B" << endl;}
};
 
class ClasseC
{
public :
 
    virtual void DoSomething() {cout << "C" << endl;}
};
 
// Ensuite, il faut une factory pour créer les ClasseA en fonction d'un identifiant
class Factory
{
public :
 
    ClassA* Build(const string& Name) const
    {
        if (Name == "ClassB")
            return new ClassB;
        else if (Name == "ClassC")
            return new ClassC;
        else
            return NULL;
    }
};
 
// Puis on utilise tout ça
int main(int argc, char *argv[])
{
    // On instancie la factory
    Factory Fact;
 
    // On crée une instance selon l'argument passé au programme
    ClassA* C = Factory.Build(argv[0]);
 
    // On utilise notre ClassA* polymorphiquement, càd via ses fonction virtuelles
    if (C)
        C->DoSomething();
 
    return 0;
}

C'est vraiment une version de base pour t'expliquer, après typiquement on stocke dans la factory des fonctions de création dans une table associative, on peut aussi rendre la factory générique via l'utilisation de templates, etc... Tu trouveras le code pour tout ça sur le forum, notamment.

27/04/2006, 20h24
Joad

Super Merci beaucoup, ca marche !
27/04/2006, 20h36
Swoög

Salut

Je pense qu'on pourrait aussi utiliser des références plutôt que des pointeurs... normalement le polymorphisme marche toujours non ?

et dans le cas où on mets "NULL" on lève une exception, comme ça impossible d'ignorer l'erreur et de risquer le segfault...

Qu'en pensez-vous, il y a-t-il un risque quelque part ?
27/04/2006, 20h39
Matthieu Brucher

Non, car l'objet est créé à l'intérieur de la classe et supprimé à sa sortie :|

Citation:

Envoyé par Miles

Non, car l'objet est créé à l'intérieur de la classe et supprimé à sa sortie :|

Je pensais à quelque chose de ce style :

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
    ClassA& Build(const string& Name) const
    {
        if (Name == "ClassB")
            return *new ClassB;
        else if (Name == "ClassC")
            return *new ClassC;
        else
            //throw Exception
    }
};
 
[...]
 
// Puis on utilise tout ça
int main(int argc, char *argv[])
{
    // On instancie la factory
    Factory Fact;
 
    try {
        // On crée une instance selon l'argument passé au programme
        ClassA& C = Factory.Build(argv[0]);
 
        // On utilise notre ClassA& polymorphiquement, càd via ses fonction virtuelles
        C.DoSomething();
    } catch (/*l'exception*/) { cerr <<"Erreur a la construction"; }
    return 0;
}

27/04/2006, 22h41
Matthieu Brucher

Mais il faut faire un delete dessus après.
Enfin, je ne sais pas, il faudrait tester.
27/04/2006, 22h54
Swoög

Citation:

Envoyé par Miles

Mais il faut faire un delete dessus après.
Enfin, je ne sais pas, il faudrait tester.

heu, je ne sais pas si le delette est nécessaire... en toutes logique oui, étant donné qu'il n'y a pas de GC en C++... en même temps, il devrait y avoir tout de même une résolution de portée ^^ à tester en effet ;)
27/04/2006, 23h02
MatRem

Pourquoi le delete ne serait pas nécessaire ??? D'ailleurs il est aussi dans l'exemple de Loulou non?
27/04/2006, 23h11
Matthieu Brucher

Quand on fait un new, le delete ne devrait JAMAIS être très loin.
27/04/2006, 23h16
MatRem

Ha bon je préfère :mrgreen:, j'ai eu peur de ne plus comprendre rien à mon langage favori :mur:.
28/04/2006, 11h16
Matthieu Brucher

En même temps, si on utilise des smart pointers, plus besoin :)