remplissage d'une structure

Version imprimable

Bonjours,

voici un bout du contenu de mat.h:

Code:

1
2
3
4
5
6
7
8
typedef struct mat_t { 		// class matrice
	unsigned int height;
	unsigned int width;
	unsigned int level;		// niveau de gris max de l'image
	char ** pixels;			// tableau de pixels accessible avec pixels[i][j]
} mat_pas_pointeur, * mat;
 
mat mat_new(unsigned int width, unsigned int height);// retourne une matrice non initialisee

puis un bout dans mat.c:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
mat mat_new(unsigned int width, unsigned int height){
	// s'appelle avec la syntaxe self->pixels[ligne][colone]
	mat m;
	unsigned int i;
	printf("juste avant l'assignation\n");
	m->height = height;
	m->width = width;
	printf("juste avant l'allocation!\n");
	m->pixels[0] = calloc(height * width, sizeof(**(m->pixels)));
	printf("juste apres la premiere allocation\n");
	m->pixels = calloc(height, sizeof(*(m->pixels)));
 
	for (i=1; i<mat_height(m); i++){
		m->pixels[i] = m->pixels[i-1] + mat_width(m);
	}
	return m;
}

un bout du main.c:

Code:

1
2
3
4
5
6
7
8
9
10
int main(int argc, char const *argv[]){
	const char *input = NULL, *output = NULL;
	const char *op = NULL;
	int interp = -1;
	double parm = 0.0;
 
	mat in = NULL, out = NULL;
 
 
	mat_print(mat_pgm_read("/home/dieu/Documents/Dropbox/projet_info/images/palmier.pgm")); return EXIT_SUCCESS; // pour tester pgm

Et l'orsque le code arrive sur m->height = height; dans mat.c, il y a Segmentation fault (core dumped)
Comment puis-je faire pour avoir le droit d'accéder au champ m->height ?

02/01/2020, 19h15
Bousk

mat est un type pointeur et tu n'alloues jamais m.

merci

En initialisation la matrice avant et en ne faisant ici que la modifier, cela fonctionne effectivement mieu! Merci

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
 
int mat_init(mat_pointeur m, unsigned int width, unsigned int height, unsigned int level){
	// s'appelle avec la syntaxe self->pixels[ligne][colone]
	// instanci chacun des champs de la matrice m
	unsigned int i;
	m->width = width;	// largeur de l'image
	m->height = height; // hauteur de l'image
	m->level = level;   // niveau de gris maximum
	m->pixels[0] = calloc(height * width, sizeof(**(m->pixels)));	// caloc afin d'avoir une image noir, pas random!
	m->pixels = malloc(height * sizeof(*(m->pixels)));				// on ne perd pas de temps a tout metre a zero, on initialise en effet juste apres
 
	for (i=1; i<mat_height(m); i++){
		m->pixels[i] = m->pixels[i-1] + mat_width(m);
	}
	return 1;
}

03/01/2020, 14h09
Bousk

Pour cette raison, cacher un pointeur dans un typedef est imo une mauvaise pratique.

Attention, tu as inversé ces deux lignes :
Citation:
Envoyé par robinechuca
Code:

1 2 m->pixels[0] = calloc(height * width, sizeof(**(m->pixels))); // caloc afin d'avoir une image noir, pas random! m->pixels = malloc(height * sizeof(*(m->pixels))); // on ne perd pas de temps a tout metre a zero, on initialise en effet juste apres
Tu dois d'abord initialiser le pointeur m->pixels avant de pouvoir accéder à m->pixels[0].
Tester le retour de ces allocations serait aussi une bonne chose à faire.

correction finale

Merci, voici donc le code final, autant laisser quelque chose de terminé!

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
 
int mat_init(mat_pointeur p_m, unsigned int width, unsigned int height, unsigned int level){
	// s'appelle avec la syntaxe self->pixels[ligne][colone]
	// instanci chacun des champs de la matrice m
	unsigned int i;
	p_m->width = width;	// largeur de l'image
	p_m->height = height; // hauteur de l'image
	p_m->level = level;   // niveau de gris maximum
	p_m->pixels = malloc(mat_height(p_m) * sizeof(*(p_m->pixels)));					// on ne perd pas de temps a tout metre a zero, on initialise en effet juste apres
	if (NULL == p_m->pixels){
		fprintf(stderr, "L'os elle est pas gentille! Elle veux pas me donner de la memoire!\n");
		return 0;
	}
	p_m->pixels[0] = calloc(mat_height(p_m) * mat_width(p_m), sizeof(**(p_m->pixels)));	// calloc afin d'avoir une image noir, pas random!
	if (NULL == p_m->pixels[0]){
		fprintf(stderr, "L'os elle est pas gentille! Elle veux pas me donner de la memoire!\n");
		return 0;
	}
	for (i=1; i < mat_height(p_m); i++){								// on met les bon pointeurs
		p_m->pixels[i] = p_m->pixels[i-1] + mat_width(p_m);				// dans la liste de pointeurs
	}
	return 1;
}

Presque :P

Code:

1
2
3
4
5
6
	p_m->pixels[0] = calloc(mat_height(p_m) * mat_width(p_m), sizeof(**(p_m->pixels)));	// calloc afin d'avoir une image noir, pas random!
	if (NULL == p_m->pixels[0]){
		free(p_m->pixels); // <======  On n'oublie pas de libérer la première zone allouée, sinon fuite de mémoire !
		fprintf(stderr, "L'os elle est pas gentille! Elle veux pas me donner de la memoire!\n");
		return 0;
	}

Enfin, tu pourrais très bien utiliser les entrées height et width à la place de tes appels à mat_height(p_m) et mat_width(p_m).