1. Accueil
  2. Tous les snippets
  3. Snippets C / C++ / C++.NET
  4. Fonctions à taille variable d'arguments

Fonctions à taille variable d'arguments

Soyez le premier à donner votre avis sur cette source.

Snippet vu 4 419 fois - Téléchargée 34 fois

Commenter

Contenu du snippet

Voici un programme en C,sauf pour les commentaires: '//' au lieu de '/* ... */'
car le C est assez embetant sur ce point, le C++ est pour ceci mieux.

Passons le fait que ce programme soit plus en C que en C++ ...

Voici le but de ce programme :
savoir utiliser des fonctions à taille variable d'arguments,
ceci est très rare mais parfois très utile ...
les fonctions <printf>,<fprintf>,<sprintf>,<vsprintf>, ... sont des fonctions
à taille variable d'arguments.

Attention : l'utilisation de fonctions à taille variable d'arguments
est dangereux car si la syntaxe est incorrecte,he bien le programmme continue.

Après tout ce blabla voici enfin comment illustrer le problème :
nous allons programmé une fontion <myPrint> qui prend des arguments
qui vont par couple, i.e. le premier argument est le type du second.
<myPrint> affichera ce second argument.
<myPrint> return TRUE,si le type de l'argument est correct,sinon FALSE.

Vous pourrez remarquer que la fonction <cout> en C++, fait le meme boulot,
meme en plus amélioré,mais je fais du C et non du C++ ...

Source / Exemple : 


// pour les <printf> ...
#include <stdio.h>
// pour les <va_arg> ...
#include <stdarg.h>

//  voici quelques utilitaires:
//  meme si ce n'est pas neccessaire,certains compilateurs (notamment les anciens)
//  ne connaissent pas le type <BOOL>
typedef int BOOL;
#define TRUE                            (1)
#define FALSE                           (0)

//  voici tout les types que peut gérer la fonction <myPrint> :
//  le type TYPE_CHAR n'affiche que le caractère et non sa valeur
//---------------------------------
#define TYPE_INT                        1
//---------------------------------
#define TYPE_LONG                       2
//---------------------------------
#define TYPE_DOUBLE                     3
//---------------------------------
#define TYPE_CHAR                       4
#define TYPE_STRING                     5
//---------------------------------

//  Voici comment prototyper la fonction <myPrint> :

//  Attention il faut que la fonction est au moins un argument fixe
//  sinon je ne sais pas faire
//  (je ne suis pas sur que l'on puisse le faire,mais bon...)
//  et puis je ne pense pas que cela arrive un jour.
//  Donc le premier argument est le premier nombre de type, ce qui est
//  équivalent au nombre de 'chose' que vous voulez afficher
//  car à chaque 'chose' on associe un type

BOOL myPrint(int,...);

// Voici LA fonction <myPrint> :
BOOL myPrint(int nbChose,...)
{
//  <listArg> est la list d'arguments variables du type <va_list>
//  défini dans <stdarg.h>
va_list listArg;

//  on initialise <listArg> grace à <va_start>
//  on est obligé de passer en argument le nom du dernier argument fixe
//  cela peut paraitre absurde mais il faut savoir que <va_start> est une macro ...
//  donc ici le nom du dernier argument fixe est 'nbChose'
va_start(listArg,nbChose);

while(nbChose >= 1)
  {
  int type;
  //  <va_arg> est une macro retourne l'argument variable courant
  //  dont le type est le second argument de <va_arg>
  //  ceci peut encore paraitre étonnant mais c'est une macro...
  type = va_arg(listArg,int);

  switch(type)
    {
    case TYPE_INT:
      {
      int a;
      a = va_arg(listArg,int);
      printf("%d",a);
      }
      break;
    case TYPE_LONG:
      {
      long a;
      a = va_arg(listArg,long);
      printf("%d",a);
      }
      break;
    case TYPE_DOUBLE:
      {
      double a;
      a = va_arg(listArg,double);
      printf("%f",a);
      }
      break;
    case TYPE_CHAR:
      {
      char a;
      a = va_arg(listArg,char);
      printf("%c",a);
      }
      break;
    case TYPE_STRING:
      {
      char *a;
      a = va_arg(listArg,char *);
      printf("%s",a);
      }
      break;
    default:
      {
      printf("Type inconnu ...\n");
      // meme si il y a un probleme on fait bien le travail
      va_end(listArg);
      return FALSE;
      }
    }

  //  retourner à la ligne pour séparer les 'choses'
  printf("\n");

  // on a traité deux arguments, donc un 'nbChose'
  nbChose --;
  }

// on fait bien le travail
va_end(listArg);

// ici tout va bien
return TRUE;
}

