Discussion :

[Abdelkaoui]

Bonjour,

J'utilise une fonction dont le nombre des paramètres est dynamique comme suit :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
 
dh_char_t city[1024] ;
dh_char_t state[1024] ;
 
tpe_set_ptrs(((void **)tpe_ovars),2,city,state);

et voici la définition de cette fonction :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
 
extern void  EXPORT
tpe_set_ptrs (
void 	**	varptrlist, 
dh_u32_t nvars,
...    /* data ptrs */
#endif
);

Cela fonctionne sans problème.

Le problème manant est que désormais le nombre des variables à passer dans la fonction "tpe_set_ptrs" n'est plus connu et je pense que je dois les mettre dans un tableau de variables ou quelque chose comme ça.

Est ce qu'il y a donc une solution pour passer ces variables (qui doivent être trouvées dans un tableau ou une liste chainée) à la fonction "tpe_set_ptrs".

Merci bien pour votre aide.

[Thierry Chappuis]

Salut,

Si tu veux une fonction avec un nombre variable d'arguments, pourquoi tu n'utilises pas stdarg qui est la manière standard de faire.

Thierry

[Médinoc]

En effet, on peut s'en servir aussi bien statiquement que dynamiquement:

Code C :

Sélectionner tout - Visualiser dans une fenêtre à part

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
44
45
46
#include <stdarg.h>
#include <stdio.h>
 
/* La façon dont s'est fait normalement: 
   Une fonction avec une va_list en paramètre,
   Et un wrapper avec des points. */
static int vTest(int dummy, va_list args)
{
	char const *str;
	while((str = va_arg(args, char const*)) != NULL)
		puts(str);
 
	return dummy*2;
}
 
static int Test(int dummy, ...)
{
	int ret;
	va_list args;
 
	va_start(args, dummy);
	ret = vTest(dummy, args);
	va_end(args);
	return ret;
}
 
void TestVaList(void)
{
	/* La façon dont on utilise normalement la fonction: */
	Test(42, "Truc", "coucou", NULL);
 
	/* Test avec création dynamique d'une va_list. */
	{
		char const * param[8];
		va_list vl;
		param[0] = NULL; /*Cette partie ne sera pas passée en paramètre.*/
 
		param[1] = "Blabla";
		param[2] = "Test";
		param[3] = NULL;
 
		va_start(vl, param[0]);
		vTest(18, vl);
		va_end(vl);
	}
}

[Abdelkaoui]

Merci pour votre réponse,

En fait, la fonction "tpe_set_ptrs" est une fonction d'une bibliothèque que j'utilise.

Cette fonction accepte un nombre variable des paramètres et c'est cette fonction qui utilise strarg par récupérer les paramètres passés.

Dans mon programme, je passe des paramètres à cette fonction comme l'exemple suivant et ça tourne normalement :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
 
dh_char_t city[60] ;
dh_char_t state[40] ;
 
tpe_set_ptrs(((void **)tpe_ovars),2,city, state);

Ce que je veux faire est le suivant :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
 
dh_char_t vars[2][256];
 
tpe_set_ptrs(((void **)tpe_ovars),2,vars);

C'est à dire que les paramètres à passer à cette fonctions existent tous dans un tableau (ou une liste chainée dans un autre exemple).

Bien à vous

[Médinoc]

Est-tu absolument sûr qu'il n'existe pas de version "v" de cette fonction ?

S'il n'en existe pas, tu peux abandonner tout espoir de réussir à lui passer un nombre indéterminé de paramètres en C standard. Il faut forcément y mettre quelque part de l'assembleur.

Mais si tu es sous Windows, il existe un espoir de faire ça en utilisant très peu d'assembleur: http://www.developpez.net/forums/sho...23#post2647023

[Abdelkaoui]

Malheureusement, la version "v" n'existe pas. Autre chose, je ne peux pas utiliser l'assembleur car mon programme doit être portable.

Mais de toute façon, y a t il moyen pour convertir un tableau de variable en une format que va_list peut le comprendre et par lequel pourra extraire la liste des variables ?

Bien à vous.

[Médinoc]

S'il n'y a pas de version "v", il est physiquement impossible de faire ce que tu veux de manière portable. L'ensemble des solutions est l'ensemble vide.

Enfin, je dis ça en supposant un nombre illimité et élévé de paramètres.
S'il y a forcément, par exemple, de 1 à 10 paramètres, tu peux tricher...
Mais s'il peut y en avoir potentiellement des millions, c'est mort.

[Jean-Marc.Bourguet]

Malheureusement, la version "v" n'existe pas. Autre chose, je ne peux pas utiliser l'assembleur car mon programme doit être portable.

Les seuls moyens sont des variations sur:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
switch(n) {
   case 1: pe_set_ptrs(((void **)tpe_ovars),1,vars[0]); break;
   case 2: pe_set_ptrs(((void **)tpe_ovars),2,vars[0], vars[1]); break;
   case 3: pe_set_ptrs(((void **)tpe_ovars),3,vars[0], vars[1], vars[2]); break;
   default: assert(0); break;
}

[Abdelkaoui]

Exactement, c'est la seule solution que je trouve pour le moment.

Mais vous voyez ! c'est étonnant quand même de ne pas trouver une solution dans le Standard C qui doit répondre à ce besoin.

A mon avis c'est très demandé.

Bien à vous.

[Médinoc]

Voilà précisément ce que je voulais dire par "tricher".


...La solution dans le Standard C, c'est de faire une version "v". Si on n'en fait pas, ce sont les utilisateurs qui s'en mordent les doigts...

[Abdelkaoui]

Oui justement, là je suis bloqué !

Car en fait il s'agit d'une lib d'accès à une base de données et mon programme dépend des fonctions de cette lib.

Merci bien.