Taille d'une va_list

Version imprimable

Bonjour à tous,

Je suppose que la question a déjà été posée des dizaines de fois, malheureusement, je n'ai pas trouvé de réponse avec la recherche...

La question est la suivante : est-il possible de connaître le nombre d'éléments que contient une va_list ?

Présentement, j'utilise un marqueur de fin :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
 
/**
 * Fonction permettant de creer un tableau dynamique
 * @param iDataType le type des donnees qui suivent
 * @param ... les données, pouvant etre des chaines, des booleens, des 
 * entiers, ou des GType. Il faut obligatoirement terminer par un
 * G_TYPE_INVALID
 * @return pointeur vers notre structure
 */
CidDataTable *
cid_create_datatable (GType iDataType, ...)
{
    CidDataTable *res = cid_datatable_new();
    GType iCurrType = iDataType;
    va_list args;
    va_start(args,iDataType);
    void *current;
    while ((current = va_arg(args,void *)) != G_TYPE_INVALID) {
        CidDataContent *tmp = NULL;
        if ((GType) current == G_TYPE_BOOLEAN || (GType) current == G_TYPE_INT || (GType) current == G_TYPE_STRING)
        {
            iCurrType = (GType) current;
            continue;
        }
        switch (iCurrType) 
        {
            case G_TYPE_BOOLEAN:
                tmp = cid_datacontent_new_boolean(current);
                break;
            case G_TYPE_STRING:
                tmp = cid_datacontent_new_string(current);
                break;
            case G_TYPE_INT:
                tmp = cid_datacontent_new_int(current);
                break;
            default:
                iCurrType = (GType) current;
        }
        res = cid_datatable_append(res,tmp);
    }
    va_end(args);
    return res;
}

Mais existe-t-il un moyen de savoir combien de paramètres optionnels ont été entrés ?

03/12/2009, 14h10
Franck.H

:salut:

Tu parcours la va_list et à chaque itération de la boucle tu incrémentes un compteur de 1.
03/12/2009, 14h11
Jenna

Citation:

Envoyé par BSans

La question est la suivante : est-il possible de connaître le nombre d'éléments que contient une va_list ?

Non, seul l'appelant connait le nombre de paramètres qu'il a mis sur la pile.
Il y aurait peut être une possibilité mais il faut faire de l'assembleur pour regarder et comparer les pointeurs de pile, de frame et autres pointeurs. Personnellement, je ne m'y risquerait pas.

Citation:

Envoyé par BSans

Présentement, j'utilise un marqueur de fin :

continue :D
03/12/2009, 14h39
BSans

Merci pour ces réponses rapides !

En conclusion, il n'y a aucun autre moyen de "protéger" la fonction que le marqueur de fin ?

Une autre technique serait d'utiliser un paramètre int nb_elem, mais ça revient au même niveau "sécurité" ; il faut faire confiance au développeur qui utilisera la fonction.
03/12/2009, 14h42
Franck.H

Citation:

Envoyé par BSans

En conclusion, il n'y a aucun autre moyen de "protéger" la fonction que le marqueur de fin ?

Une autre technique serait d'utiliser un paramètre int nb_elem, mais ça revient au même niveau "sécurité" ; il faut faire confiance au développeur qui utilisera la fonction.

Tout à fait ;) Le mieux reste encore de finir la liste avec une valeur comme NULL par exemple !
03/12/2009, 14h43
Jenna

Citation:

Envoyé par BSans

En conclusion, il n'y a aucun autre moyen de "protéger" la fonction que le marqueur de fin ?

Pas à ma connaissance

Citation:

Envoyé par BSans

Une autre technique serait d'utiliser un paramètre int nb_elem, mais ça revient au même niveau "sécurité" ;

Tout à fait

Citation:

Envoyé par BSans

il faut faire confiance au développeur qui utilisera la fonction.

Oui !!

Citation:

Envoyé par Franck.H

Tout à fait ;) Le mieux reste encore de finir la liste avec une valeur comme NULL par exemple !

