Exercice structure et pointeur

Bonjour,

Voici un exercice que je du effectué, et je voulais avoir votre avis dessus. On m'a demandé de modifier un bout de programme pour que celui-ci fonctionne correctement.

Voici le programme:

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

typedef struct{   int hauteur, largeur; unsigned char* pixels; }image_t;     void alloue_image(image_t* i, int h, int l) { i.hauteur=h; i.largeur=h; i.pixels=malloc(h*l+1); }   return i;   }

---

Voici ce que j'ai écrit:

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21

typedef struct image_t image_t; struct image_t { int hauteur; int largeur; unsigned char* pixels;   };   void alloue_image(image_t* i, int h, int l)   { i = malloc(sizeof(image_t)); *i.hauteur=h; *i.largeur=l; *i.pixels=malloc((h*l+1)*sizeof(char); }

---

merci d'avance

Ce code ne fera rien d'autre que des fuites mémoires.
Dans la fonction tu modifies une copie de pointeur, l'original ne sera pas modifié et n'aura jamais la nouvelle structure en mémoire.
Au passage, plutôt que ces immondes *i., utilise l'opérateur ->

Citation:

---

Envoyé par enzo9311

Voici un exercice que je du effectué, et je voulais avoir votre avis dessus.
Voici ce que j'ai écrit:

Code:

---

1 2 3 4 5 6 7 8

void alloue_image(image_t* i, int h, int l)   { i = malloc(sizeof(image_t)); *i.hauteur=h; *i.largeur=l; *i.pixels=malloc((h*l+1)*sizeof(char); }

---

---

Bonjour
Tu alloues "i" (local à la fonction) que tu perds ensuite. Bref pareil que Bousk. Mémoire allouée et perdue.

A mon avis, tu devrais reprendre le premier programme et l'indenter correctement, tu verrais mieux où il y a l'erreur (et au passage ça te montrera que l'indentation d'un code ce n'est pas que pour faire joli).

Citation:

---

Envoyé par enzo9311

Citation:

---

Envoyé par Bousk

Au passage, plutôt que ces immondes *i., utilise l'opérateur ->

---

---

D'autant plus que l'opérateur "étoile" étant moins prioritaire que le "point", pour que ça fonctionne tu aurais dû écrire (*i).membre=valeur...

Citation:

---

Envoyé par enzo9311

Bonjour,

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

typedef struct{   int hauteur, largeur; unsigned char* pixels; }image_t;     void alloue_image(image_t* i, int h, int l) { i.hauteur=h; i.largeur=h; i.pixels=malloc(h*l+1); }   return i;   }

---

Voici ce que j'ai écrit:

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21

typedef struct image_t image_t; struct image_t { int hauteur; int largeur; unsigned char* pixels;   };   void alloue_image(image_t* i, int h, int l)   { i = malloc(sizeof(image_t)); *i.hauteur=h; *i.largeur=l; *i.pixels=malloc((h*l+1)*sizeof(char); }

---

merci d'avance

---

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

struct { int hauteur, largeur; unsigned char* pixels; } image_t;   void alloue_image( int h, int l) { struct image_t* i = (struct image_t *) malloc(sizeof(image_t);   i->hauteur=h; i->largeur=h; }   return i;   }

---

c'est quoi cette ligne :

Code:

---

*i.pixels=malloc((h*l+1)*sizeof(char);

---

???
Que cherches-tu à faire ???

Code:

---

*i.pixels=malloc((h*l+1)*sizeof(char);

---

c'est pour allouer la taille pour 'pixels' qui est dans la structure

Citation:

---

Envoyé par enzo9311

Code:

---

*i.pixels=malloc((h*l+1)*sizeof(char);

---

c'est pour allouer la taille pour 'pixels' qui est dans la structure

---

Ce que tu vas obtenir sera un vecteur de h*l+1 char dont l'adresse de début sera i->pixels ?!

Citation:

---

Envoyé par enzo9311

Code:

---

*i.pixels=malloc((h*l+1)*sizeof(char);

---

c'est pour allouer la taille pour 'pixels' qui est dans la structure

---

Ben oui mais comme tu as mal adressé le membre "pixel" du pointeur "i" (cf mon premier post), le résultat du malloc ne sera pas récupéré au bon endroit.

Quand on veut s'adresser à un membre "xxx" d'un pointeur de structure "pt", l'opération "membre xxx du pointé de pt" s'écrira tout logiquement (*pt).xxx (à cause des priorités des opérateurs dont j'ai déjà parlé). Parce que si tu écris *pt.xxx ça équivaut à *(pt.xxx) ce qui signifie que "pt" est la structure elle-même (et non un pointeur) et que le pointeur c'est "xxx".
Mais l'écriture (*pt).xxx étant assez "chiante", il a été créé un opérateur de substitution "flèche". Ainsi l'écriture (*pt).xxx devient pt->xxx. C'est plus simple à écrire et ça signifie exactement la même chose (accès au membre "xxx" du pointé de "pt"). Et tout ça doit sûrement être écrit dans tes cours mais tout le monde sait évidemment qu'un cours c'est fait pour surtout ne pas être lu.

Donc à toi de voir ce que tu préfères écrire. Tu as le choix des deux écritures mais si tu choisis la première (sait-on jamais), alors fais le correctement.

PS: si "xxx" est lui aussi un pointeur, alors l'accès à son pointé s'écrira *(*pt).xxx ou plus simplement *pt->xxx (qui se lit alors *(pt->xxx)).

très bien merci beaucoup. Je croyais que *i.XXX était exactement équivalent à i->xxx. Je savais pas qu'il fallait mettre des parenthèses.

Citation:

---

Envoyé par enzo9311

Je croyais que *i.XXX était exactement équivalent à i->xxx.

---

Ca aurait été totalement contre-productif d'implémenter deux écritures distinctes exactement équivalentes...

Citation:

---

Envoyé par enzo9311

Je savais pas qu'il fallait mettre des parenthèses.

---

Et ça ne te choquait pas d'écrire la même chose dans le cas où c'est "XXX" le pointeur et "i" la structure???

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14

typedef strut { int *xxx; int v; } t_truc;   t_truc i; t_truc *pt; i.v=10; i.xxx=&i.v; pt=&i; printf("v vaut %d\n", i.v); printf("v vaut %d\n", pt->v); printf("xxx vaut %d\n", *i.xxx); printf("xxx vaut %d\n", *pt->xxx);

---

...

Bonjour,
En plus de ce qui a été mentionné par les autres membres du forum j'ajouterais que si vous souhaitez vraiment allouer dynamiquement vos structures, vous avez deux possibilités. La première (pour les débutants, cela pourrait paraître compliqué.) est l'emploi d'un pointeur de pointeur, car c’est ce qui permettra à votre fonction de pouvoir modifier votre variable pointeur . La seconde est juste une fonction qui renvoie une adresse mémoire valide obtenu grâce la fonction d’allocation dynamique malloc.

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22

/* * Fonction d’allocations qui renvoie * deux valeurs de retours: * (0) comme échec d’allocation et * (1) une allocation réussie. */ int f_alloc_a( ts_image** p){ *p = malloc( 1 * (sizeof *p )); return *p != NULL; } /* * Fonction d’allocations qui renvoie : * -> une adresse valide en cas de succès de l'allocation dynamique * -> NULL (qui est un pointeur invalide de référence) */ ts_image *f_alloc_b( void ){ ts_image *p = NULL; if( !( p = malloc(1 *sizeof *p) ) ) return NULL; return p; }

---

à bientôt