Structure et pointeur.

Version imprimable

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
// Definition structure.
typedef struct Point Point;
typedef struct Mouv Mouv;
typedef struct Unit Unit;
// Strucutre
struct Point
{
	short int unsigned x;
	short int unsigned y;
};
struct Mouv
{
	char vue;// Orientation
	Point deb;// Depart
	Point go;// Destination
	char pas;// Etape du mouvement accomplit
};
 
struct Unit
{
	short int unsigned user_id;
	short int unsigned type;
	Mouv mouv;
	short int unsigned vie_act;
	char action;
};
// Initialisation :
void init_unit(short int unsigned user_id, short int unsigned type,
		short int unsigned posi_x, short int unsigned posi_y,
		Unit* unit_return){
 
	unit_return	=malloc(	sizeof(short int unsigned)*3
+sizeof(char)*3
+sizeof(short int unsigned)*4
	);
 
	*unit_return.user_id	=user_id;// ERR Ici
/*
	unit_return->type	=type;
	unit_return->vue	=VUE_NULL;
	unit_return->deb.x	=posi_x;
	unit_return->deb.y	=posi_y;
	unit_return->go.x	=posi_x;
	unit_return->go.y	=posi_y;
	unit_return->pas	=0;
	unit_return->vie_act	=1;// Vie Max a faire
	unit_return->action	=ACT_WAIT;
*/
printf("%p --> %s\n",unit_return,unit_return);
return;
}

Code:

1
2
3
4
// Erreur -->
didungar@DidUngar:/media/sda3/Prog/Garganthum$ gcc*
unit.c: Dans la fonction «init_unit» :
unit.c:14: erreur: request for member «user_id» in something not a structure or union

// Mon but :
Je cherche a crée de la place disponible dans tout mon programme ( d'ou mem alloc )
Que je pourré acceder simplement grace a une structure.
( pas si simple que ca ... )
j'ai donc un pointeur vers ma structure,
et je désire l'utiliser pour aller sur mon mem alloc.

Voila si quelqu'un pourrez m'aider ...
Merci d'avance

16/03/2007, 08h31
Franck.H
Code:

*unit_return.user_id = user_id;

Non, plutôt:

Code:

unit_return->user_id = user_id;

De plus:
Code:

1 2 3 4 5 6 unit_return = malloc ( sizeof (short int unsigned) *3 + sizeof (char) * 3 + sizeof (short int unsigned) * 4 );
En réalité, un char vaut toujours 1 donc un sizeof n'a que peut d'importance et même de but dans ce cas ;)

Pour finir:

Code:

short int unsigned

Ceci:

Code:

unsigned short

devrait suffir !
16/03/2007, 08h35
Franck.H
Juste un conseil en passant sur une partie que je viens de voir:
Code:

1 2 3 4 void init_unit(short int unsigned user_id, short int unsigned type, short int unsigned posi_x, short int unsigned posi_y, Unit* unit_return)
En fait, je fairais plutôt retourner un pointeur de ce type par la fonction ce qui nous donne alors:
Code:

1 2 Unit * init_unit(short int unsigned user_id, short int unsigned type, short int unsigned posi_x, short int unsigned posi_y)
L'avantage est que c'est que ca te permet également de faire retourner un code d'erreur donc ici NULL si l'allocation devais échouer (enfin il faut tout de même gérer cette éventualité mais c'est simple) ;)
16/03/2007, 08h36
mchk0123
Code:

1 2 3 4 5 unit_return = malloc ( sizeof (short int unsigned) *3 + sizeof (char) * 3 + sizeof (short int unsigned) * 4 );
Oula la pourquoi faire simple ?

Essaye plutôt :

Code:

unit_return = malloc (sizeof(struct Unit));

Car sinon (en plus) tu risques d'avoir de grosses suprises en cas de mauvais alignement mémoire.
16/03/2007, 08h38
Franck.H
Citation:
Envoyé par mchk0123

Code:

1 2 3 4 5 unit_return = malloc ( sizeof (short int unsigned) *3 + sizeof (char) * 3 + sizeof (short int unsigned) * 4 );

Oula la pourquoi faire simple ?

Essaye plutôt :

Code:

unit_return = malloc (sizeof(struct Unit));

Car sinon (en plus) tu risques d'avoir de grosses suprises en cas de mauvais alignement mémoire.
Je dirais même mieux:

Code:

unit_return = malloc (sizeof(* unit_return));

;)
16/03/2007, 10h18
mchk0123

Citation:

Envoyé par Franck.H

Je dirais même mieux:

Code:

unit_return = malloc (sizeof(* unit_return));

;)

Me suis toujours demandé s'il y avait une différence en termes de code compilé, entre les 2 versions ? Je suppose que non ...

