Comment appeler des fonctions par leurs pointeurs en passant plusieurs arguments en C?

Je dois créer une fonction “appelant de fonction”: elle reçoit un pointeur de fonction générique ( void * ) et un nombre variable d’arguments en tant qu’arguments. Elle doit appeler cette fonction en passant les arguments et renvoyer un pointeur générique à la valeur renvoyée. . Cependant, ce pointeur de fonction d’entrée peut pointer vers n’importe quel type de fonction (avec n’importe quel type de renvoi), même avec des fonctions avec un nombre constant d’arguments. Ce serait quelque chose comme:

 void * function_caller(void * function_pointer, ...) { void * returning_value; // Call the function and get the returning value return returning_value; // this returning value will be properly casted outside } 

De cette façon, le code suivant fonctionnerait:

 int function1(int a, char b) { // ... } void function2(float c) { // ... } float function3() { // ... } int main() { int v1; float v3; v1 = *(int *) function_caller((void *) &function1, 10, 'a'); // Which would be equivalent to v1 = function1(10, 'a'); function_caller((void *) &function2, 3.0); // Which would be equivalent to function2(3.0); v3 = *(float *) function_caller((void *) &function3); // Which would be equivalent to v3 = function3(); return 0; } 

Je sais que je vais devoir utiliser une liste va_list , mais je ne sais pas comment appeler la fonction par un pointeur transmettant les arguments.

Alors, les gars, une idée?

La mauvaise nouvelle est que cela n’est pas possible en C, même en C non transférable (GCC a des extensions qui sonnent comme si elles faisaient ce travail, mais elles ne fonctionnent pas dans le cas général). Il est nécessaire d’écrire des shims en assembleur.

La bonne nouvelle est que d’autres personnes ont déjà écrit les cales pour vous: jetez un coup d’œil à libffi . ( Manuel ici . N’utilisez pas l’API “fermeture” si vous pouvez éventuellement l’éviter.)