Bonjour tout le monde,

Je viens vous poser des questions à props de l'héritage.

J'ai compris qu'on avait une classe mère (de base) et une classe fille (dérivée).

Si ma classe fille hérite en public de la classe mère, elle aura accès à tout ce qui est en public dans la classe mère.

Par contre, s'est quand j'hérite en protected et en private dans la classe fille que je ne comprends plus.

J'ai fais des tests et j'ai l'impression que l'héritage en protected et en private ne me donne pas le droit d'utiliser les objets de la classe mère, mais alors à quoi ça sert ce protected et ce private ?

Dans mon cours, j'ai trois classes, une hérite en privé de ça classe mère et est aussi la classe mère d'une autre classe qui hérite en publique :

#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 : private 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 d'avance pour votre aide

Tu peux faire de l'héritage sans avoir à utiliser les attributs définis dans la classe mère : dans ce cas la classe fille ne fait que surcharger les méthodes de la classe mère (on peut voir ca comme l'implémentation d'une interface en Java).

_____________________________________
Un éditeur de ressources gratuit pour Windows

Merci pour ta réponse.

S'est ce qui est fait dans le code de mon mesage ?

Merci encore

DD

Je parlais plutot de ca:

class A
{
    virtual void methode1() {...}
ou bien
    virtual void methode1() = 0;
};

class A : private A
{
    virtual void methode1() {on redéfinit méthode 1}
}

_____________________________________
Un éditeur de ressources gratuit pour Windows

Merci pour ta réponse.

Les méthodes virtuelles on a pas encore vue.

Par contre un copain de ma classe à qui j'ai présenté le même problème me dit ceci :

tu n'as pas acces au priver mais tu a acces au public

dans les fonctions

regarde

CChaineComposee::CChaineComposee(const CChaineComposee& Source)
:CChaine(Source),m_NbrChamps ,m_Champs(NULL)
{
 Chaine("hello");
 if(EstVide())
  printf("ee");
 if (Source.m_NbrChamps > 0)
 {
  m_Champs = (char**)malloc(Source.m_NbrChamps*sizeof(char*));
  if (m_Champs != NULL)
  {
   m_NbrChamps = Source.m_NbrChamps;
   for (long n=0; n < Source.m_NbrChamps; n++)
   {
    long PosRel = Source.m

regarde les premiere ligne

tu a acces au constructeur

et au fonction

de l'interieur de la classe

donc je pense ( je pense beaucoup mais demande un truc officiel a la rentrée)

privée en heritage

met tout ce que contient la classe hériter en privée pour l'utilisateur*

mais permet de se servir des attribut public dans les fonction de la chaine qui hérite

*et bien les fonction public de CChaine ne sont pas utilisable dans le main par exemple
*tu ne peut pas faire
*CChaineComposee marco.Chaine("hello")

Comprends tu ce qu'il veut dire ?

Merci

Tu peux te rendre sur cette page qui explique les différents héritages.

Tableau 8-1. Droits d'accès sur les membres hérités

		mot clé utilisé pour l'héritage
Accès aux données		public	protected	private
mot clé utilisé	public	public	protected	private
pour les champs	protected	protected	protected	private
et les méthodes	private	interdit	interdit	interdit

Pour résumer :
-Tu ne peux jamais utiliser les choses privées
-En héritage public, les protections ne changent pas
-En héritage protected, les membres publics deviennent protected
-En héritage private, les champs protected et public deviennent private
_____________________________________
Un éditeur de ressources gratuit pour Windows