Petite question sur les héritages?

Version imprimable

13/02/2009, 16h07
razonback

Petite question sur les héritages?

Bonjour à tous, voila j'ai un petit problème.
J'aimerais savoir si on peut stocker, dans un tableau d'une classe mère, des éléments d'un de ses fils et surtout, le plus important, si on ne perd pas de données. Je pense que c'est possible, alors si oui pouvez vous me mettre un petit bout de code pour voir comment je peux récupérer les données qui sont uniquement dans la classe fille de ce tableau. Merci !
13/02/2009, 17h08
koala01

Salut,

Ta demande n'est pas très claire, et j'ai peur de répondre "à coté" de ce que tu demandes...

Pourrais tu nous donner un exemple de ce que tu veux vraiment faire :question:

Cependant, je peux déjà attirer ton attention sur le fait qu'une classe mère ne sait absolument rien de ce qui compose les classes qui en dérivent... Peut être est-ce que cela répondra déjà en partie à ta question ;)
14/02/2009, 00h45
LittleWhite
Je vais aussi essayer de donner une indication, sachant que il faudrai préciser un peu la question ...

Nous avons une classe A ( que nous appelerons classe mère )
A contient une variable ( toto )
Nous avons une classe B ( qui hérite de A )
B peut accéder à toto, car B est un A , mais A n'est pas un B ( je sais plus comment on formule ce principe fondamental ).
Bref , du code un peu ( ça parle mieux que moi ) ( et je montre une autre chose fondamentale en passant )
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 class A { public: int toto_public; private: int toto_private; protected: int toto_protected; }; class B : public A { }
Si je fais dans la classe B une fonction qui utilise toto_public ( accès + modification ) ça marche.
Si je fais dans la classe B une fonction qui utilise toto_protected ça marche aussi.
Par contre si j'essaie avec toto_private ça marche pas. Les private sont conservés, et ne peuvent être utilisé que par la classe elle même ( même pas par ces filles )

Dans une fonction en dehors des classes A et B , l'accès ne sera possible que sur les toto_public ( pour cela que les fonctions sont souvent en public , pour pouvoir les utiliser ).

Par nous pouvons remarquer que j'ai un héritage public ( : public A ), je sais que cela me permet de garder l'accès des variables aux filles.
Mais dans le cas dans protected, ça change, genre les variables protected de A deviennet privé dans B ( donc seulement accéssibles dans B ) ... et donc plus hérité dans une classe qui hérite de B.

En conclusion, pour faire simple, il est donc possible d'utiliser les variables d'une classe mère dans une classes filles. Après il faut faire attention à la visibilité

=> Lien qui sera mieux que moi : http://cpp.developpez.com/cours/cpp/?page=page_10#LX-E

Je vais vous donner un exemple pour être plus clair. Comme vous pouvez le voir si dessous, je crée trois classes. La classe de base Bonbon et deux de ses sous classes Dragibus et Caramel. Ensuite dans mon "main", j'aimerais avoir un tableau qui me permet d'avoir des cases avec des Dragibus et des Caramel. Je me suis donc dit qu'il fallait un tableau de type Bonbon. Mais à ce moment la je ne peux pas accéder à toutes les informations. Donc ma question est:
Comment faire pour avoir un tel tableau et pouvoir acceder à toutes les informations de chaque case?
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 class Bonbon { public : int couleur; public : }; class Dragibus : public Bonbon { public : double cacao; int cafe; char capourrilesdents; public : Dragibus( double d, int a, char c) { cacao = d; cafe= a; capourrilesdents = c; couleur = 12121212; } }; class Caramel : public Bonbon { public : int sucette; float rutabaga; public : Caramel( int a, float q) { sucette = a; rutabaga = q; couleur = 21; } }; int main() { Bonbon * tab; tab = new Bonbon[2]; Dragibus drag( 234, 45, 'c'); Caramel mel( 678, 45.89); tab[0] = drag; tab[1] = mel; }

Hum et bien tu peux faire ça (je crois que c'est considéré comme "pas propre") :

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
55
56
57
58
59
60
61
62
63
64
65
66
enum BonbonType
{
    BONBON_DRAGIBUS,
    BONBON_CARAMEL
};
 
class Bonbon
{
public :
 
    virtual BonbonType GetType() const = 0;
    ...
};
 
class Dragibus : public Bonbon
{
public :
 
    virtual BonbonType GetType() const
    {
        return BONBON_DRAGIBUS;
    }
    ...
};
 
class Caramel : public Bonbon
{
public :
 
    virtual BonbonType GetType() const
    {
        return BONBON_CARAMEL;
    }
    ...
};
 
int main()
{
    // Note : à ce stade, un std::vector ou une std::map est plus pratique...
    Bonbon** tab = new Bonbon*[2];
    tab[0] = new Dragibus( 234, 45, 'c');
    tab[1] = new Caramel( 678, 45.89);
 
    for (int i = 0; i < 2; ++i)
    {
        Bonbon* b = tab[i];
        if (b->GetType() == BONBON_DRAGIBUS)
        {
            Dragibus* d = (Dragibus*)b;
            // On utilise "d" comme on veut
            ...
        }
 
        if (b->GetType() == BONBON_CARAMEL)
        {
            Caramel* c = (Caramel*)b;
            // Pareil...
            ...
        }
    }
 
    // ... et on oublie pas ça :)
    for (int i = 0; i < 2; ++i)
        delete tab[i];
    delete[] tab;
}

L'inconvénient, c'est que si GetType() renvoie un truc faux, le programme ne va pas aimer... Donc source d'erreur.

Normalement, quand on utilise l'héritage, la classe mère possède des méthodes qui sont souvent ré-implémentée par les classes filles.
Du coup, quand on parcours ton tableaux de Bonbon, on ne se soucie pas de savoir de quel type ils sont, on appelle juste les méthodes de Bonbon qui auront été ré-implémentées par Caramel et Dragibus :

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
55
56
57
58
59
60
class Bonbon
{
public :
 
    virtual int GetColor() const = 0;
    virtual void Display() const = 0;
    ...
};
 
class Dragibus : public Bonbon
{
public :
 
    virtual int GetColor() const
    {
        return 1212121212;
    }
 
    virtual void Display() const
    {
        // Afficher un joli dragibus
    }
    ...
};
 
class Caramel : public Bonbon
{
public :
 
    virtual int GetColor() const
    {
        return 21;
    }
 
    virtual void Display() const
    {
        // Afficher un joli caramel
    }
    ...
};
 
int main()
{
    // Note : à ce stade, un std::vector ou une std::map est plus pratique...
    Bonbon** tab = new Bonbon*[2];
    tab[0] = new Dragibus( 234, 45, 'c');
    tab[1] = new Caramel( 678, 45.89);
 
    for (int i = 0; i < 2; ++i)
    {
        Bonbon* b = tab[i];
        int bonbonColor = b->GetColor();
        b->Display();
    }
 
    // ... et on oublie pas ça :)
    for (int i = 0; i < 2; ++i)
        delete tab[i];
    delete[] tab;
}

Dans la boucle, on fait donc tout sans savoir à quel type de bonbon on a affaire.

Edit : j'avais pas fait attention à la construction du tableau... :oops: C'était pas très joli :)