Passer une fonction en paramètre

Version imprimable

Bonjour tout le monde,

J'ai un souci super urgent, je suis débutant en C et je voudrais savoir comment passer une fonction en paramètre en C. Je m'explique : Voici mon code :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 int main(int argc, char *argv[]) { if (argc != 2) { printf("Passez les arguments à la fonction...\n"); return EXIT_SUCCESS; } char* cheminimage = argv[1]; //on affiche l'image pour être sur d'avoir la bonne image pgmimage* image = creationimage(chemin); if(image == NULL) { printf("Impossible de créer l'image\n"); } imagecopie(image, "test_save1.pgm"); luminière(image, 40, "test_save2.pgm"); return EXIT_SUCCESS; }
Je m'explique, voilà la fonction doit être appelé comme ceci :

Code:

./ main "cheminimage" "filtre(40)"

Voilà j'ai passé en paramètre à argv[1] le chemin de l'image comme ceci

Code:

char* cheminimage = argv[1];

et ça marche et je voudrais passer à argv[2] ma fonction

Code:

"luminière(image, 40, "test_save2.pgm)"

Pour qu'à ma compilation j'appelle mon main de cette façon, c'est super urgent Merci :

Code:

./main "image.pgm" "lumière(40)"

12/10/2012, 19h06
Neckara

Bonjour,

Je pense que tu t'y prend de la mauvaise manière.
Essaye de t'inspirer des autres commandes qui existent :

Code:

commande valeur -nomOption valeurOption

Ainsi il te suffit juste de lire argument par argument.
Si l'argument commence par un "-", tu va lire une option et en fonction de l'option, tu vas traiter un ou plusieurs autres arguments et les placer dans des variables.
Pour mettre des valeurs par défaut, il te suffit juste d'initialiser tes variables au début de ton programme.

Après pour convertir la chaîne de caractère, tu peut regarder du côté de sscanf ou de strtol/ll/d/q/etc...

À moins de détourner le problème, tu ne peux pas modifier le code machine de ton programme à l'exécution. La seule chose que tu peux faire est d'en modifier le flot d'exécution, en utilisant, par exemple, les branchements conditionnels. Typiquement, ici, tu peux comparer la fonction passée en ligne de commande avec celles définies dans ton programme. Ci-après une manière de procéder. On peut commencer par considérer une fonction analyse, qui, à partir de la chaîne de caractère constituant les arguments en ligne de commande, retourne une structure contenant les différents champs attendus. Ppour éviter de réinventer la roue, tu peux également utiliser des bibliothèques de sur-couche logicielle comme getopt, qui permettent de gérer spécifiquement les arguments en ligne de commande. Imaginons par exemple le programme HelloWorld, qui prend un identificateur de fonction en paramètre : pour hello, on exécute la fonction hello, et pour world, on exécute la fonction world.
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 /* GNU Coding Standards */ #include <stdio.h> #include <stdlib.h> #include <string.h> typedef void fun (void); static void world (void) { puts ("World"); } static void hello (void) { puts ("Hello"); } static fun * analyse (const char *argline) { fun *ret = NULL; if (strcmp (argline, "hello") == 0) { ret = hello; } else if (strcmp (argline, "world") == 0) { ret = world; } return ret; } static void usage (const char *program_name, int status) { if (status != EXIT_SUCCESS) { printf ("Usage: %s FUN\n", program_name); } exit (status); } int main (int argc, char **argv) { fun *exec_fun = NULL; if (argc == 2) { exec_fun = analyse (argv[1]); } else { usage (argv[0], EXIT_FAILURE); } if (exec_fun != NULL) { exec_fun (); } else { usage (argv[0], EXIT_FAILURE); } return 0; }
À ce propos, il y a un problème dans ton nommage des identificateurs ; luminière n'est en effet pas un identificateur correct en langage C.

bonjour,

Je rejoins l'idée des options dans la ligne de commande ensuite tu peux faire un tableau de structure avec des pointeur sur fonction

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
 
 
typedef struct s_fct
{
   char opt;
   fct   fonction;
} t_fct =
 
typedef void (*fct)(arg);
 
t_fct mesFct[] = {{'a', &fct1}, {'b', &fct2}, NULL};
 
int maint(int argc, int** argv)
{
      char* path;
      int count;
      int count2;
 
      if (argc > 2)
         return -1;
      path = argv[1];
 
     for (count = 2; argv[2][count] != '\0'; count++)
      {
       for (count2 = 0; mesFct[count2] != NULL && count2 > 0; count2++)
          if(mesFct[count2].opt == argv[2][count])
          {
              (*(mesFct[count2]).fct)(path);
              count2 = -1;
          }
      }
 
}

A revérifier mais dans l'idée c'est un truc dans le style

23/10/2012, 23h16
Pouet_forever

Le problème du tableau et de la fonction analyse de lucas, c'est que toutes les fonctions doivent avoir la même signature. C'est assez contraignant si on veut gérer un minimum d'options. :?
24/10/2012, 06h18
Neckara

Citation:

Envoyé par Pouet_forever

Le problème du tableau et de la fonction analyse de lucas, c'est que toutes les fonctions doivent avoir la même signature. C'est assez contraignant si on veut gérer un minimum d'options. :?

Si on ne gère que des options, il suffit juste de faire une structure "Options" contenant toutes les variables nécessaires (et pouvant même contenir d'autres structures).

Sinon utiliser un tableau est très lent dans ce cas là.
Il vaut mieux passer par un arbre équilibré trié sur le nom de l'option.

Ou, si c'est statique, un tableau trié et une recherche dichotomique. Voir fonction bsearch() dans la bibliothèque standard du C.

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
typedef struct s_options
{
	/*...*/
} t_options;
 
typedef void (*fct)(t_options const *arg);
 
typedef struct s_fct
{
	char const *nom;
	fct const fonction;
} t_fct;
 
/*Fonction de comparaison*/
int compare_cle_fct(const void *pcvCle, const void *pcvFct)
{
	char const *cle = pcvCle;
	t_cft const *fct = pcvFct;
	return strcmp(cle, fct->nom);
}
 
/*Fonction de recherche dans un tableau de fct*/
t_fct const *bsearch_fct_c(
 char const *nom,
 t_fct const *fonctions,
 size_t nbFonctions
)
{
	return bsearch(nom, fonctions, nbFonctions, sizeof *fonctions, compare_cle_fct);
}
 
 
/*
Variables globales et fonctions les utilisant
*/
/*Attention, ce tableau doit être trié*/
static t_fct const g_mesFct[] = {{"fct1", &fct1}, {"fct2", &fct2}};
static size_t const g_nbFonctions = sizeof g_mesFct / sizeof g_mesFct[0];
 
/*Fonction de recherche dans le tableau global de fct*/
t_fct const * GetFonction(char const *nom)
{
	return bsearch_fct_c(nom, g_mesFct, g_nbFonctions);
}

03/11/2012, 13h29
jouana

Et en ajoutant une structure d'options tu peux mettre un maximum d'option tout en standardisant ta prise de paramètre, voir plusieurs structures avec en prise de paramètre un void*.

C'est pas d'un propreté exemplaire mais c'est pas mal.

Ensuite ça dépend du type d'option
si ce n'est pas des valeurs mais un enchaînement d'options tu peux te rabattre sur des champs de bits.