Oui. J'utilise en fait la valeur G_TYPE_INVALID pour signaler la fin de ma liste.

Et donc, une dérivée de la question initiale.

Peut-on "concaténer" un argument manuellement ?

Dans l'idée, on obtiendrait quelque chose comme :
Code:

1 2 3 4 5 6 7 8 9 10 11 void ma_vraie_fonction (char *blah, va_list list); void ma_fonction (char *blah, ...) { va_list args; va_start (args, blah); /* ici on concatène args avec G_TYPE_INVALID */ ma_vraie_fonction (blah, args); va_end (args); }

03/12/2009, 15h05
Franck.H

J'ai déjà essayé par le passé pour un projet de faire des modifications dans une va_list mais cela n'est pas trop possible et si ca l'est, très risqué.
03/12/2009, 15h12
BSans

Ok, encore merci.
04/12/2009, 01h21
LittleWhite

Bonjour,

Je pense pouvoir aidé un peu sur cette question. Moi même j'ai eu des gros problèmes avec les va_list.
En fait, il existe une fonction 'snprintf()'

Voici le manpage que j'ai (en anglais pardon)

Citation:

Concerning the return value of snprintf(), SUSv2 and C99 contradict
each other: when snprintf() is called with size=0 then SUSv2 stipulates
an unspecified return value less than 1, while C99 allows str to be
NULL in this case, and gives the return value (as always) as the number
of characters that would have been written in case the output string
has been large enough

Qui dit, que dans une implémentation C99 (bon, c'est pas le C ultra strict), on peut passer un pointeur null, qui permettra d'avoir la taille de la chaine que l'on doit avoir en résultat. ( Je pense que cela répondra en partie à votre réponse, même si vous ne demander pas la même chose ).
Dans le cas, ou vous n'avez pas l'implementation comme dans la norme C99, vous pouvez trouvé le code source de celle ci sur internet et le mettre dans votre code. Comme ça, pas besoin de trop se poser de question ( et en même temps on apprend comme c'est géré :D )

En espérant que cela aide
04/12/2009, 10h09
Franck.H

Ca ne devrait même pas exister le C99 (sans vouloir lancer de débat) :aie:

Je ne sais pas si je m'y suis bien pris, mais mon implémentation ne fonctionne pas...

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
 
BSans $ cat main.c 
#include <stdlib.h>
#include <stdio.h>
 
int main (int argc, char **argv)
{
    int nb = snprintf(NULL,0,NULL,"toto","tata","titi","a",'b');
    fprintf(stdout,"params: %d\n",nb);
 
    return EXIT_SUCCESS;
}
BSans $ gcc -std=c99 -c main.c 
BSans $ gcc -std=c99 -o test main.o
BSans $ ./test 
params: -1

snprintf() ne retourne pas le nombre de paramètres, mais le nombre de caractères nécessaires: Tu dois donc spécifier un format pour que ça puisse être calculé.
Là, tu passes NULL à la place, donc snprintf() refuse.
Code:

1 2 3 4 5 6 7 8 9 10 #include <stdlib.h> #include <stdio.h> int main (int argc, char **argv) { int nb = snprintf(NULL, 0, "%s%s%s %s %c\n", "toto", "tata", "titi", "a", 'b'); fprintf(stdout,"taille: %d\n", nb); return EXIT_SUCCESS; }

04/12/2009, 12h10
BSans

Donc aucun intérêt pour le problème que j'exposais plus tôt.

Il est impossible de déterminer le format des arguments à l'avance, comme il est impossible de prévoir le nombre d'arguments optionnels que l'utilisateur entrera.
04/12/2009, 12h40
Franck.H

Citation:

Envoyé par BSans

Donc aucun intérêt pour le problème que j'exposais plus tôt.

Il est impossible de déterminer le format des arguments à l'avance, comme il est impossible de prévoir le nombre d'arguments optionnels que l'utilisateur entrera.

Exactement ;)