Bonjour, je possède une structure :

typedef struct Spec_Func{
  int nb_args ;
  //Quelque chose pour stocker les arguments
  void (*function)(void * arg, ...);
}Spec_Func ;

L'idée est d'appelé une fonction du genre :

void launch_function(Spec_Func spec_Func){
  spec_Func.function(NULL,NULL,NULL);//Mais avec un autre moyen que NULL,NULL,NULL
}

Cependant je prefererai avoir une syntaxe qui me permette d'utiliser les arguments.

Comment les sauvegarder avec va_list où autre moyen dans la structure afin d'avoir une syntaxe plus proche de celle ci pour launch_function :

void launch_function(Spec_Func spec_Func){
  spec_Func.function(spec_Func.arguments);
}

Merci de votre aide

PS: pour l'instant la fonction appelé est :

void empty_set(void * arg,...)
{
  printf("In Empty Func\n");
  (void)arg;
}

-
Edité par Golgoo 19 mai 2018 à 13:57:44

Bonjour,

va_list n'est pas un module de stockage. Il permet de parcourir des paramètres préalablement placés sur la pile. Mais il n'existe pas de moyens autre que la syntaxe du langage pour passer des paramètres sur la pile.
Je ne comprends pas bien la question et je crains que la demande ne soit pas possible, du moins avec le format souhaités.
Exemple de choses impossibles :

void fonction( void* , ... );
fonction( NULL, 1 , 2, 3.14 ); // La fonction n'a aucun moyen de connaître les types des paramètres ni même leur nombre.

// J'ai N paramètres, je veux les transmettre à un fonction à nombre variable de paramètres
// => il n'y pas de syntaxe possible si le nombre N n'est pas connu dès la compilation (il faudrait être en C++ pour cela.)

On peut par contre, mettre les paramètres dans un tableau (s'ils sont de même type) ou dans une structure pour les passer en paramètre.
On peut aussi relayer des paramètres reçus d'une fonction à une autre fonction qui recevra une va_list, mais n'ayant aucune possibilité d'en connaître le type et le nombre on ne peut pas accéder directement aux paramètres.

Merci de ta réponse Dalfab.

L'idée c'est d'avoir un module qui se chargerai de faire la boucle principale SDL, sans qu'on ait à l'implémenter mais juste à appeler la fonction, void do_sdl_loop();

L'idée était de stocker comme ceci :

enum {KEY_UP,KEY_DOWN,KEY_MAX} ;

#define MAX_FUNC 100

typedef struct Spec_Func{
  int nb_args ;
  //Quelque chose pour stocker les arguments
  void (*function)(void * arg, ...);
}Spec_Func ;

typedef struct Key_Func{
  int nb_fonction ;
  Spec_Func spec_func[MAX_FUNC];
}Key_Func ;

Key_Func key_funcs[KEY_MAX][SDL_NUM_SCANCODES];

Ainsi un exemple d'utilisation serait :

de créer une fonction void moove_srf( (void *) &sdl_Surface, (void *) &sdl_Rect ); qui se charge de récupérer les types au début.

et d'appeler une fonction void add_key_function(KEY_DOWN,SDLK_DOWN,moove_srf,(void*)&sdl_Surface,(void*)&sdl_Rect);

cette fonction doit être appeler automatiquement dans la boucle principale.

pour l'instant ça tourne mais je ne vois pas comment stocker les arguments,

Mais tu m'as fais penser à un truc : est ce que c'est donc possible de stocker les arguments ainsi que le nombre d'arg lors de la fonction add_key_function en les mettant dans un tableaux de void* ?

Puis ... dans la boucle appeler la fonction moove_srf que l'utilisateur aurai créé avec les arguments enregistré par la fonction add_key_function. La ça bloque encore :/

Merci encore de ta réponse ça m'a l'air un peu plus réalisable déjà :).

Je ne sais pas si tu voix à peu prêt ce que j'ai envie de coder, si tu veux je peux te montrer plus de code

EDIT :

Ok j'essaie de trouver une solution,

Ca pourrait être possible en utilisant une structure comme celle-ci :

enum Arg_Type{INT_V,INT_P,CHAR_V,CHAR_P};

union Arg_Union{
  int a;  int * a;
  char a; char *a;
}

typedef struct Arg_Struct{
  int nb_args;

  enum Arg_Type arg_Type[nb_args];
  union Arg_Union Arg_Union[nb_args];
}Arg_Struct ;

Cependant on devrait être capable de récupérer les arguments proprement en appelant une fonction du style :

void my_function(Arg_Struct arguments){
  recuperer_arguments(arguments);
  /*
  instructions
  */
  
}

Est ce que tu connaîtrais une solutions pour récupérer les arguments ?

void add_key_function(SDL_KEY,void (*f)(Arg_Struct),int nb_arg, enum arg_Type a_type[],union Arg_Union a_union[]);

 Une fonction de ce style devrait se charger de remplir les structures comme il faut, après ça sera plus simple d'appeler les fonctions.

Le problème reste à trouver : un moyen pour récupérer les arguments ( et optionnellement optimiser le prototype de add_key_function ).

Si quelqu'un à des idées, elles seraient les bienvenues

-
Edité par Golgoo 21 mai 2018 à 18:54:38