Remplir un pointeur sur fonction correctement

Version imprimable

:salut: tout le monde,

Voilà je cherche comment remplir "proprement" un pointeur sur fonction.
J'ai actuellement ceci :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 void init_elevation(t_env *e) { e->elevation[0].ressources[0] = 1; e->elevation[0].ressources[1] = 1; e->elevation[0].ressources[2] = 0; e->elevation[0].ressources[3] = 0; e->elevation[0].ressources[4] = 0; e->elevation[0].ressources[5] = 0; e->elevation[0].ressources[6] = 0; e->elevation[1].ressources[0] = 2; e->elevation[1].ressources[1] = 1; e->elevation[1].ressources[2] = 1; e->elevation[1].ressources[3] = 1; e->elevation[1].ressources[4] = 0; e->elevation[1].ressources[5] = 0; e->elevation[1].ressources[6] = 0; .... }
Ce code fonctionne parfaitement mais c'est plutôt super moche.

Et en fait je cherchais plutôt à le remplir de cette manière :
Code:

1 2 e->elevation[0].ressources[] = {1, 1, 0, 0, 0, 0, 0}; ...
Le problème est que ceci est incorrect, le Make m'insulte.
"ressources" étant tout bonnement un short.

J'aurais pu faire deux boucles, mais chaque résultat est fixe et bien défini et n'a aucun rapport avec le précédent.

Quelqu'un saurait-il me dire comment faire cela s'il vous plait plus proprement ?

Merci par avance

19/06/2008, 07h16
Vincent Rogier

1- si les valeurs qu'il faut associer à tes tableaux ne sont pas fixes et ne correspondent à aucune logique intégrable dans une boucle, non y pas d'autres moyens

2 - et le rapport avec les "pointeurs sur fonction" ? Car j'en vois pas....
19/06/2008, 07h58
architecte
2 ==> e->elevation[0].ressources[0] c'est un pointeur sur fonction, ensuite c'est vrai que pas forcément un énorme rapport j'aurais pu juste mettre un

Code:

short *ressources

:D

Pourquoi peut-on remplir un int de cette manière du coup ?
Code:

1 2 3 4 5 int map[] = { 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, \ 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1 };
Bon ca veut rien dire comment je l'ai rempli mais ca fonctionne...
Donc voilà pourquoi je cherche un moyen de le remplir un peu comme cela.
Je suis étonné qu'il n'y est pas de moyen...

Une première solution est:

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
#include <stdio.h>
#include <string.h>
 
#define ARRAY_SIZE(a) ( sizeof (a) / sizeof *(a) )
 
typedef struct
{
    struct
    {
        int ressources[7];
    }
    elevation[2];
}
t_env;
 
void init_elevation(t_env *e)
{
    size_t i;
    int ressources[][7] = 
    {
        {1, 1, 0, 0, 0, 0, 0},
        {2, 1, 1, 1, 0, 0, 0}
    };
 
    for (i = 0; i < ARRAY_SIZE(e->elevation); i++)
    {
        memcpy(e->elevation[i].ressources, ressources[i], 
                sizeof ressources[i]);
    }
}
 
int main(void)
{
    t_env e;
    size_t i, j;
 
    init_elevation(&e);
 
    for (i = 0; i < ARRAY_SIZE(e.elevation); i++)
    {
        for (j = 0; j < ARRAY_SIZE(e.elevation[i].ressources); j++)
        {
            printf("%d ", e.elevation[i].ressources[j]);
        }
        printf("\n");
    }
 
    return 0;
}

ou encore:

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
#include <stdio.h>
#include <string.h>
 
#define ARRAY_SIZE(a) ( sizeof (a) / sizeof *(a) )
 
typedef struct
{
    struct
    {
        int ressources[7];
    }
    elevation[2];
}
t_env;
 
#define INIT_ENV_T          \
{                           \
    {                       \
        {{1,1,0,0,0,0,0}},  \
        {{2,1,1,1,0,0,0}}   \
    }                       \
} 
 
int main(void)
{
    t_env e = INIT_ENV_T;
    size_t i, j;
 
 
    for (i = 0; i < ARRAY_SIZE(e.elevation); i++)
    {
        for (j = 0; j < ARRAY_SIZE(e.elevation[i].ressources); j++)
        {
            printf("%d ", e.elevation[i].ressources[j]);
        }
        printf("\n");
    }
 
    return 0;
}

Thierry

19/06/2008, 08h52
Vincent Rogier

Citation:

Envoyé par architecte

2 ==> e->elevation[0].ressources[0] c'est un pointeur sur fonction, ensuite c'est vrai que pas forcément un énorme rapport j'aurais pu juste mettre un

Code:

short *ressources

:D

tu dis dans ton post précedent :

Citation:

Envoyé par architecte

"ressources" étant tout bonnement un short.

Donc :

1 - tu dis que ressource est un short (en fait un short *)
2 - tu n'indiques pas de prototype de fonction
3 - tu initialises à 0 (au lieu de NULL pour les fonctions, ok 0 = NULL, mais utiliser NULL pour les pointeurs est plus clair que 0 qui en C est réservé au types scalaires entiers)

Je ne vois toujours pas le rapport avec les pointeurs de fonctions...

Que veux tu dire par "pointeur sur fonction" ?
19/06/2008, 10h05
Thierry Chappuis

+1

Je ne vois pas de pointeurs de fonctions ici, mais un fil qui concerne l'initilisation d'une structure.

Thierry