Discussion :

[enzo9311]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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

[Bousk]

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 ->

[Sve@r]

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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).

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...

[exe2bin]

Bonjour,

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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

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

[enzo9311]

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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

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

[exe2bin]

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

*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 ?!

[Sve@r]

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

*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)).

[enzo9311]

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.

[Sve@r]

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

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

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 c :

Sélectionner tout - Visualiser dans une fenêtre à part

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);

...

[sambia39]

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 C :

Sélectionner tout - Visualiser dans une fenêtre à part

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