C des arguments par défaut

Wow, tout le monde est un pessimiste autour d'ici. La réponse est oui.

Il n'est pas anodin: à la fin, nous aurons la fonction de base, un soutien struct, une fonction wrapper, et une macro
autour de la fonction wrapper. Dans mon travail, j'ai un ensemble de macros pour automatiser tout cela; une fois
vous de comprendre le flux, il sera facile pour vous de faire de même.

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

Nous aimerions tourner

double f(int i, double x)

dans une fonction qui prend les valeurs par défaut (i=8, x=3.14). Définir un compagnon struct:

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

Renommer votre fonction f_base, et de définir une fonction wrapper qui définit les valeurs par défaut et les appels
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);
}

Maintenant ajouter une macro à l'aide de C variadic macros. De cette façon les utilisateurs n'ont pas à savoir qu'ils sont
en fait le remplissage d'une f_args struct et pensent qu'ils font d'habitude:

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

OK, maintenant, tout de travail:

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érifier les règles sur la façon composé d'initialiseurs de définir les valeurs par défaut pour les règles exactes.

Une chose qui ne fonctionne pas: f(0), parce que nous ne pouvons pas distinguer entre, d'une valeur manquante et
zéro. Dans mon expérience, c'est quelque chose à regarder dehors pour, mais peuvent être pris en charge comme
le besoin s'en fait sentir---la moitié de la durée par défaut est vraiment zéro.

Je suis passé par la difficulté d'écrire ceci parce que je pense que les arguments nommés et les valeurs par défaut
font vraiment de codage en C plus facile et encore plus de plaisir. Et
C est génial d'être aussi simple et ayant encore assez pour rendre tout cela possible.

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

#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);                                                             
}    

Le standard C99 définit que plus tard les noms dans l'initialisation de remplacer les éléments précédents. Nous pouvons aussi avoir une certaine norme de paramètres positionnels ainsi, il suffit de modifier la macro et de la fonction de signature en conséquence. La valeur par défaut des paramètres ne peut être utilisé dans le paramètre nommé style.

Programme de la sortie:

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

Pas.

Pas même le tout dernier standard C99 prend en charge cette.

Probablement la meilleure façon de le faire (ce qui peut ou peut ne pas être possible dans votre cas, en fonction de votre situation) est de passer à C++ et de l'utiliser comme "une meilleure C'. Vous pouvez utiliser C++ sans utiliser les classes, les modèles, la surcharge d'opérateur ou d'autres fonctionnalités avancées.

