Discussion :

[Neckara]

Bonjour,

Quelques sujets parlant du design pattern visiteur et du double-dispatch on ravivé en moi une ancienne question qui sommeillait.

J'ai deux classes mères :
- Visitable dont chaque filles définie une méthode :

Code :

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

1
2
3
4
virtual void visiteMoi(Visiteur & v)
{
          v.visite(*this);
}

- Visiteur qui défini pour chaque type de Visitable une méthode :

Code :

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

1
2
3
4
5
6
7
8
9
virtual void visite(Visitable &)
{
           std::cerr << "visitable" << std::endl;
}
 
void visite(VisitableFille1 &)
{
            std::cerr << "visitableFille1" << std::endl;
}

C'est génial, j'ai juste à hériter de Visiteur et de redéfinir quelques méthodes pour visiter n'importe quel Visitable.

Tout content, je fais une petite bibliothèque, je la publie...
Et un beau jour, un utilisateur de ma bibliothèque peut me contacter et me dire :

Tu est bien gentil Neckara, mais moi je veux créer une nouvelle classe fille de Visitable et effectuer des traitements spécifiques avec les Visiteur que j'aurais créé

Or pour faire ceci, il n'a que deux solutions :
- réécrire la classe Visiteur pour inclure ses méthodes de traitements.
- créer sa propre visite spécialisé (avec VisiteurPerso et VisitablePerso qui sont plus ou moins une copie de Visiteur et de Visitable) qu'on utilisera après avoir effectué la première visite et s'être aperçut qu'on visite des classes créés par l'utilisateur. Pour cela on fait hériter chaque Visiteur créé de Visiteur et de de VisiteurPerso et chaque Visitable créé de VirtualVisitablePerso et de VisitablePerso en n'oubliant pas d'inclure un class VirtualVisitablePerso : public Visitable{ virtual void visiteMoi(Visiteur &)=0;} à la bibliothèque.

Je me demandais s'il n'existait justement pas d'autres solutions/astuces pour éviter ce problème.
Comme faire une sorte de "double double-dispatch" où il suffierait juste de créer sa classe et de définir uniquement les méthodes pour les Types où nous voulons un traitement particulier exemple :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
class Visiteur
{
            public : 
                        virtual void visite(Visitable &);
 
}
 
class VisiteurFils : public Visiteur
{
             public :
                         virtual void visite(Visitable &);
                         virtual void visite(VisitableFils &);
}

[koala01]

Salut

En fait, le patron visiteur n'est qu'une mise en oeuvre parmi d'autre du principe du double dispatch...

Tu peux donc envisager un nombre tout à fait illimité de solutions qui te seraient propres

Par exemple, pour rester dans le contexte d'un visiteur, tu peux parfaitement envisager le visiteur "asynchrone", qui va tenter de transtyper la classe de base "visiteur" dans un de ses types dérivés, sous une forme proche de

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
class Visiteur
{
    public:
        /* pour les types que l'on connait déjà */
        virtual void visit(Derivee1 /* const */ &);
        virtual void visit(Derivee2 /* const */ &);
        /* ...*/
};
class AutreVisiteur : public Visiteur
{
    public:
        /* cette fonction ci fait partie d'un ajout suite à évolution */
        virtual void visit(NouvelleDerivee /* const */ &);
};
class NouvelleDerivee : public Base
{
     public:
         virtual void accept( Visiteur & v)
         {
              AutreVisiteur * reel = dynamic_cast<AutreVisteur *> (&v);
              if(reel)
              {
                  reel->visit(*this);
              }
         } 
};

Mais tu peux aussi t'éloigner du concept visiteur et utiliser le double dispatch "pur et simple", sous une forme proche de

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
class Base
{
    public:
        virtual void foo() = 0;
}
class Derivee : public Base
{
    public:
        virtual void foo() { bar(*this);}
};
class AutreDerivee : public Base
{
    public:
        virtual void foo() {   doSomething(*this);}
};
class TroisiemeDerivee : public Base
{
    public:
        /* voir avec un objet connu */
        virtual void foo() 
        {  
            UnTypeQuelconque obj; 
            obj.doSomething(*this);
        }
};

Les limites du système étant celles de ta propre imagination

Ceci dit, le principe ouvert fermé devrait, effectivement, t'inciter à envisager une solution proche du visiteur asynchrone si tu viens à devoir rajouter un type au niveau des visitables, de manière à garder les visiteurs "de base" (ceux qui n'avaient pas prévus cette évolution) "aussi stables que possibles"

[Emmanuel Deloget]

Le visiteur acyclique est aussi une solution, proche de celle proposée par koala01. (Ne pas chercher à aller sur le site objectmentor.com - il est mort depuis déjà quelques mois - RC Martin est passé à autre chose )