Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

Langage C++ Discussion :

Polymorphisme et toString


Sujet :

Langage C++

  1. #1
    Membre du Club
    Polymorphisme et toString
    Bonjour,

    J'essaye de reproduire l'exemple suivant qui est en Java mais en c++ :

    Ce qui est affiché est bien "Base Derived" car il y a du polymorphisme avec la méthode toString.

    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
    public class Base{
      public String toString(){
        return "Base";
      }
    }
     
    class Derived extends Base{
      public String toString(){
        return super.toString() + " " + "Derived";
      }
    }
     
    public class Main{
      public static void main(String args[]){
        Base derived = new Derived();
     
        System.out.println(derived);
      }
    }


    Maintenant, en c++, les deux classes ont une fonction amie qui redéfinie l'opérateur << qui renvoie un stream :

    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
    #include <iostream>
     
    class Base {
    public:
      friend std::ostream &operator<<(std::ostream &stream, const Base *base);
    };
     
    class Derived : public Base {
    public:
      friend std::ostream &operator<<(std::ostream &stream, const Derived *derived);
    };
     
    std::ostream &operator<<(std::ostream &stream, const Base *base) {
      return stream << "Base";
    }
     
    std::ostream &operator<<(std::ostream &stream, const Derived *derived) {
      return stream << (Base *)derived << " " << "Derived";
    }
     
    int main(int argc, char **argv) {
      Base *derived = new Derived();
     
      std::cout << derived << "\n";
    }


    Cependant, ce code ne m'affiche que "Base".

    Quel est le problème ici?

    Merci d'avance

  2. #2
    Expert éminent
    C'est simple 1 function amie ne pas être virtuelle.

    Il faut avoir 1 fonction virtuelle (par exemple, virtual void display(std::ostream&) const) et appeler cette fonction dans la fonction amie.


    1 source wikibooks.org, More C++ Idioms/Virtual Friend Function

  3. #3
    Membre du Club
    Bonjour,

    Merci pour votre réponse, j'ai compris!

    Maintenant comment est-ce que je dois faire si je veux depuis la fonction display de Derived, appeler la fonction display de Base pour produire la sortie "Base Derived"?

    J'ai essayé de faire :

    Code :Sélectionner tout -Visualiser dans une fenêtre à part
    1
    2
    3
    4
    void Derived::display(std::ostream &stream) const {
      ((Card *)this)->display(stream);
      stream << " Derived";
    }


    mais le problème c'est que cela produit une boucle infinie (grâce au polymorphisme justement ). J'ai cru comprendre qu'il n'y avait pas d'équivalent de super en c++...

  4. #4
    Expert éminent
    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
    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
    #include <iostream>
    #include <string>
     
    #include <cstdlib>
     
     
    class Base {
    public:
     
        friend std::ostream& operator << (std::ostream&, const Base&);
     
    protected:
     
        virtual void print(std::ostream& os) const {
            os << "base";
        }
    };
     
     
    class Derived: public Base {
    protected:
     
        virtual void print(std::ostream& os) const {
            Base::print(os);
     
            os << " -> derived";
        }
    };
     
     
    std::ostream& operator << (std::ostream& os, const Base& b) {
        b.print(os);
     
        return os;
    }
     
     
    /*****************************************************************************/
    /***********************************  Main  **********************************/
    /*****************************************************************************/
     
    int main(int argc, char** argv)
    {
        Base* b = new Base;
        Base* d = new Derived;
     
        std::cout << (*b) << std::endl << (*d);
     
        delete b;
        delete d;
     
     
        return EXIT_SUCCESS;
    }


    Édit : Utiliser l'opérateur de résolution de portée ( :: ) avec le nom de la classe mère n'est utile qu'avec des fonctions virtuelles et statiques Avec des fonctions normales, je ne sais pas si cela fonctionne, mais je ne vois pas l’intérêt
    Et c'est aussi utile dans 1 contexte multi héritage (ah le fameux problème du diamant des recruteurs sans idées ), qui permet de désambiguïser en choisissant quelle méthode prendre, si plusieurs parents ont 1 méthode avec le même nom.

  5. #5
    Expert confirmé
    Bonjour,

    Pour appeler la méthode explicite de la classe de Base, il ne faut pas passer par un pointeur ou une référence car justement la résolution virtuelle se met en place. Il faut faire comme en Java, il faut "forcer" un appel explicite de la fonction de Base.
    C'est la ligne 24 de l'exemple de foetus.

  6. #6
    Membre du Club
    Super maintenant ça marche!

    Bonne journée

###raw>template_hook.ano_emploi###