Je ne comprends pas l'héritage en protected

beegees

30 mars 2008 à 15:34:42

Bonjour tout le monde,

J'ai une classe de base que voici :

class CPersonne
{
public:
CPersonne();
CPersonne(const char* Nom,const char* Prenom,int Age);
~CPersonne();
bool Nom(const char* UnNom);
bool Prenom(const char* UnPrenom);
protected:
bool Age(int UnAge);
private:
double m_Sexe;
};

J'ai une classe dérivée qui va hériter d'une manière Protected à la classe de base :

class CGarcon : protected CPersonne
{
};

Dans le main, je fais ceci :

CGarcon Eric;
Eric.Age(3);

à la compilation, j'ai ce message d'erreur :

Citation : beegees

error C2248: 'Age' : cannot access protected member declared in class 'CPersonne'

Je ne comprends pas alors l'intérêt d'hériter de manière Protected d'une classe de base si on ne peut pas utiliser ces fonctions protégées.

Sauriez-vous m'expliquer car je n'ai pas compris.

Un super grand merci d'avance.

beegees

askerat

30 mars 2008 à 15:40:33

Si si on peut, seulement tu as du oublié d'inclure un header ou un truc du genre. Car en gros private c'est uniquement pour ce qui est des methodes / propriétées internes au fonctionnement de la classe, protected c'est un peu pareil, mais ça peut être etendu aux classes filles, et public est accessible depuis n'importe quelle classe qui instancie ta classe. Et ajoutes un constructeur à CGarcon, concevoir une classe, meme héritée sans meme y intégrer un constructeur je ne l'ai jamais fait. Ne serais ce que pour appeller le constructeur de CPersonne.

beegees

30 mars 2008 à 16:07:13

Merci pour ta réponse.

Quand tu dis :

Citation : askerat

private c'est uniquement pour ce qui est des methodes / propriétées internes au fonctionnement de la classe

Quel est l'intérêt alors de mettre CGarcon : private CPersonne ???

ça ne fonctionne toujours pas mais pourtant le header est inclus.

Voici mon code :

le header (.h) :

class CPersonne;
class CGarcon;
class CPersonne
{
public:
CPersonne();
~CPersonne();
void Nom(const char* UnNom);
bool Prenom(const char* UnPrenom);
protected:
bool Age(int UnAge);
private:
double m_Sexe;
};
class CGarcon : public CPersonne
{
public:
CGarcon();
~CGarcon();
};

Voici le fichier .cpp qui contient les constructeurs et destructeurs :

#include <BasicConsole.h>
#include "test.h"
CPersonne::CPersonne()
{
}
CPersonne::~CPersonne()
{
}
CGarcon::CGarcon()
{
}
CGarcon::~CGarcon()
{
}
CGarcon::Nom("Eric")
{
}

Et voici mon main :

#include <BasicConsole.h>
#include "test.h"

void main()
{
CGarcon UnGars;
UnGars.Nom("Eric");
}

me donne :

Citation : compilateur C++

error C2248: 'Age' : cannot access protected member declared in class 'CPersonne'

Merci encore pour ton aide.

beegees

askerat

30 mars 2008 à 16:14:44

Essaye voir d'ajouter :

CGarcon() : CPersonne();

dans le .h et dans le .cpp pour appeller le constructeur de la classe mere. Normalement si tu le specifies pas il est appellé automatiquement ( du moins en java ), je me suis mis sur le C++ que récemment.

minirop

30 mars 2008 à 16:32:15

Citation : beegees

Je ne comprends pas alors l'intérêt d'hériter de manière Protected d'une classe de base si on ne peut pas utiliser ces fonctions protégées.

l'erreur (je pense) est que comme tu utilises un héritage protected, les fonctions public deviennent protected donc ceci n'est pas possible :

CGarcon UnGars;
UnGars.Nom("Eric"); // Nom() est protected

beegees

30 mars 2008 à 18:50:48

Citation : minirop

Citation : beegees

Je ne comprends pas alors l'intérêt d'hériter de manière Protected d'une classe de base si on ne peut pas utiliser ces fonctions protégées.

l'erreur (je pense) est que comme tu utilises un héritage protected, les fonctions public deviennent protected donc ceci n'est pas possible :

CGarcon UnGars;

UnGars.Nom("Eric"); // Nom() est protected

