Publicité
+ Répondre à la discussion
Affichage des résultats 1 à 4 sur 4
  1. #1
    Invité régulier
    Homme Profil pro
    Étudiant
    Inscrit en
    janvier 2013
    Messages
    40
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Maroc

    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : janvier 2013
    Messages : 40
    Points : 8
    Points
    8

    Par défaut Héritage cpp redéfinition

    Lorsqu' une fonction membre est définie dans une classe, elle masque toutes les
    fonctions membres de même nom de la classe de base (et des classes ascendantes).
    Autrement dit, la recherche d’une fonction (surdéfinie ou non) se fait dans une
    seule portée, soit celle de la classe concernée, soit celle de la classe de base (ou
    d’une classe ascendante), mais jamais dans plusieurs classes à la fois.


    j'ai pas compris la phrase souligner

  2. #2
    Membre éprouvé

    Homme Profil pro
    Caissier
    Inscrit en
    décembre 2012
    Messages
    291
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Maine et Loire (Pays de la Loire)

    Informations professionnelles :
    Activité : Caissier

    Informations forums :
    Inscription : décembre 2012
    Messages : 291
    Points : 453
    Points
    453

    Par défaut

    (bonsoir)
    Une classe de base se nommant animal, parent de chien, chat...contenant un prénom.
    Si tu veux récupérer le prénom, soit :
    ou :
    Mais tu n'auras jamais les deux en même temps car elles renvoient à la même fonction.

  3. #3
    Membre habitué Avatar de zhouyu
    Homme Profil pro Loïc
    Étudiant
    Inscrit en
    octobre 2009
    Messages
    84
    Détails du profil
    Informations personnelles :
    Nom : Homme Loïc
    Âge : 26
    Localisation : France

    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : octobre 2009
    Messages : 84
    Points : 131
    Points
    131

    Par défaut

    Salut.
    Ce qu'il explique c'est que tu n'as accès qu'a une instance de ta méthode en fonction de la classe que tu utilises.
    Exemple :
    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
     
        public class A
        {
            public void affiche()
            {
                printf("A \n");
            }
        }
     
        public class B : A
        {
            public void affiche()
            {
                printf("B  \n");
            }
        }
     
        public class C : B
        {
        }
     
        public class D : C
        {
            public void affiche()
            {
                C::affiche();//pas sur de la syntaxe
                printf("D  \n");
            }
        }
    Une méthode affiche est défini dans la classe mère A.
    Dans B on la redéfinit ce qui fait qu'on a plus accès à la méthode affiche de base.
    Dans C on n'y touche pas, donc à l'appelle de la méthode affiche, il regarde dans C, rien, il remonte dans l'arbre d'héritage, une méthode affiche est défini dans B, il appelle cette version de affiche.
    Dans D, on veut garder le comportement du parent mais rajouter quelque chose, donc dans la redéfinition j'appelle la version du parent et je rajoute mes modifications.

  4. #4
    Modérateur

    Homme Profil pro Cyrille
    Network programmer
    Inscrit en
    juin 2010
    Messages
    1 897
    Détails du profil
    Informations personnelles :
    Nom : Homme Cyrille
    Âge : 26
    Localisation : France

    Informations professionnelles :
    Activité : Network programmer

    Informations forums :
    Inscription : juin 2010
    Messages : 1 897
    Points : 5 025
    Points
    5 025

    Par défaut

    Quand tu manipules un objet il faut distinguer 2 choses
    - son type statique
    - son type dynamique
    Ils peuvent être différents quand on manipule un pointeur ou référence, ils sont identiques sinon.
    Avec la virtualité et le typage dynamique on crée des interfaces et on fait ce qu'on apelle polymorphisme.

    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
    struct A { void Do() { std::cout<<"je suis A"<<std::endl; } virtual void Do2() { std::cout<<"je suis A::Do2"<<std::endl; } };
    struct B : A {};
    struct C : A { void Do() { std::cout<<"je suis C"<<std::endl; } virtual void Do2() { std::cout<<"je suis C::Do2"<<std::endl; } };
    struct D : C { void Do() { std::cout<<"je suis D et "<<C::Do(); } virtual void Do2() { std::cout<<"je suis D::Do2 et"<<C::Do2(); } };
     
    int main() {
    A a;
    B b;
    C c;
    D d;
    a.Do(); // je suis A
    a.Do2(); // je suis A::Do2
    b.Do(); // je suis A
    b.Do2(); // je suis A::Do2
    c.Do(); // je suis C
    c.Do2(); // je suis C::Do2
    d.Do(); // je suis D et je suis C
    d.Do2(); // je suis D::Do2 et je suis C::Do2
    A* ptrA = &a;
    ptrA->Do(); // je suis A
    ptrA->Do2(); // je suis A::Do2
    ptrA = &b;
    ptrA->Do(); // je suis A
    ptrA->Do2(); // je suis A::Do2
    ptrA = &c;
    ptrA->Do(); // je suis A
    ptrA->Do2(); // je suis C::Do2
    A& refA = d;
    refA.Do(); // je suis A
    refA.Do2(); // je suis D::Do2 et je suis C::Do2
    A aD = d;
    aD.Do(); // je suis A
    aD.Do2(); // je suis A::Do2
    }

Liens sociaux

Règles de messages

  • Vous ne pouvez pas créer de nouvelles discussions
  • Vous ne pouvez pas envoyer des réponses
  • Vous ne pouvez pas envoyer des pièces jointes
  • Vous ne pouvez pas modifier vos messages
  •