Salut à toutes et tous,
 
Je voulais savoir si pouvais faire une fonction C qui accepte des valeurs en entrée soit "normale", soit des pointeurs sans devoir écrire 2 fonctions. Du genre :
 
int Foo(char a, char b) ;
 
int Foo(char *a, char *b) ;
 
Mon idée est de faire une fonction Foo et une FooPtr, mais je me demandais si je pouvais regrouper les 2 en 1... sachant que les valeurs, qu'elles soient passer par pointeurs ou pas ont la même signification.
 
Merci d'avance.

en C, tu ne peux pas faire d'overload (utiliser le même nom de fonction pour des appels avec des arguments différents)
 
Dans ton cas, tu peux toujours faire une fonction inline avec un autre nom qui appellera l'autre fonction, comme ca, ton code reste factorisé.

En fait, c'est faisable en C11, en utilisant le mot-clé _Generic() (cf. http://en.wikipedia.org/wiki/C11_% [...] evision%29). Cela dit, je n'ai jamais fait joujou avec ça, mais ce mot-clé a été introduit pour exactement ce genre de raison. En gros: tu dois avoir 2 fonctions avec 2 noms différents + une macro qui permet de d'appeler l'une ou l'autre en fonction des types passés en paramètres.
 
Et si tu aimes le gore, ce genre de chose est aussi faisable avec le préprocesseur C (C99): https://web.archive.org/web/2013120 [...] e-tgmathh/
 
Edit: En C99, tu auras en fait besoin d'une extension de gcc : typeof().

 
Generic a l'air d'être plus comme un template de C++, et du coup, ca ne passerait pas si tu as un niveau d'indirection différent.

Hum, je ne suis pas forcément de l'avis de tous, il y a bien une façon de faire "détournée", a l'aide de vaargs.
 
http://www.cplusplus.com/reference/cstdarg/va_start/
 
Dans l'exemple donné dans le lien ci dessus, suivant n par exemple, il serait possible d'appliquer différent va arg en changeant cette ligne:
 

 
Avec le type attendu.
 
Ca n'est pas très beau (c'est même très laid puisque normalement on réserve va arg pour les arguments illimités), mais c'est pour autant possible de la sorte...

Ha, je n'ai que ça à foutre en moment. J'ai fait joujou avec gcc 4.9.2, et on peut faire pas mal de délire avec ce mot clé :
(on notera que les caractères en C, sont des "int" et non des "char" ). La flemme de voir si on peut varier le nombre d'argument en fonction du type.
 

#include <stdio.h>
 
int FooChr(char a, char b)
{
  fprintf(stderr, "(char) version\n" );
}
 
int FooPtr(char * a, char * b)
{
  fprintf(stderr, "(char *) version\n" );
}
 
int FooChrPtr(char a, char * b)
{
  fprintf(stderr, "(char, char *) version\n" );
}
 
#define Foo(a, b)     _Generic(a, int: _Generic(b, int: FooChr, char *: FooChrPtr), char *: FooPtr)(a, b)
 
int main(int nb, char * argv[])
{
  char * a = NULL;
  Foo('a', 'b'); // FooChr
  Foo(a, a);     // FooPtr
  Foo('a', a);   // FooChrPtr
  return 0;
}