paramètres Passing dynamiquement aux fonctions variadique

Question

Je me demandais s'il y avait un moyen de transmettre des paramètres dynamiquement aux fonctions variadique. à savoir si j'ai une fonction

int some_function (int a, int b, ...){/*blah*/} 

et j'accepte un tas de valeurs de l'utilisateur, je veux une certaine façon de passer ces valeurs dans la fonction:

some_function (a,b, val1,val2,...,valn) 

Je ne veux pas écrire différentes versions de toutes ces fonctions, mais je soupçonne qu'il n'y a pas d'autre option?

Answer 1

Il pourrait être intéressant d'essayer juste de passer un tableau, puis utilisez les macros vararg de toute façon. Selon l'alignement de la pile, il se peut que cela fonctionne (tm).

Ceci est probablement pas une solution optimale, je principalement posté parce que je trouvais l'idée intéressante. Après l'avoir essayé, cette approche a fonctionné sur mon linux x86, mais pas sur x86-64 - elle peut probablement être améliorée. Cette méthode dépendra de l'alignement de la pile, de l'alignement de la structure et probablement plus.

void varprint(int count, ...) 
{ 
    va_list ap; 
    int32_t i; 

    va_start(ap, count); 
    while(count--) { 
     i = va_arg(ap, int32_t); 
     printf("Argument: %d\n", i); 
    } 
    va_end(ap); 
} 

struct intstack 
{ 
    int32_t pos[99]; 
}; 

int main(int argc, char** argv) 
{ 
    struct intstack *args = malloc(sizeof(struct intstack)); 
    args->pos[0] = 1; 
    args->pos[1] = 2; 
    args->pos[2] = 3; 
    args->pos[3] = 4; 
    args->pos[4] = 5; 

    varprint(5, *args); 
    return 0; 
} 

Answer 2

fonctions VARIADIC utilisent une convention d'appel où l'appelant est responsable de popping les paramètres de la fonction de la pile, donc oui, il est possible de le faire dynamiquement. Il n'est pas standardisé en C et nécessiterait normalement un assemblage pour pousser manuellement les paramètres désirés, et invoquer correctement la fonction variadique. La convention d'appel cdecl exige que les arguments soient poussés dans le bon ordre, et après l'appel, les octets poussés en tant qu'arguments avant l'appel sont sautés. De cette façon, la fonction appelée peut recevoir un nombre arbitraire de paramètres, car l'appelant va gérer le retour du pointeur de la pile à son état de pré-appel. L'espace occupé par les arguments avant le ... est la limite inférieure sûre pour le nombre d'octets poussés. Des arguments variadiques supplémentaires sont interprétés lors de l'exécution.

FFCALL est une bibliothèque qui fournit des enveloppes pour passer les paramètres de façon dynamique à des fonctions variadique. Le groupe de fonctions qui vous intéresse est avcall. Voici un exemple d'appeler les fonctions que vous avez données ci-dessus:

#include <avcall.h> 

av_alist argList; 
int retVal; 
av_start_int(argList, some_function, retval); 
av_int(argList, a); 
av_int(argList, b); 
av_type(argList, val1); 
... 
av_type(argList, valn); 
av_call(argList); 

Vous trouverez peut-être aussi this link discuter générer des emballages autour des fonctions variadique en C, être d'intérêt pour justifier pourquoi ce ne fait pas partie de la norme C

Answer 3

Une approche standard consiste à faire en sorte que chaque fonction variée soit accompagnée d'une contrepartie va_list (comme dans printf et vprintf). La version variadique convertit simplement ... en va_list (en utilisant des macros de stdarg.h) et appelle sa sœur va_list-taking, qui fonctionne réellement.

Answer 4

Selon ce que vous êtes de passage autour, il pourrait être une union discriminée vous êtes après ici (comme laissé entrevoir dans les commentaires). Cela éviterait la nécessité de fonctions variadique ou des tableaux de void*, et répond à la question « comment peut-une_fonction savoir ce que vous avez réellement passé ce ».Vous pourriez avoir un code comme ceci:

enum thing_code { INTEGER, DOUBLE, LONG }; 

struct thing 
{ 
enum thing_code code; 
union 
{ 
    int a; 
    double b; 
    long c; 
}; 
}; 

void some_function(size_t n_things, struct thing *things) 
{ 
    /* ... for each thing ... */ 
    switch(things[i].code) 
    { 
     case INTEGER: 
     /* ... */ 
    } 
} 

Vous pouvez prendre un peu plus loin et d'éviter le commutateur en remplaçant le code avec un ou plusieurs pointeurs de fonctions qui font quelque chose d'utile à chaque thing. Par exemple, si ce que vous vouliez faire était de simplement imprimer chaque chose, vous pourriez avoir ceci:

struct thing 
{ 
void (*print)(struct thing*); 
union 
{ 
    ... 
}; 
} 

void some_function(size_t n_things, struct thing *things) 
{ 
    /* .. for each thing .. */ 
    things[i]->print(things[i]); 
    /* ... */ 
}