va_arg en c

Les bibliothèques C fournissent un large éventail de fonctions pour couvrir les besoins d'un programmeur et offrir également la possibilité de créer nos propres fonctions personnelles pour répondre aux besoins spécifiques de chaque cas.

Parmi les types de fonctions fournis par cette langue figurent les fonctions «variadiques». Ces types de fonction ont la flexibilité de contenir un nombre dynamique ou variable d'arguments d'entrée.

Dans ce Indice de linux Article, le va_arg La macro, qui est un composant de base de ce type de fonction et est utilisée pour récupérer les données des arguments d'entrée, est expliqué en détail.

Nous verrons une explication détaillée de son fonctionnement et de sa syntaxe. Ensuite, nous mettrons ce que nous avons appris en pratique dans un exemple pratique où nous créerons une fonction variatique étape par étape avec des fragments de code et des images qui montrent comment le va_arg La macro fonctionne dans la langue C.

Syntaxe de macro VA_ARG

Type VA_ARG (VA_LIST AP, TYPE)

Définition d'une fonction variatique

Avant d'aller plus en détail sur la macro va_arg, Examinons rapidement ce qu'est une fonction variatique.

Ces fonctions n'ont pas de nombre fixe d'arguments d'entrée, mais le nombre de ces arguments est adapté à ce que le programmeur envoie à chaque appel.

Un exemple de ceci est la fonction variadique largement utilisée printf (), dont les arguments d'entrée peuvent être juste une chaîne, une chaîne et une variable, ou un pointeur, ou plusieurs d'entre eux.

Ensuite, nous verrons comment définir une fonction variatique:

Fonction de type (variable de type,…);

Comme nous le voyons dans la définition, lors de la création d'une fonction de ce type, nous devons spécifier dans sa déclaration au moins un argument de contribution déclaré et son type, suivi d'une ellipse séparée par des virgules représentant les arguments variables ou inconnus.

Les variables et les macros qui utilisent les fonctions variadiques, telles que va_arg, sont définis dans le «stdarg.en-tête h ”. Donc, pour les utiliser, nous devons les inclure dans notre «.Code C ”ou son en-tête comme suit:

#inclure

Ensuite, regardons en détail ce que sont les macros qui composent la fonction variatique.

Arguments d'entrée et macros d'une fonction variatique

Dans les fonctions variadiques, un certain nombre de macros et de types de variables sont utilisés pour traiter les arguments d'entrée que le programmeur envoie à chaque appel. Ces macros et leur utilisation dans la fonction sont présentées ci-dessous.

va_list ap

L'objet AP est de type VA_LIST et stocke des informations sur les arguments d'entrée. Ensuite, il indique la position actuelle dans l'ordre de récupération des données d'entrée de liste.

Une fois déclaré, l'objet VA_LIST doit être initialisé avec la macro VA_START.

void va_start (va_list ap, dernier);

La macro va_start est appelée d'abord lorsqu'une fonction variatique est appelée. Il initialise l'objet AP qui pointe vers le premier argument inconnu de la liste.

type va_arg (va_list ap, type);

Cette macro renvoie le prochain argument d'entrée indiqué par AP à partir de la liste d'arguments. Le type de données renvoyé est spécifié en type.

Dès que VA_ARG récupère les données, AP augmente sa valeur par la référence à l'argument d'entrée suivant.

Cette macro ne renvoie pas de valeur par défaut indiquant que la liste des arguments d'entrée a atteint sa fin. Ainsi, le programmeur doit s'assurer qu'une méthode sûre est générée qui indique s'il existe encore des arguments dans la liste qui peuvent être extraits ou non.

Une méthode sûre consiste à inclure, dans chaque appel à la fonction variatique, une valeur constante et unique qui peut être interprétée dans le corps de la fonction comme un indicateur de «plus de paramètres laissés» dans le dernier paramètre d'entrée.

void VA_END (VA_LIST AP);

Une fois que tous les arguments ont été récupérés, chaque cycle de VA_START doit être terminé avec VA_END avant que la fonction variadique ne revienne. Sinon, il existe des informations sur la pile avec les données de l'appel actuel, ce qui pourrait entraîner des erreurs dans l'appel suivant de la fonction

Nous avons déjà vu chacune des macros qui font partie de la récupération d'argument dans une fonction variatique. Maintenant, voyons un exemple de la façon dont l'utilisation du va_arg macro pour récupérer les données des arguments d'entrée est implémentée dans ce type de fonction.

Comment créer une fonction variatique étape par étape et récupérer ses arguments d'entrée avec la macro va_arg () dans la langue C

Dans cet exemple, nous expliquons étape par étape comment créer une fonction variatique et récupérer ses arguments d'entrée - en utilisant la macro va_arg.

Dans la première étape, nous créons la fonction variadique, que nous appellerons get_arguments ().

La sortie et l'argument d'entrée déclaré Arg_1 seront de type double. La déclaration ressemblera à ceci:

double get_arguments (double arg_1,…);

Après avoir déclaré la fonction avec ses types de sortie et d'entrée, nous continuons avec le développement du corps de fonction.

Dans l'étape suivante, nous créerons un tableau de 10 éléments de type double avec le nom get_arg. Dans ce tableau, nous stockons les données de l'argument d'entrée, que nous récupérerons avec la macro va_arg.

Nous allons également créer la variable «A», qui est de type int et servirons d'identifiant pour les éléments du tableau get_arg.

double get_arg [10];
int a = 1;

À l'étape suivante, nous créons un objet de type VA_LIST, que nous appellerons «AP».

Cet objet est initialisé avec la macro va_start et passe comme premier argument, le nom de l'objet créé précédemment 'ap'; et comme deuxième argument le nom de la dernière variable d'entrée connue, dans ce cas "Arg_1".

va_list ap;
va_start (ap, arg_1);

Il est important de noter que le premier argument, et dans ce cas le seul connu de la fonction, n'est pas inclus dans la liste «AP», donc sa récupération se fait de la même manière que pour une fonction non variadique.

Dans ce cas, nous le stockons dans l'élément numéro 1 du tableau get_arg.

get_arg [a] = r1;

Ensuite, créez une boucle de temps pour récupérer les arguments d'entrée avec la macro va_arg.

Dans cette boucle, répétez ceci jusqu'à ce que la macro va_arg obtient la valeur -1 ou «e», qui sera l'indicateur du «dernier argument».

Dans chaque cycle de la boucle, le message «Argument récupéré:» est imprimé par la fonction printf (), suivi de la valeur des données récupérées.

Ensuite, l'identifiant «A» est incrémenté de 1 et la macro va_arg est appelé, qui récupère le prochain argument d'entrée et le stocke dans l'élément de tableau get_arg référencé par «a».

while (get_arg [a] != e)

printf ("Recomedargument% d", a);
printf (":% f \ n", get_arg [a]);
a ++;
get_arg [a] = va_arg (ap, double);

Lorsque toutes les données ont été récupérées et que le programme a quitté la boucle, nous devons quitter l'objet de liste «AP» que nous avons créé au début de la fonction avec la macro va_end et passer le nom de cet objet comme argument d'entrée.

va_end (ap);

Ensuite, nous verrons le code complet de la fonction variatique que nous venons de créer, et le principal pour appeler la fonction et déclarer les variables de type double que nous enverrons en arguments d'entrée.

#inclure
#inclure
voidget_arguments (double r1,…);
double e = -1;
voidMain ()
double arg_1 = 10;
Doublearg_2 = 4700;
double arg_3 = 2200;
double arg_4 = 5800;
double arg_5 = 3300;
get_arguments (arg_1, arg_2, arg_3, arg_4, arg_5, e);

voidget_arguments (double r1,…)
int a = 1;
DOUBLEGET_ARG [10];
va_listap;
VA_START (AP, R1);
get_arg [a] = r1;
while (get_arg [a] != e)
printf ("Recomedargument% d", a);
printf (":% f \ n", get_arg [a]);
a ++;
get_arg [a] = va_arg (ap, double);

va_end (ap);

L'image ci-dessous montre la console de commande avec les arguments d'entrée récupérés. Dans ce cas, la fonction a été appelée avec deux arguments d'entrée.

Les données récupérées pour un appel avec cinq arguments d'entrée.

Problèmes et solutions dans la récupération des données d'entrée avec le va_arg Macro

Le principal problème que nous rencontrerons dans le développement d'une fonction variatique est que la macro va_arg n'a pas de méthode pour informer le programmeur de la fin de la liste des arguments d'entrée. Ainsi, une fois que toutes les données envoyées dans l'appel ont été récupérées, cette macro renverra des résultats erronés chaque fois qu'il est appelé indéfiniment

Cela signifie que non seulement vous obtiendrez des résultats incorrects, mais dans les cas où la récupération des données est bouclée, il y aura un débordement. Par conséquent, le programmeur doit proposer une méthode pour détecter la fin des arguments de la liste. L'une des méthodes peut être d'utiliser une constante comme dernier argument qui indique la fin de la liste.

Une autre méthode consiste à spécifier comme premier argument le nombre de paramètres à envoyer à chaque fois que la fonction variadique est appelée.

Conclusion

Dans ce LINUX HINT Article, nous vous avons donné une explication détaillée et complète du fonctionnement des fonctions variadiques et comment utiliser le va_arg macro dans la langue C.

Nous avons également expliqué en détail l'utilisation des autres macros qui font partie de la récupération des données dans ce type de fonction et vous ont montré pas à pas sur la façon de déclarer et de développer l'une d'entre elles qui sont une ressource très importante dans ce langage de programmation et d'autres. Vous pouvez trouver plus d'articles comme celui-ci dans le moteur de recherche d'indices Linux.