Discussion :

[saad.hessane]

Bonjours tout le monde,
Je voudrais bien savoir un peu plus sur la fonction printf (et de toutes les fonctions formatées). Je crois que printf est la première fonction que j'ai utilisé en apprenant le langage C. Mais je ne sais toujours pas comment elle fait pour recevoir un nombre de paramètre au choix.
Pouvez vous m'expliquez comment?

Code :

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

1
2
printf("coucou"); //Un seul paramètre
printf("Mon pseudo est %s et j'ai %d ans", "ilys05", 19); //Trois paramètres

[Lucien63]

Va voir ici :

http://man.developpez.com/man3/va_end.3.php

[saad.hessane]

J'ai un peu du mal à comprendre.
il faut que j'inclue #include <stdarg.h>, puis je déclare ma fonction. Est ce que je doit nécessairement mettre les trois points?
Ensuite j'ai rien compris aux macros va_start et compagnie.
Merci de m'aider.

[ram-0000]

les 3 point ma_fonction(...) (appelé ellipsis me semble t'il en anglais) servent à indiquer que le nombre de paramètre est variables. Entre 0 et n paramètres peuvent remplacer les 3 ...
Ainsi void ma_fonction(int nb, ...) demande au moins 1 paramètre
Ainsi void ma_fonction(int nb, const char *str, ...) demande au moins 2 paramètres

Le problème de ce type de fonction est qu'elle doit savoir exactement le type des paramètres reçus.

Ainsi pour le printf et autres dérivés, si il y a %s dans la chaine de format, la fonction sait que le paramètre est une chaine de caractère, si c'est %d, c'est un entier, etc

Ensuite, les macros va_start, va_arg et va_end servent dans la fonction appelée à récupérer des paramètres en donnant le type que l'on attend

Ces fonctions ont toujours un indicateur concernant les paramètres qui suivent. Cela peut être un format de chaine comme pour printf(), un 1er paramètre qui indiquent le nombre de paramètres qui suivent ou tout autre convention que tu veux à partir du moment où tu retrouves tes petits.

Enfin, il faut savoir que ces fonctions ne sont pas sûre dans le sens où il faut que l'appelant fasse ce que l'appelé attend. Il n'y a aucun controle des paramètres fait par le compilateur. Par exemple printf("%s", 42) se compile mais génère à coup sûr un crash.

[Lucien63]

Voici un exemple simple d'une fonction Sum qui peut prendre un nb de parametre au choix.
Elle fait la somme des parametre à partir du deuxieme.
Le premier paramètre est le nb d'élement a additionner.(il est donc egal au nb de parametres - 1)

Code :

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
#include <stdio.h>
 
#include <stdarg.h>
 
int Sum( int elem, ... )
{
   int i;
   int sum = 0;
 
   va_list pArg;
   va_start( pArg, elem );
 
   if(elem==NULL) return 0;
 
   for(i=0; i<elem; i++)
           sum +=  va_arg(pArg, int);
 
   va_end(pArg);
   return sum;
}
 
//---------------------------------------------------------------------------
int main(void)
{
    int Somme = Sum( 3, 30, 40, 50 );
    printf( "La somme est : %d\n", Somme );
 
    Somme = Sum( 5, 30, 40, 50, 20, 40 );
    printf( "La somme est : %d\n", Somme );
 
 
    return 0;
}

[nicolas.sitbon]

Voici un exemple simple d'une fonction Sum qui peut prendre un nb de parametre au choix.
Elle fait la somme des parametre à partir du deuxieme.
Le premier paramètre est le nb d'élement a additionner.(il est donc egal au nb de parametres - 1)

Code :

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
#include <stdio.h>
 
#include <stdarg.h>
 
int Sum( int elem, ... )
{
   int i;
   int sum = 0;
 
   va_list pArg;
   va_start( pArg, elem );
 
   if(elem==NULL) return 0;
 
   for(i=0; i<elem; i++)
           sum +=  va_arg(pArg, int);
 
   va_end(pArg);
   return sum;
}
 
//---------------------------------------------------------------------------
int main(void)
{
    int Somme = Sum( 3, 30, 40, 50 );
    printf( "La somme est : %d\n", Somme );
 
    Somme = Sum( 5, 30, 40, 50, 20, 40 );
    printf( "La somme est : %d\n", Somme );
 
 
    return 0;
}

Code :

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
#include <stdio.h> 
#include <stdarg.h>
#include <stddef.h>
 
static int sum_int (size_t nb_elem, ...)
{
   int sum = 0;
 
   if (nb_elem != 0)
   {
      size_t i;
      va_list pArg;
 
      va_start ( pArg, nb_elem);
 
      for (i = 0; i < nb_elem; i++)
      {
         sum +=  va_arg(pArg, int);
      }
 
      va_end (pArg);
   }
 
   return sum;
}
 
int main (void)
{
    int somme = sum_int (3, 30, 40, 50);
    printf ("La somme est : %d\n", somme);
 
    somme = sum_int (5, 30, 40, 50, 20, 40);
    printf ("La somme est : %d\n", somme);
 
    return 0;
}

[Lucien63]

Oui, c'est mieux !

Une question : Pourquoi static ?

[nicolas.sitbon]

Dans la mesure où pour le moment la fonction ne sert que dans ce fichier source, je la mets static, laissant plus de choix au compilateur pour l'optimisation (inliner la fonction par exemple)., et puis ça reste une bonne pratique de limiter les portées.

[Médinoc]

Il faut savoir aussi, pour les fonctions variadic, le mieux est généralement de les décomposer en deux: Une fonction qui prend une va_list en paramètre, et une autre qui prend "..."

Code :

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
#include <stdio.h> 
#include <stdarg.h>
#include <stddef.h>
 
static int vsum_int(size_t nb_elem, va_list pArg)
{
   int sum = 0;
 
   if (nb_elem != 0)
   {
      size_t i;
 
      for (i = 0; i < nb_elem; i++)
      {
         sum +=  va_arg(pArg, int);
      }
 
   }
 
   return sum;
}
 
static int sum_int (size_t nb_elem, ...)
{
   int sum = 0;
   va_list pArg;
   va_start ( pArg, nb_elem);
 
   sum = vsum_int(nb_elem, pArg); 
 
   va_end (pArg);
 
   return sum;
}
 
int main (void)
{
    int somme = sum_int (3, 30, 40, 50);
    printf ("La somme est : %d\n", somme);
 
    somme = sum_int (5, 30, 40, 50, 20, 40);
    printf ("La somme est : %d\n", somme);
 
    return 0;
}

[Emmanuel Delahaye]

Je voudrais bien savoir un peu plus sur la fonction printf (et de toutes les fonctions formatées). Je crois que printf est la première fonction que j'ai utilisé en apprenant le langage C. Mais je ne sais toujours pas comment elle fait pour recevoir un nombre de paramètre au choix.
Pouvez vous m'expliquez comment?

Code :

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

1
2
printf("coucou"); //Un seul paramètre
printf("Mon pseudo est %s et j'ai %d ans", "ilys05", 19); //Trois paramètres

Elle utilise une interface composé d'un paramètre et d'une 'ellipse' : ...

Code :

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

int printf (char const *format, ...);

L'ellipse indique le nombre de paramètres est variable et qu'il dépend des indications données le premier paramètre, à savoir les champs de formatages qui commencent par '%'.

[orfix]

Salut,

les 3 point ma_fonction(...) (appelé ellipsis me semble t'il en anglais) servent à indiquer que le nombre de paramètre est variables. Entre 0 et n paramètres peuvent remplacer les 3 ...
<...>

Euhhh on est d'accord que ma_fonction(...) est fausse est que le nombre de paramètres variables varie de 1 à n ?

Code :

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

<type> ma_fonction(<type> ma_variable, ...);

@++

[ram-0000]

Salut,


Euhhh on est d'accord que ma_fonction(...) est fausse est que le nombre de paramètres variables varie de 1 à n ?

Code :

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

<type> ma_fonction(<type> ma_variable, ...);

@++

Non non, je persiste, les 3 points "..." sont pour 0 à n paramètres.

[Médinoc]

Mais comment peut-on avoir accès à ces paramètres de manière standard, dans ce cas?

[Emmanuel Delahaye]

Mais comment peut-on avoir accès à ces paramètres de manière standard, dans ce cas?

Je crois qu'il n'a pas dit qu'il y avait 0 à n paramètres en tout, mais que l'ellipse remplaçait 0 à n paramètres, ce qui est vrai. En tout il y a au moins 1 à n+1 paramètres, car il faut obligatoirement un paramètre avant l'ellipse en C standard.

[orfix]

Alors j'avais mal compris désolé !
C'est cette écriture qui m'a induite en erreur :

Code :

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

1
2
 
ma_fonction(...)

[ram-0000]

il faut obligatoirement un paramètre avant l'ellipse en C standard.

Syntaxiquement non, il peut y avoir 0 paramètre avant l'ellipse.

Maintenant, fonctionnellement, si il y a 0 paramètre avant l'ellipse, je ne sait pas les traiter

Code compilé sans erreur ni warning :

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

1
2
3
4
5
6
7
8
9
10
11
12
 
void _test(...)
{
   // je ne sais pas quoi faire de mes paramètres variables
}
 
int main(int /*argc*/, char * /*argv[]*/)
{
   _test();
   _test(12, 14);
   return 0;
}

[Lucien63]

Déjà, comment y accéder ?
Que mets-tu dans va_start ?

Code :

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

 va_start( pArg, ??? );

[ciol2.6.12]

Comment le compilateur détecte une erreur de format au fait, par exemple quand on met %d et pas un entier, ou qu'on ne met pas assez d'arguments ?
C'est codé en dur dans le compilateur ?

[Emmanuel Delahaye]

Comment le compilateur détecte une erreur de format au fait, par exemple quand on met %d et pas un entier, ou qu'on ne met pas assez d'arguments ?
C'est codé en dur dans le compilateur ?

C'est analysé intelligemment par certains compilateurs comme gcc.

[ram-0000]

Déjà, comment y accéder ?
Que mets-tu dans va_start ?

Rien, je ne sais pas "accrocher" mon va_start avec un paramètre de la fonction. C'est ce que je met dans le corps de ma fonction "je ne sais pas quoi faire de mes paramètres variables".

Mon propos étais juste de dire que c'était possible, je n'ai pas dis que c'était utile