Discussion :

[GOUGOU1]

Salut tout le monde.
Bon, en fait, le titre de mon post porte à confusion, mais bon, je savais pas quoi mettre en fait.
Je sais ce que signifie ces mots clés :
Public => accessible par tous les objets externes.
Private => Uniquement accessible par l'objet (et par tout ceux de sa classe aussi je crois ?)
Protected => Comme private, mais en plus, les objet qui héritent de cet objet peuvent accédé aux données et membres Protected ( ce qui n'ets pas le cas pour les variables private).

BRef, voilà mon problème.
J'ai 3 classes :

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
 
class A
{
     public :
        int p_a;
        int p_fa();
     protected :
       int pr_a;
       int pr_fa();
};
 
class B : public A;
{
     public :
        int p_b;
        int p_fb();
     protected :
       int pr_b;
       int pr_fb();
};
 
class C : public B
{
     public :
        int p_c;
        int p_fc();
};

Donc voilà, normalement, la classe C au final, après compilation devrais ressembler à çà :

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
 
class C : public B
{
     public :
        int p_a;
        int p_b;
        int p_c;
        int p_fa();
        int p_fb();
        int p_fc();
 
     private :
       int pr_a;
       int pr_b;
       int pr_fa();
       int pr_fb();
};

Alors voilà, je voudrais savoir s'il est possible d'interdire à l'objet C d'accéder à tout ce qu'il possède dans sa partie Private.
Par exemple, admettons que A soit du type Objet, B du type objet deplaçabe et C du type voiture.
La classe A possède par exemple la méthode définir model 3D. Bin je ne voudrais pas que l'objet voiture puisse accéder à cette méthode, car une voiture, çà se contente de rouler.

Voilà, j'espère que vous avez compris ce que je voulais faire (à mon avis, je me suis mal exprimé, mais c'est un peu bizarre comme truc, j'en conviens lol}

@++

[xterminhate]

Ton seconde code est completement faux.

[DarkWiken]

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
 
class A 
{ 
     public : 
        int p_a; 
        int p_fa(); 
     protected : 
       int pr_a; 
       int pr_fa(); 
}; 
 
class B : protected A; 
{ 
     public : 
        int p_b; 
        int p_fb(); 
     private : 
       int pr_b; 
       int pr_fb(); 
}; 
 
class C : protected B 
{ 
     public : 
        int p_c; 
        int p_fc(); 
};

Essaie avec ça... Mais bon, c'est assez tordu l'heritage à ce niveau là

[salseropom]

question d'implémentation, remplace

Code :

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

1
2
 
class B : protected A;

par

Code :

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

1
2
 
class B : protected A

[JolyLoic]

Pourquoi ne pas simplement mettre ta fonction private dans A ?

[GOUGOU1]

Bin car je voudrais que B puisse l'utiliser, mais pas l'objet C.
Car l'objet C, il est bien plus évolué que l'objet A, donc il n'a pas besoin d'accéder aux méthodes de si bas niveau.
@++

[JolyLoic]

Es-tu certain de ne pas avoir de problème quand tu défini ta structure d'héritage ? Ton souhait d'avoir une fonction dans A appelable dans les dérivées (comme B), mais pas dans C, me fait poser la question de savoir si tu devrais vraiment avoir C dérivant de B. De même, l'exemple que tu donnes avec une classe Objet à la base n'est pas très probant (une telle classe est souvent une mauvaise idée en C++).

Pour dire autrement, pourrais-tu décrire tes vrais classes, qu'on puisse mieux voir ton problème ?

[GOUGOU1]

Alrs, en fait, ma première classe est la classe Objet, mais Objet au sens Objet 3D.
Elle dispose de méthodes permettant de choisir le model 3D à afficher, de le placer à un point, de le tourner, etc....
De cette classe, hérite la classe Objet_Deplable, qui est un Objet 3d, que l'on peut........; Deplacer (trop dur). En gros, ce sont des objet qui seront passés en paramètre à un moteur physique. Et enfin, de cette classe, hérite tous les objets "réels" : voiture, roquette, lapin, etc....
Bref, un lapin, çà marche, recule et straph, mais çà ne peux pas changer de model 3D
donc en gros, je veux que mon lapin, il puisse utiliser les fonctions des classes de dessus, mais quand je vais l'utiliser dans mon programme, je veux ne pas pouvoir faire çà :

Code :

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

1
2
Lapin Roger.
Roger->definir_model3d("LapinBlanc.3ds");

De même qu'en interne, je ne veux pas pouvoir faire çà :

Code :

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

1
2
3
4
5
 
void Lapin::FonctionALaCon(char* model)
{
    this->definir_model3d(model);
}

Voilà.
Je ne sais pas si c'est possible.
@++

[Laurent Gomila]

J'imagine que Objet et Objet_Deplacable sont des classes abstraites, alors dans ce cas comment voudrais-tu donc appeler ta fonction definir_model3d autrement que sur les objets "finaux" (les feuilles de ta hiérarchie) ? Si ça fait partie de l'interface publique des classes mères, je ne vois pas pourquoi ça ne le serait plus pour les classes dérivées.

A part ça, ça me parait pas genial de mélanger les objets affichables et les objets déplaçables. Idéalement je pense que tu devrais dériver ton lapin de Objet_Affichable et de Objet_Collidable, par exemple.

[JolyLoic]

Et le jour où ton lapin aura trouvé une bouteille de jus de carottes fermenté, es-tu certain de ne pas vouloir faire Roger->definir_model3d("LapinBlancBourré.3ds");

[GOUGOU1]

Bin en fait, la classe Objet est pour tout objet disposant d'un model 3D.
De cette classe hérite les objet_deplaçables, mais aussi les objets statics.
Il n'existe pas d'objets non affichables dans mon programme, et tous les objets genèrent une zone de collision, c'et spour çà que j'ai choisi cette représentation.

JolyLoic : Non, j'appelerais la méthode

Code :

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

1
2
3
4
5
6
7
 
void Lapin::setEtatLapin(LapinBourré)
{
    this->setComportement(Bourré);
    this->setPrecisionMouvements(0.01);
    this->addTimeout(3000,vomir());
};

[Laurent Gomila]

D'accord mais au final, tu l'appelles où ta fonction definir_model3d si ce n'est pas sur tes objets ?

[GOUGOU1]

Euh, là, je pense qu'en fait, je me rend compte que mon truc est impossible, car oui, cette méthode, je devrais forcement l'appeler dans mon objet final, à moins que l'on puisse faire comme en java, en utilisant le mot clé super(), ce qui me permettrait d'appeler le constructeur de la classe supérieure, et donc de ne pas avoir a appeler cette méthode définirModel3D.
Est-ce possible ?

@+++

[Laurent Gomila]

Oui tu peux appeler le constructeur des classes mères avec la liste d'initialisation. Mais dans ce cas tu peux définir ta fonction privée dans A non ?

Code :

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

1
2
3
4
5
6
7
8
9
class Objet
{
    Objet(const char* name) {definirModele3D(name);}
};
 
class ObjetDeplacable : public Objet
{
    ObjetDeplacable(const char* name) : Objet(name) {}
};

[GOUGOU1]

Cool.
En fait, la fonction, il faut qu'elle soit accessible dans B aussi, car la classe B doit pouvoir changer le model (en fonction de la vie de l'objet par exemple). C'ets la classe C qui ne doit pas pouvoir y accéder.

Mais par contre, qu'est-ce qui change entre çà

Code :

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

 class ObjetDeplacable : public Objet

çà,

Code :

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

 class ObjetDeplacable : private Objet

et çà

Code :

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

 class ObjetDeplacable : protected Objet

?

en fait, j'exploite pas a fond les concepts objets, et j'aimerais en savoir un peu plus.
Merci, et @++

[Laurent Gomila]

Le mieux est de trouver un cours pour ça, typiquement tu as un tableau qui récapitule les différents types d'héritage.

En gros et sans doute avec quelques erreurs :

- Héritage public : public reste public, protected reste protected, et private est innaccessible.

- Héritage protected : public devient protected, protected le reste, et privte toujours innaccessible.

- Héritage privé : tout devient privé, sauf ce qui est privé qui reste lui encore et toujours innaccessible.

L'héritage public est un héritage d'interface, càd que si B dérive publiquement de A c'est que des instances de B pourront être manipulées comme des A.

L'héritage privé est équivalent à une composition.

Pour l'héritage protégé par contre... On l'utilise très rarement.

[GOUGOU1]

Ok.
Merci pour tout, je vais tenter de me débrouiller maintenant avec tout çà.
@++