Merci Minirop pour ta réponse.

Je pense que tu as raison quand tu dis que les fonctions publiques deviennt protected quand je j'hérite de façon protected.

Mais alors à quoi ça sert de mettre protected et Private si on ne peut pas accèder à partir de la classe fille aux fonctions membres et variables ?

Je ne comprends pas l'intérêt.

J'espère que vous pourrez encore m'aider.

Merci
beegees

danman

30 mars 2008 à 18:58:15

je crois qu'il faut heriter en public

donc

class CGarcon : protected CPersonne
{
};

devien

class CGarcon : public CPersonne
{
};

beegees

30 mars 2008 à 19:03:01

Merci pour ta réponse danman,

Si j'hérite en pubic, ça fonctionne.

Mais alors, je ne sais pas pourquoi on peut et on met le protected et le private comme dans l'exemple ci-dessous :

#ifndef CHAINE_H
#define CHAINE_H
class CChaine
{
public:
CChaine(); // Constructeur par défaut
CChaine(const CChaine& Source); // Constructeur par copie
CChaine(const char* UneChaine); // Constructeur spécifique
~CChaine(); // Destructeur
const char* Chaine() const; // Accesseur du texte de la chaîne
bool EstNull() const; // Accesseur de test sur le texte (m_Chaine == NULL)
bool EstVide() const; // Accesseur de test sur le texte (m_Chaine == NULL) || (m_Chaine == "")
void Vider(); // Modificateur permettant de supprimer le texte de la chaîne (on revient à NULL)
bool Chaine(const char* UneChaine); // Modificateur du texte de la chaîne
private:
char* m_Chaine; // Membre contenant l'adresse du tableau de caractères alloué dynamiquement
};
class CChaineComposee : <couleur nom="rouge">private</couleur><gras/> CChaine
{
public:
CChaineComposee(); // Constructeur par défaut
CChaineComposee(const CChaineComposee& Source); // Constructeur par copie
CChaineComposee(const char* UneChaine, char UnSeparateur); // Constructeur spécifique
~CChaineComposee(); // Destructeur
long NombreChamps() const; // Accesseur du nombre de champs
const char* Champs(long Indice) const; // Accesseur d'un champ
bool Definir(const char* UneChaine, char UnSeparateur); // Modificateur permettant de modifier la chaîne et de générer le tableau des champs
private:
bool Decomposer(char UnSeparateur); // Modificateur permettant de modifier la chaîne et de générer le tableau des champs
private:
long m_NbrChamps;
char** m_Champs;
};
class CChargeurFichierTexte : public CChaineComposee
{
public:
CChargeurFichierTexte();
~CChargeurFichierTexte();
bool Charger(const char* NomFichier, char UnSeparateur, bool (* FctnTraiterLigne)(const CChargeurFichierTexte&, void*), void* Contexte);
private:
};
#endif//CHAINE_H

Merci pour la lumière que vous m'apporterez.

beegees

lmghs

30 mars 2008 à 20:02:35

Oublie l'héritage protégé, il y a quelques rares idiomes qui l'exploitent, mais en général on n'utilise que :
- l'héritage public quand on veut la substituabilité (et éventuellement importer du code)
- l'héritage privé quand on veut importer du code sans permettre la substituabilité.

Comprends la notion fondamentale de substituabilité, et tu auras compris l'héritage.

Anonyme

30 mars 2008 à 21:52:13

Pour simplifier le propos de lmghs (qui est à 100% correct) utilise l'héritage public quant ta classe dérivé peut remplacer l'objet de base et l'héritage privé quand ta classe dérivé exprime la relation "Est implémenté sous forme de".

Exemple :
Pour l'héritage public:
un stylo est un machin_pour_ecrire.
Tu peux remplacer n'importe quel machin_pour_ecrire par un stylo.

Pour le private:
Une pile est une implémentation classe_De_Stockage

lmghs

30 mars 2008 à 22:22:07

C'est plus subtil que ça (pour les exemples)

Une liste triée sera implémentée en terme de liste (sans en "être-une"), et pourtant toutes deux pourraient être vue comme des séquences bi-directionnellement itérables qui proposent le retrait en O(1).

(Si je ne me suis pas plus étendu cette fois, c'est parce que j'ai déjà rabâché à n'en plus finir sur le sujet ; google est ton ami)