C arguments par défaut

Question

Existe-t-il un moyen de spécifier des arguments par défaut à une fonction en C ?

Answer 1

Wow, tout le monde est si pessimiste par ici. La réponse est oui.

Ce n'est pas trivial : à la fin, nous aurons la fonction principale, une structure de support, une fonction d'encapsulation, et une macro autour de la fonction wrapper. Dans mon travail, j'ai un ensemble de macros pour automatiser tout cela. Une fois que vous aurez compris le processus, il vous sera facile de faire de même.

J'ai écrit ce sujet ailleurs, voici donc un lien externe détaillé pour compléter le résumé ici : http://modelingwithdata.org/arch/00000022.htm

Nous aimerions tourner

double f(int i, double x)

en une fonction qui prend les valeurs par défaut (i=8, x=3.14). Définissez une structure d'accompagnement :

typedef struct {
    int i;
    double x;
} f_args;

Renommez votre fonction f_base et définissez une fonction wrapper qui définit les valeurs par défaut et appelle la base :

double var_f(f_args in){
    int i_out = in.i ? in.i : 8;
    double x_out = in.x ? in.x : 3.14;
    return f_base(i_out, x_out);
}

Ajoutez maintenant une macro, en utilisant les macros variadiques du C. De cette façon, les utilisateurs n'ont pas besoin de savoir qu'ils qu'ils remplissent réellement un f_args structure et pensent qu'ils font comme d'habitude :

#define f(...) var_f((f_args){__VA_ARGS__});

OK, maintenant tout ce qui suit fonctionnerait :

f(3, 8);      //i=3, x=8
f(.i=1, 2.3); //i=1, x=2.3
f(2);         //i=2, x=3.14
f(.x=9.2);    //i=8, x=9.2

Vérifiez les règles sur la façon dont les initialisateurs composés définissent les valeurs par défaut pour connaître les règles exactes.

Une chose qui ne marchera pas : f(0) car nous ne pouvons pas faire la différence entre une valeur manquante et zéro. D'après mon expérience, c'est un problème auquel il faut faire attention, mais qui peut être résolu par l'utilisation de la commande le besoin s'en fait sentir - la moitié du temps, votre valeur par défaut est vraiment zéro.

Je me suis donné la peine d'écrire ceci parce que je pense que les arguments nommés et les valeurs par défaut rendent vraiment le codage en C plus facile et plus amusant. Et Le C est génial parce qu'il est si simple et qu'il a suffisamment d'éléments pour rendre tout cela possible.

Answer 2

Oui. :-) Mais pas de la manière à laquelle on pourrait s'attendre.

int f1(int arg1, double arg2, char* name, char *opt);

int f2(int arg1, double arg2, char* name)
{
  return f1(arg1, arg2, name, "Some option");
}

Malheureusement, le C ne permet pas de surcharger les méthodes et vous vous retrouveriez avec deux fonctions différentes. Pourtant, en appelant f2, vous appelleriez en fait f1 avec une valeur par défaut. Il s'agit d'une solution "Don't Repeat Yourself", qui vous permet d'éviter de copier/coller du code existant.

Answer 3

Pas vraiment. Le seul moyen serait de écrire une fonction varargs et remplir manuellement les valeurs par défaut pour les arguments que l'appelant ne passe pas.

Answer 4

Nous pouvons créer des fonctions qui utilisent des paramètres nommés (uniquement) pour les valeurs par défaut. Ceci est la suite de la réponse de bk.

#include <stdio.h>                                                               

struct range { int from; int to; int step; };
#define range(...) range((struct range){.from=1,.to=10,.step=1, __VA_ARGS__})   

/* use parentheses to avoid macro subst */             
void (range)(struct range r) {                                                     
    for (int i = r.from; i <= r.to; i += r.step)                                 
        printf("%d ", i);                                                        
    puts("");                                                                    
}                                                                                

int main() {                                                                     
    range();                                                                    
    range(.from=2, .to=4);                                                      
    range(.step=2);                                                             
}    

La norme C99 définit que les noms ultérieurs dans l'initialisation remplacent les éléments précédents. Nous pouvons également avoir des paramètres positionnels standard, il suffit de modifier la signature de la macro et de la fonction en conséquence. Les paramètres de valeur par défaut ne peuvent être utilisés que dans le style paramètre nommé.

Sortie du programme :

1 2 3 4 5 6 7 8 9 10 
2 3 4 
1 3 5 7 9

Answer 5

Non.

Même la toute dernière norme C99 ne le permet pas.