Cela vous donnera une variante de C avec la surcharge de fonctions et des paramètres par défaut (et toutes les autres fonctionnalités que vous avez choisi d'utiliser). Vous avez juste à être un peu disciplinée si vous êtes vraiment sérieux au sujet en utilisant seulement un sous-ensemble restreint de C++.

Beaucoup de gens vont dire que c'est une très mauvaise idée d'utiliser le C++ de cette façon, et ils pourraient avoir un point. Mais c'est juste un avis; je pense que c'est valable pour utiliser les fonctionnalités de C++ que vous êtes à l'aise avec, sans avoir à acheter l'ensemble de la chose. Je pense qu'une partie importante de la raison pour le succès de C++, c'est qu'il a utilisé par beaucoup de programmeurs dans les premiers jours exactement de cette manière.

Encore une autre option utilise structs:

struct func_opts {
  int    arg1;
  char * arg2;
  int    arg3;
};

void func(int arg, struct func_opts *opts)
{
    int arg1 = 0, arg3 = 0;
    char *arg2 = "Default";
    if(opts)
      {
        if(opts->arg1)
            arg1 = opts->arg1;
        if(opts->arg2)
            arg2 = opts->arg2;
        if(opts->arg3)
            arg3 = opts->arg3;
      }
    //do stuff
}

//call with defaults
func(3, NULL);

//also call with defaults
struct func_opts opts = {0};
func(3, &opts);

//set some arguments
opts.arg3 = 3;
opts.arg2 = "Yes";
func(3, &opts);

Oui, avec des caractéristiques de C99 vous pouvez le faire. Cela fonctionne sans définir de nouvelles structures de données ou alors sans la fonction de décider au moment de l'exécution comment il a été appelé, et
sans aucun calcul de frais généraux.

Pour une explication détaillée, voir mon post à

http://gustedt.wordpress.com/2010/06/03/default-arguments-for-c99/

Jens

Généralement non, mais dans gcc, Vous pouvez faire le dernier paramètre de (funcA() en option avec une macro.

Dans funcB() j'utilise une valeur spéciale (-1) pour signaler que j'ai besoin de la valeur par défaut pour le " b " en paramètre.

#include <stdio.h> 

int funcA( int a, int b, ... ){ return a+b; }
#define funcA( a, ... ) funcA( a, ##__VA_ARGS__, 8 ) 


int funcB( int a, int b ){
  if( b == -1 ) b = 8;
  return a+b;
}

int main(void){
  printf("funcA(1,2): %i\n", funcA(1,2) );
  printf("funcA(1):   %i\n", funcA(1)   );

  printf("funcB(1, 2): %i\n", funcB(1, 2) );
  printf("funcB(1,-1): %i\n", funcB(1,-1) );
}

Un autre truc à l'aide de macros:

#include <stdio.h>
#define func(...) FUNC(__VA_ARGS__, 15, 0)
#define FUNC(a, b, ...) func(a, b)
int (func)(int a, int b)
{
return a + b;
}
int main(void)
{
printf("%d\n", func(1));
printf("%d\n", func(1, 2));
return 0;
}

Si un seul argument est passé, b reçoit la valeur par défaut (dans ce cas, 15)

OUI

Par le biais de macros

3 Paramètres:

#define my_func2(...) my_func3(__VA_ARGS__, 0.5)
#define my_func1(...) my_func2(__VA_ARGS__, 10)
#define VAR_FUNC(_1, _2, _3, NAME, ...) NAME
#define my_func(...) VAR_FUNC(__VA_ARGS__, my_func3, my_func2, my_func1)(__VA_ARGS__)
void my_func3(char a, int b, float c) //b=10, c=0.5
{
printf("a=%c; b=%d; c=%f\n", a, b, c);
}

Si vous voulez 4ème argument, puis un supplément de my_func3 doit être ajouté. Remarquer les changements dans VAR_FUNC, my_func2 et my_func

4 Paramètres:

#define my_func3(...) my_func4(__VA_ARGS__, "default") //<== New function added
#define my_func2(...) my_func3(__VA_ARGS__, (float)1/2)
#define my_func1(...) my_func2(__VA_ARGS__, 10)
#define VAR_FUNC(_1, _2, _3, _4, NAME, ...) NAME
#define my_func(...) VAR_FUNC(__VA_ARGS__, my_func4, my_func3, my_func2, my_func1)(__VA_ARGS__)
void my_func4(char a, int b, float c, const char* d) //b=10, c=0.5, d="default"
{
printf("a=%c; b=%d; c=%f; d=%s\n", a, b, c, d);
}

Seule exception que float variables ne peut être donné des valeurs par défaut (sauf si c'est le dernier argument que dans les 3 paramètres de cas), parce qu'ils ont besoin de la période de ('.'), ce qui n'est pas acceptée dans les arguments de la macro. Mais peut comprendre un travail autour comme on le voit dans my_func2 macro (de 4 paramètres cas)

Programme

int main(void)
{
my_func('a');
my_func('b', 20);
my_func('c', 200, 10.5);
my_func('d', 2000, 100.5, "hello");
return 0;
}

De sortie:

a=a; b=10; c=0.500000; d=default                                                                                                                                                  
a=b; b=20; c=0.500000; d=default                                                                                                                                                  
a=c; b=200; c=10.500000; d=default                                                                                                                                                
a=d; b=2000; c=100.500000; d=hello