Discussion :

[n0-sheep]

Bonjour,

Certain langages modernes, tels Clojure (et Haskell?) (variante de Lisp pour la machine virtuelle Java), proposent une fonctionnalité très intéressante appelée mutiméthode.
C++ ne possède pas cette fonctionnalité, mais il est possible d'obtenir un résultat similaire en utilisant le RTTI.

Je voudrais réaliser un benchmark entre ces deux options :
1. Celle en c++ qui utilise le RTTI,
2. Celle dans les autres langages (qui sont interprétés), où la fonctionnalité est supportée de base.

Il n'est pas évident qu'une des deux options soit plus rapide que l'autre car le RTTI ralentit considérablement l'exécution d'un programme c++ tandis que les langages interprétés sont en moyenne plus lents que des programmes c++.

J'écris ce message pour demander de l'aide dans cette réalisation pour deux raisons :
1. Je voudrais que le compilateur optimise le code d'exemple, mais pas plus que ce qu'il ne le ferait pour du code de production, il faut donc que le code d'exemple soit suffisamment complexe, et je n'ai aucune idée du niveau de complexité voulue.
2. Je m'y connais mal dans les autres langages que c++, et j'aurai besoin d'aiguillage pour écrire un code réaliste en Clojure*. (J'ai conscience que ce second point ne soit pas vraiment dans le bon forum, puisqu'il s'agit de la rubrique c++).

Voici une rapide présentation de la façon utilisée en c++ pour obtenir des multiméthodes : - Pattern visitor couplé à un dynamic_cast.
Cette solution permet de rajouter des méthodes à une classe sans induire de rigidité sur la hiérarchie de cette classe.
Le cout est un appel à une méthode virtuelle + un dynamic_cast.

Code d'exemple :

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
 
class Base{
    virtual void accept(BaseVisitor* bv) = 0;
};
 
class Derived_A{
    void accept(BaseVisitor* bv){ (dynamic_cast<Derived_A_Visitor*>(bv)) -> visit(this); }
};
class Derived_B{
    void accept(BaseVisitor* bv){ (dynamic_cast<Derived_B_Visitor*>(bv)) -> visit(this); }
};
 
//=============
class BaseVisitor{
};
 
class Derived_A_Visitor : public BaseVisitor{
    void visit(Derived_A* d){ /* code de la multiméthode */ }
};
class Derived_B_Visitor : public BaseVisitor{
    void visit(Derived_B* d){ /* code de la multiméthode */ }
};

Merci d'avance pour vos conseils

[ternel]

Quel est ton besoin fonctionnel?

parce que souvent, les templates sont adaptées.

[KsassPeuk]

Lu'!

En rapport avec le multi-methods, tu peux regarder cette conf :

La proposition est justement d'avoir des alternatives au multi-méthodes soit par l'usage d'un pattern-matching implémenté dans le contexte de C++, soit par justement une intégration plus profonde du multi-méthods en tant qu'extension du langage.

[JolyLoic]

Je te conseille aussi la lacture de http://www.open-std.org/jtc1/sc22/wg...2007/n2216.pdf (cosigné par le même gars et par Bjarne Stroustrup).

[Luc Hermitte]

Sur le sujet des multi-méthods en C++:
- cette série de 2 articles très intéressante: http://www.codeproject.com/Articles/...splus11-Part-1 et http://www.codeproject.com/Articles/...s-for-Cplusplu
- et le repo qui va avec: https://github.com/jll63/yomm11

Et j'avais croisé une autre implémentation à base de visiteurs et de C++11 ici même si mes souvenirs sont justes, et sans RTTI.

[n0-sheep]

Bonjour à tous,
Merci pour vos réponses.

Les liens que vous m'avez fournis ci dessus rendent mon projet de benchmark inutile : C++ dispose déjà de solutions acceptables pour simuler les multiméthodes, et la situation devrait encore s'améliorer dans les prochaines versions de C++.

Je suis assez impressionné par la (supposée) vitesse de Mach7 qui se prétend être plus rapide que le pattern visitor !