Discussion :

[boboss123]

Bonjour,

Je fais un programme pour un µC et j'ai besoin d'utiliser la fonction sprintf dont le prototype est :

Code :

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

int sprintf (auto char *buf, auto const MEM_MODEL rom char *fmt, ...);

voici ce que j'aimerais faire :

Code :

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

1
2
3
4
5
6
7
8
static char myBuf[100];
 
void maFonction_printf(auto const MEM_MODEL rom char *fmt, ...){
 
	sprintf(myBuf, fmt, ???);
 
	// autres commandes ...
}

Que dois-je mettre à la place des "???" ?

Comment est gérée la pile avec ce genre de fonction (nombre de paramêtres variables) ? est-ce qu'il y a des contrôles a faire pour ne pas "exploser" la pile ?
=> que se passe t-il si je mets trop de paramêtres ? j'aurais un risque de bug ou ma chaine sera tronquée ?

merci d'avance

[huit_six]

Bonjour,
dans ton cas, moi j'utiliserai plutôt vsnprintf ou vsprintf si tu n'as pas accès aux fonctions "en n" avec uclib (et franchement, je n'en sais rien ).

Un exemple d'utilisation de l'ellipse pour un cas similaire :

Code :

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

1
2
3
4
5
6
7
8
9
int pd_printf_err(char *format, ...) {
	va_list ap;
	int ret = 0;
	va_start(ap, format);
 
	ret =  vfprintf(stderr, "%s\n", ap);
	va_end(ap);
	return ret;
}

Il suffit de remplacer vfprintf(...) par

Code :

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

vsnprintf(dest, nb_char_max, fmt, ap);

ou

Code :

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

vsprintf(dest, nb_char_max, fmt, ap);

si tu n'as pas accès à vsnprintf.

Concernant la pile, je ne sais pas comment c'est géré.

=> que se passe t-il si je mets trop de paramêtres ? j'aurais un risque de bug ou ma chaine sera tronquée ?

Je ne suis pas sûr de comprendre ta question. Si tu mets trop de paramètres par rapport au nombre attendu par le format, je pense que ce n'est pas grave, tu auras un warning, mais à mon avis, ça ne plantera pas. En revanche, si tu mets trop de paramètres par rapport à une hypothétique limite du nombre de paramètres pour une fonction à ellipse, je ne sais pas ce qu'il peut se passer.

[Melem]

Tutoriel : Fonctions à arguments en nombre variable
FAQ : Comment définir une fonction acceptant un nombre d'arguments variable, comme printf() ?

Comment est gérée la pile avec ce genre de fonction (nombre de paramètres variables) ? est-ce qu'il y a des contrôles a faire pour ne pas "exploser" la pile ?
=> que se passe t-il si je mets trop de paramètres ? j'aurais un risque de bug ou ma chaine sera tronquée ?

La pile est gérée exactement de la même façon qu'avec les autres fonctions. A chaque appel d'une telle fonction, le nombre et le type des arguments passés dans la partie "arguments variables" doivent obligatoirement être renseignés. Avec printf par exemple, c'est fait à l'aide des codes de conversion dans la chaîne format. Si tu passes un nombre ou des types d'arguments qui ne correspondent pas à ceux qu'attend la fonction au moment de l'appel, il se passe ce qu'il se passe lorsque tu fournis n'importe quoi à n'importe quelle fonction. Rien de mystérieux.

Si tu mets trop de paramètres par rapport au nombre attendu par le format, je pense que ce n'est pas grave, tu auras un warning, mais à mon avis, ça ne plantera pas.

Fournir n'importe quoi à une fonction est toujours grave. Pour le warning, le compilateur ne saura jamais quels sont les arguments attendus pour un appel donné, impossible donc qu'il puisse émettre un warning. Avec les fonctions de la bibliothèque standard par contre, il peut émettre ces warnings s'il analyse la chaîne format et vérifie si les arguments passés correspondent bien.

[huit_six]

Avec les fonctions de la bibliothèque standard par contre, il peut émettre ces warnings s'il analyse la chaîne format et vérifie si les arguments passés correspondent bien.

Oui ce n'était pas clair du tout, mais en effet, je parlais des fonctions de la bibliothèque standard.
Par contre, concernant son autre question, y a t'il une limite du nombre de paramètres qu'une fonction (avec ellipse ou non) peut recevoir ? S'il y en a une et qu'on l'atteint, il doit falloir commencer à se poser de sérieuses questions sur la conception du programme, mais ça a piqué ma curiosité

[Melem]

La limite est la même que pour toutes les fonctions c'est tout. Sous Windows par exemple, la taille par défaut de la pile pour chaque thread est de 1 Mo, ce qui signifie que la taille de toutes les variables locales (incluant paramètres des fonctions) réunies en vie dans un thread à chaque instant ne doit jamais dépasser 1 Mo (et déjà qu'il n'y a pas que des variables locales dans la pile ...).

D'habitude, lorsqu'une fonction commence à prendre un nombre relativement important de paramètres, il vaut mieux utiliser une méthode du genre :

Code :

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

int func(const PARAMETRES * parametres);

Là il n'y a qu'un seul paramètre passé : parametres (qui est un pointeur donc qui occupe 4 octets sur processeur 32 bits et 8 octets sur 64 bits).

[boboss123]

ok, merci beaucoup pour les informations

Est-ce que le compilateur est capable de déterminer s'il y a un risque de dépassement de la pile :
- si on utilise que des fonctions avec nombre de parametres fixe ?
- si on utilise des fonctions avec nombre de parametres variable ?
=> si oui, comment ?

[huit_six]

La limite est la même que pour toutes les fonctions c'est tout. Sous Windows par exemple, la taille par défaut de la pile pour chaque thread est de 1 Mo, ce qui signifie que la taille de toutes les variables locales (incluant paramètres des fonctions) réunies en vie dans un thread à chaque instant ne doit jamais dépasser 1 Mo (et déjà qu'il n'y a pas que des variables locales dans la pile ...).

Ok donc il y a une limite par thread. C'est bon à savoir, donc il vaut mieux ne pas craquer en déclarant un buffer automatique trop gros du genre :

Code :

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

char buffer[2 * 1024 * 1024];

devrait bloquer à l'exécution si je comprends bien...
Cette limite par thread, c'est uniquement windows ? Les unix-like fonctionnent de la même manière ?

@boboss123 : pour les fonctions à nombre variable d'arguments, comme le nombre d'arguments et la taille de la pile déjà utilisée peuvent varier pendant l'exécution, je ne pense pas que le compilo puisse détecter quoi que ce soit. Et réflexion faite, ça me parait également difficile pour les autres fonctions. Mais attendons l'avis d'experts...

[Melem]

Cette limite par thread, c'est uniquement windows ? Les unix-like fonctionnent de la même manière ?

Théoriquement rien n'oblige un système d'instaurer une telle limite (qui est toujours ajustable d'ailleurs, que ce soit à la compilation ou pendant l'exécution) mais pratiquement, il n'y en a pas beaucoup. En tout cas pas du côté de Windows/UNIX.

[huit_six]

Merci beaucoup !

[boboss123]

merki