Retour d'une fonction imbriquée

Version imprimable

Bonjour à tous,

J'ai actuellement un problème.
J'aimerais créer une fonction (callback_func) qui en retourne une autre (callback) (selon les arguments de la première) pour la passer à une autre fonction (get) qui l'utilisera en tant que fonction de callback.

Je ne sais pas si c'est très parlant pour vous, alors que je vais tâchez de vous donner un exemple, que j'espère simple à comprendre.

J'utilise GCC (et donc son extension pour les nested functions)
J'ai omis les déclarations de prototypes
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 #include <stdlib.h> #include <stdbool.h> bool get_first_int(int * ptr, const int list[], const size_t size, bool (*func)(const int)) { bool found; unsigned int i; for(found = false, i = 0; !found && i < size; i++) { if(func(list[i])) { *ptr = list[i], found = true; } } return found; } bool is_odd(const int i) { return i & 1; } bool multiple_of_3(const int i) { return multiple_of(3)(i); } bool (*multiple_of(const int multiple))(const int) { bool func(const int i) { div_t d = div(i, multiple); return d.quot != 0 && d.rem == 0; } return func; }
Ici, la fonction callback_func est multiple_of, les fonctions callback sont is_odd ou encore multiple_of_3 et la fonction get est get_first_int.

Ainsi j'aimerais pouvoir écrire :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 #include <stdio.h> #include <stdlib.h> #include <stdbool.h> int main(void) { int res, list[7] = {0, -6, 2, 3, 6, 1, 5}; bool found; found = get_first_int(&res, list, sizeof(list) / sizeof(*list), multiple_of(3)); if(found) { printf("La Première Correspondance est '%i'\n", res); } else { puts("Aucune Correspondance Trouvée..."); } return EXIT_SUCCESS; }
C'est à dire fournir en tant que fonction de callback, à get_first_int, directement la fonction retournée par callback_func, et non une fonction globale (comme multiple_of_3).

Or, le problème, c'est que cela ne va pas marcher, étant donné que la fonction retournée par callback_func est locale et donc la zone mémoire est inaccessible dans ma fonction get.
J'aimerais donc savoir comment contourner le problème, de façon propre.

Merci d'avance à vous !

Cordialement,
Hiz0

Ici, je ne vois pas vraiment l'intérêt d'avoir des fonctions imbriquées étant donné qu'on peut tout simplement faire :
Code:

1 2 3 4 5 6 bool multiple_of(const int multiple, const int i) { div_t d = div(i, multiple); return d.quot != 0 && d.rem == 0; }
Mais d'habitude, quand je dois écrire une fonction f qui doit retourner une "sous fonction", j'isole f et ses fonctions internes dans un fichier à part et limite la visibilité de ces fonctions à ce fichier ce qui les rendent virtuellement locales à f.
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 static int f1(int a, int b); PFONCTION f(const int i) { PFONCTION func; switch(i) { case 1: func = f1; break; default: func = NULL; } return func; } int f1(int a, int b) { return a + b; }

13/07/2008, 12h45
Karashi
Citation:
Envoyé par Melem

Ici, je ne vois pas vraiment l'intérêt d'avoir des fonctions imbriquées étant donné qu'on peut tout simplement faire :

Code:

1 2 3 4 5 6 bool multiple_of(const int multiple, const int i) { div_t d = div(i, multiple); return d.quot != 0 && d.rem == 0; }
Si, puisque je dois passer ma fonction à celle-ci

Code:

bool get_first_int(int * ptr, const int list[], const size_t size, bool (*func)(const int))

Pas du tout.

Fichier : multiple.h :

Code:

1
2
3
typedef bool (*PFONCTION)(const int);
 
PFONCTION multiple_of_func(const int multiple);

Fichier : multiple.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
#include "multiple.h"
#include <stdlib.h>
 
static bool multiple_of_3(const int i);
static bool multiple_of(const int multiple, const int i);
 
PFONCTION multiple_of_func(const int multiple)
{
    PFONCTION func;
 
    switch(multiple)
    {
    case 3:
        func = multiple_of_3;
        break;
 
    default:
        func = NULL;
    }
 
    return func;
}
 
bool multiple_of_3(const int i)
{
    return multiple_of(3, i);
}
 
bool multiple_of(const int multiple, const int i)
{
    div_t d = div(i, multiple);
 
    return d.quot != 0 && d.rem == 0;
}

Inclure multiple.h pour utiliser multiple_of_func.

13/07/2008, 19h21
Karashi
Désolé, j'ai du mal me faire comprendre :oops:.

La fonction multiple_of_func est une fonction moule pas du tout une fonction de sélection de fonction existante.

La fonction multiple_of_3 est juste un exemple du type de fonction que devrait me sortir multiple_of_func.

Je voudrais pouvoir écrire :
Code:

1 2 3 4 PFONCTION callback = NULL; callback = multiple_of(multiple_variable);

OK. Et ceci :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
static int _multiple;
static bool multiple_of_multiple(const int i); /* Teste si i est multiple de _multiple */
 
PFONCTION multiple_of(const int multiple)
{
    _multiple = multiple;
 
    return multiple_of_multiple;
}
 
bool multiple_of_multiple(const int i)
{
    div_t d = div(i, _multiple);
 
    return d.quot != 0 && d.rem == 0;
}

Ca te convient ?

14/07/2008, 13h00
Karashi

Oui merci, la technique fonctionne.

M'enfin, on m'avait toujours dit d'éviter les globales (même static)

Enfin, tan pis s'il n'existe pas d'autres moyens de contourner le problème.

Un grand merci pour toutes tes réponses :)
14/07/2008, 13h41
Melem

Pas qu'il faut éviter les globales, il faut s'interdire de mettre en global une variable qu'on aurait pu mettre en local à une fonction. Il ne faut pas non plus avoir plusieurs variables globales, même si on ne peut pas faire autrement. Si cela devait venir, plutôt créer une structure globale (donc on n'a plus qu'une seule variable globale : la structure) contenant toutes les variables (globales) nécessaires.