Il est essentiel de comprendre qu'en C, le passage des arguments à une fonction se fait par valeur. Ainsi, l'interface suivante:

Code:

1
2
3
void init_unit(short int unsigned user_id, short int unsigned type,
               short int unsigned posi_x, short int unsigned posi_y,
               Unit *unit_return);

ne fonction que si la mémoire pour unit_return est allouée à l'extérieur de la fonction. Si la fonction a la responsabilité d'allouer dynamiquement la mémoire pour cette structure à l'aide de malloc, on a deux solutions:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
Unit * init_unit(short int unsigned user_id, short int unsigned type,
               short int unsigned posi_x, short int unsigned posi_y)
{
    Unit *unit_return = malloc(sizeof *unit_return);
    /*-TC- Il faut toujours vérifier la valeur de retour de malloc */
    if (unit_return != NULL)
    {
        unit_return->user_id = user_id;
        unit_return->type = type;
        unit_return->mouv.vue = VUE_NULL;
        unit_return->mouv.deb.x	= posi_x;
        unit_return->mouv.deb.y	= posi_y;
        unit_return->mouv.go.x = posi_x;
        unit_return->mouv.go.y = posi_y;
        unit_return->mouv.pas = 0;
        unit_return->vie_act = 1;
        unit_return->action	= ACT_WAIT;
    }
    return unit_return;
}

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
enum {INIT_OK, INIT_NULL_ARG_ERROR, INIT_ALLOC_ERROR}
 
int init_unit(short int unsigned user_id, short int unsigned type,
                 short int unsigned posi_x, short int unsigned posi_y
                 Unit **unit_return)
{
    int err = INIT_OK;
 
    if (unit_return != NULL)
    {
        Unit *tmp = malloc(sizeof *unit_return);
        /*-TC- Il faut toujours vérifier la valeur de retour de malloc */
        if (unit_return != NULL)
        {
            tmp->user_id = user_id;
            unit_return->type = type;
            tmp->mouv.vue = VUE_NULL;
            tmp->mouv.deb.x	= posi_x;
            tmp->mouv.deb.y	= posi_y;
            tmp->mouv.go.x = posi_x;
            tmp->mouv.go.y = posi_y;
            tmp->mouv.pas = 0;
            tmp->vie_act = 1;
            tmp->action	= ACT_WAIT;
        }
        else
        {
            /* Erreur: L'allocation de mémoire à échoué */
            err = INIT_ALLOC_ERROR;
        }
        *unit_return = tmp;
    }
    else
    {
        /* Erreur: NULL passé en argument à unit_return */
        err = INIT_NULL_ARG_ERROR;
    }
    return err;
}

Par ailleurs, n'oublie pas qu'il faut toujours (!) vérifier la valeur de retour de malloc.

Thierry

16/03/2007, 10h25
Franck.H

Citation:

Envoyé par mchk0123

Me suis toujours demandé s'il y avait une différence en termes de code compilé, entre les 2 versions ? Je suppose que non ...

non aucune différence mais c'est surtout pour la maintenance du code. De cette manière, si le type de unit_return change et bien tu n'as pas à changer dans tout le code, juste dans sa déclaration ;)
16/03/2007, 10h26
Thierry Chappuis

Citation:

Envoyé par mchk0123

Me suis toujours demandé s'il y avait une différence en termes de code compilé, entre les 2 versions ? Je suppose que non ...

Non, la différence est au niveau de la maintenance, plus aisée avec la version de Franck.

EDIT: grillé

Thierry

Pour revenir à la fonction init_unit, d'un point de vue conception, les versions données plus-haut initialisent tous les membres explicitement, y compris le champ mouv, et les champs deb et go de mouv. En procédant de la sorte, on casse l'abstraction autour des structures Mouv et Point. A mon avis, une bonne pratique est de créer un constructeur pour chacune de ces structures:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
/* N'effecture pas d'allocation */
int Point_init(Point *p_self, unisgned int x, unsigned int y)
{
    err = 0;
 
    if (self != NULL)
    {
        /* FACULTATIF: C'est un bonne pratique de tout initialiser à 0 */
        static Point tmp = {0};
        *p_self = tmp;
 
        p_self->x = x;
        p_self->y = y;
    }
    else
    {
        /* Erreur: NULL est passé en 1er argument... */
        err = 1;
    }
    return err;
}

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
/* Alloue dynamiquement de la mémoire */
Point * Point_new(unsigned int x, unsigned int y)
{
    Point *p_this = malloc(sizeof *p_this);
    if (p_this != NULL)
    {
        /* FACULTATIF: C'est un bonne pratique de tout initialiser à 0 */
        static Point tmp = {0};
        *p_this = tmp;
 
        p_this->x = x;
        p_this->y = y;
    }
    return p_this;
}

Thierry