Benchmark multiméthodes : {C++; RTTI} vs {Clojure}, {etc}.
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:
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