int main(int argc,char **argv)
{

//  ces deux lignes permettent les arguments <argc> et <argv>
//  soient non-utilisés et que le compilateur soit content, car
//  je ne sais pas quel est le niveau de 'warning' que vous avez :
//  le compilateur pourrait raler comme quoi 
//  ces deux variables ne sont pas référencées ...
(void)  argc;
(void)  argv;

// ici on utilise la fonction <myPrint> :
myPrint(2,TYPE_STRING,"voici le nombre cent : (int)",TYPE_INT,100);
myPrint(2,TYPE_STRING,"voici le nombre cent : (long)",TYPE_LONG ,100);
myPrint(2,TYPE_STRING,"voici le centieme caractere :",TYPE_CHAR,100);
myPrint(2,TYPE_STRING,"voici environ pi :",TYPE_DOUBLE,3.1415926435);

//  regarder ceci :
//  tout ce peut vous paraitre n'importe quoi.Certe.
//  Mais est-ce-que ça va marcher ?
//  OUI !!! car le nombre de 'chose' est 0
//  donc <myPrint> ne lira pas "tralala" ...
myPrint(0,"tralala",TYPE_CHAR,"coucou",1.23456789,TYPE_LONG * TYPE_DOUBLE);

//  en revanche :
//  ceci est dangereux (c'est pourquoi je le met en comentaire)
//  ---> myPrint(0,"tralala",TYPE_CHAR);
//  car il n'y a rien après <TYPE_CHAR>

getch();

//  retourner 0 car ici tout va bien
return 0;
}

Conclusion :


ps: Chaque bug trouvé est la bienvenu

A voir également

Ajouter un commentaire

Commentaires

Signaler
Messages postés
89
Date d'inscription
samedi 19 avril 2003
Statut
Membre
Dernière intervention
26 janvier 2008
On peut écrire int main(void) pour éviter les warnings.
Signaler
Messages postés
38
Date d'inscription
mercredi 28 août 2002
Statut
Membre
Dernière intervention
24 janvier 2010
Pourquoi passer par stdarg.h ??

je me souviens, l'année passée j'avais fais un menu avec nombre d'élément aléatoires.

Tiens, je te fais ça en speed, après tu modifie comme tu veux:

#include <stdio.h>

void foo(int nbelem, ...)
{
int i;
for(i = 1;i <= nbelem;i++)
{
printf("%d. %s\n", i, *(&nbelem+i));

}
}
int main(void)
{
foo(4, "foo", "bar", "mouhhaha", "powned!");
}
Signaler
Messages postés
114
Date d'inscription
lundi 17 février 2003
Statut
Membre
Dernière intervention
28 juin 2004
Merci pour se code sa va m'aidé.
tu a oublié d'inclure conio.h pour le getch();
S'inscrire maintenant

Vous n'êtes pas encore membre ?

inscrivez-vous, c'est gratuit et ça prend moins d'une minute !

Les membres obtiennent plus de réponses que les utilisateurs anonymes.

Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.

Le fait d'être membre vous permet d'avoir des options supplémentaires.

Du même auteur (glipper)