Pointeur de fonction comme paramètre de modèle non-type

Question

Je suis actuellement en train de porter GTK + dans un langage dynamique, l'un des défis est de convertir les fonctions GTK + en liaisons de langage. Je tente d'utiliser des modèles C++ pour le simplifier.

Par exemple, pour convertir « gtk_widget_show_all » à la « show_all » de langage dynamique, je d'abord définir la fonction suivante générique:

template<class Type, class GtkType, void function (GtkType*)> 
static Handle<Value> SimpleMethod (const Arguments& args) { 
    GtkType *obj = blablabla...; 

    function (obj); 

    return Undefined(); 
} 

Ensuite, je peux lier le « gtk_widget_show_all » à « SHOW_ALL » très facilement:

NODE_SET_PROTOTYPE_METHOD (constructor_template, "show_all", (SimpleMethod<Widget, GtkWidget, gtk_widget_show_all>)); 

Mais lorsque la fonction GTK + devient plus complexe, il serait un enfer pour définir tous les SimpleMethod pour chaque type de fonction GTK +, comme ceci:

template<class Type, class GtkType, void function (GtkType*, const char *)> 
static Handle<Value> SimpleMethod (const Arguments& args) { 
    ... 
} 

template<class Type, class GtkType, void function (GtkType*, int)> 
static Handle<Value> SimpleMethod (const Arguments& args) { 
    ... 
} 

template<class Type, class GtkType, int function (GtkType*)> 
static Handle<Value> SimpleMethod (const Arguments& args) { 
    ... 
} 

template<class Type, class GtkType, void function (GtkType*, const char *, const char *)> 
static Handle<Value> SimpleMethod (const Arguments& args) { 
    ... 
} 

Cela deviendra plutôt dégoûtant. Y at-il un bon moyen de simplifier ces fonctions à une fonction?

Answer 1

Vous pouvez définir un certain nombre de surcharges, en fonction du nombre d'arguments, comme ceci:

template<class Type, class GtkType, class ReturnType, ReturnType function()> 
static Handle<Value> SimpleMethod (const Arguments& args) { 
    ... 
} 

template<class Type, class GtkType, class ReturnType, class Arg0, ReturnType function(Arg0)> 
static Handle<Value> SimpleMethod (const Arguments& args) { 
    ... 
} 

...and so on... 

Boost.Preprocessor vous aiderait à générer les surcharges. Les arguments du modèle variadique C++ 11 devraient rendre cela beaucoup plus facile.