allocation dynamique ne fonctionne qu une fois.

Version imprimable

Bonjour.
dans le cadre de mes études je dois réaliser un petit programme qui doit pouvoir allouer un nombre de float dynamiquement: nombre d'élément lu par un scanf. Toutes les données en entrées sont en redirection vers un fichiers de données.
Celui ci est de blocs constitués comme suit.
Première ligne : int code int n(nombre d'élement)
deuxième ligne: suite de n float que je dois stocker dynamiquement
et ainsi de suite.
voici le code de mon programme:

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
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
 
#include<stdio.h>
#include<math.h>
#include<malloc.h>
 
float * alloc_mem(int n);
void liberer_mem(float *x);
void lecture( float *x, float *y, int n);
void liberer_mem(float *tab)
{
	free(tab);
}
 
float * alloc_mem(int n)
{
	float *temp;
	temp=(float*)malloc(n*sizeof(float));
	return temp;
}
 
void lecture( float *x, float *y, int n)
{
	int i=0;
	for(i=0;i<n;i++)
	{
		scanf("%f %f",x+(i*sizeof(float)),y+(i*sizeof(float)));
		printf("je lis\n");
	}
}
void impression(float *tab, int n)
{
	int i=0;
	for(i=0;i<n;i++)
	{
		if(i%5==0)
			printf("\n");
		printf("%2.3f | ",*(tab+(i*sizeof(float))));
	}
}
 
 
int main (void)
{
 
	int code, n, i=1;
/*x et y représentent en fait un nuage de point*/
	float *x, *y;
	while(scanf("%d %d",&code,&n)==2)
	{
	printf("n=%d\n",n);
	printf("nuage%d .\n",i);
	printf("**********\n");
	printf("est ce quez j arrive la?");
 
	if((x=alloc_mem(n))==NULL)
		printf("erreur sur l allocation\n");
 
 
	printf("%p\n",x);
	printf("jalloue la mémoire");
	y=alloc_mem(n);
	lecture(x,y,n);
	printf("impression de x\n");
	impression(x,n);
	printf("impression de y\n");
	impression(y,n);
	liberer_mem(x);
	liberer_mem(y);
	printf("%p\n",x);
	printf("\n");
	i++;
	}
	return 0;
}

et le fichier de données

Code:

1
2
3
4
5
6
7
8
9
 
1 10
1.52 2.52 1.21 5.52 6.52 9.32 1.25 5.65 9.32 4.36 12.32 3.65 4.95 1.75 5.25 2. 32.3 33.6 12. 32.3
1 5
2.25 21.32 5. 21.78 5.256 21.54 1.25 1.65 2.65 58.95
1 10
1.52 2.52 1.21 5.52 6.52 9.32 1.25 5.65 9.32 4.36 12.32 3.65 4.95 1.75 5.25 2. 32.3 33.6 12. 32.3
1 5
2.25 21.32 5. 21.78 5.256 21.54 1.25 1.65 2.65 58.95

Voici maintenant le résultat de l'exécution.

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
 
n=10
nuage 1 .
**********
est ce quez j arrive la?003D24B8
jalloue la mÚmoireje lis
je lis
je lis
je lis
je lis
je lis
je lis
je lis
je lis
je lis
 
impression du tableau x
 
1.520 | 1.210 | 6.520 | 1.250 | 9.320 |
12.320 | 4.950 | 5.250 | 32.300 | 12.000 |
impression du tableau y
 
1.250 | 9.320 | 12.320 | 4.950 | 5.250 |
32.300 | 12.000 | 2.000 | 33.600 | 32.300 | 003D24B8
 
n=5
nuage 2 .
**********
est ce quez j arrive la?

toute les impression qui n ont rien a voir sont la pour tester jusqu'ou je peux aller dans le code.
Apparement le programme s'arrete après l'allocation la deuxième fois, je ne comprend pas pourquoi...
Pöurriez vous m'expliquer pourquoi?
D'avance Merci. :lol:

10/03/2006, 23h32
PRomu@ld
Juste pour info à la compilation ça me donne ça :

Citation:

test.c:3:20: error: malloc.h: No such file or directory
test.c: In function 'liberer_mem':
test.c:10: error: implicit declaration of function 'free'
test.c:10: warning: nested extern declaration of 'free'
test.c: In function 'alloc_mem':
test.c:16: error: implicit declaration of function 'malloc'
test.c:16: warning: incompatible implicit declaration of built-in function 'malloc'
test.c: At top level:
test.c:30: warning: no previous prototype for 'impression'

J'aimerai que tu m'explique comment tu fais pour exécuter ton programme puisqu'il ne compile pas.

D'autre part, ceci est déprécié :

Citation:

temp=(float*)malloc(n*sizeof(float));

il vaut mieux faire ça :
Code:

1 2 temp= malloc(n*sizeof(float));
De plus, tu ne testes pas toujours les valeur de retour de ta fonction (tu le fais pour x mais pas pour y)

Pour ton free, la bonne méthode pour libérer la mémoire c'est de faire ceci :
Code:

1 2 3 free(tab); tab = NULL;
Or attention cependant si tu utilises ta fonction telle que tu l'a faite, ça ne marchera pas.

Il faut faire ceci :
Code:

1 2 3 4 5 6 void liberer_mem( float ** tab ) { free(*tab); *tab = NULL; }
et lors de l'appel il faut faire ceci :
Code:

1 2 liberer_mem( &tab );
L'explication vient du type de passage des paramètres des fonctions en C.

Enfin, pour tes debuggages, utilise un fprintf sur la sortie d'erreur standard, du coup tu sauras exactement où ça plante ( problème de bufferisation).

Je n'ai pas répondu exactement à ta question mais corrige un petit peu ton code (du moins pour qu'il compile chez moi ...) et ensuite je pourrais surement t'aider.

J'utilise MinGW developer studio. ici je n ai pas d erreur de compilation. est ce que vous pourriez , svp , m expliquer le prototype de la fonction liberer_mem? et l'appel surtout car je ne comprend pas.
voici mon code modifié avec ajout de la librairie stdlib.h. Je m'excuse pour les erreurs que je n'ai pas eu...

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
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
 
#include<stdio.h>
#include<math.h>
#include<stdlib.h>
 
float * alloc_mem(int n);
void liberer_mem(float **tab);
void lecture( float *x, float *y, int n);
void liberer_mem(float **tab)
{
 
	free(*tab);
	*tab=NULL;
}
 
float * alloc_mem(int n)
{
	float *temp;
	temp=(float*)malloc(n*sizeof(float));
	return temp;
}
 
void lecture( float *x, float *y, int n)
{
	int i=0;
	for(i=0;i<n;i++)
	{
		scanf("%f %f",x+(i*sizeof(float)),y+(i*sizeof(float)));
		printf("je lis\n");
	}
}
void impression(float *tab, int n)
{
	int i=0;
	for(i=0;i<n;i++)
	{
		if(i%5==0)
			printf("\n");
		printf("%2.3f | ",*(tab+(i*sizeof(float))));
	}
}
 
 
int main (void)
{
 
	int code, n, i=1;
	float *x, *y;
	while(scanf("%d %d",&code,&n)==2)
	{
	printf("n=%d\n",n);
	printf("nuage %d .\n",i);
	printf("**********\n");
	printf("est ce quez j arrive la?");
 
	if((x=alloc_mem(n))==NULL  || (y=alloc_mem(n))==NULL )
	printf("erreur sur l allocation\n");
 
	printf("%p\n",x);
	printf("jalloue la mémoire");
	lecture(x,y,n);
	printf("\nimpression du tableau x\n");
	impression(x,n);
	printf("\nimpression du tableau y\n");
	impression(y,n);
	free(x);
	free(y);
	liberer_mem(&x);
	liberer_mem(&y);
	printf("%p\n",x);
	printf("\n");
	i++;
	}
	return 0;
}

Le résultat est toujours le meme. Je n'ai pas eu plus de résultats
Pour rappel du résultat :

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
 
 
n=10
nuage 1 .
**********
est ce quez j arrive la?003D24B8
jalloue la mÚmoireje lis
je lis
je lis
je lis
je lis
je lis
je lis
je lis
je lis
je lis
 
impression du tableau x
 
1.520 | 1.210 | 6.520 | 1.250 | 9.320 |
12.320 | 4.950 | 5.250 | 32.300 | 12.000 |
impression du tableau y
 
1.250 | 9.320 | 12.320 | 4.950 | 5.250 |
32.300 | 12.000 | 2.000 | 33.600 | 32.300 | 003D24B8
 
n=5
nuage 2 .
**********
est ce quez j arrive la?

Merci d'avance

Alors, en C, les fonctions passent leur paramètres par copie, ainsi lorsque tu fais ceci :
Code:

1 2 3 4 5 void fct( int a, int b) { ... }
Tu es d'accord que a et b lors des appels sont des copies des variables que tu as passé en paramètre.

Pour le cas de pointeurs dans les paramètres tu fais ceci :
Code:

1 2 3 4 5 void fct( int *a ) { ... }
Le pointeur a est une copie du pointeur que tu as passé en paramètre. Comme il s'agit de pointeurs, tout ce que tu vas modifier en passant par a modifiera aussi ce qui sera pointé par ce que tu as passé en paramètre. Ca, je pense que tu l'as bien compris au vu de ton code.

Maintenant venons en au point délicat. Lorsque tu fais :
Code:

1 2 a = NULL;
Tu mets le pointeur a à NULL et pas la variable pointée, en effet pense à ce qui se passe lorsque tu fais ceci :
Code:

1 2 3 4 5 6 7 8 9 10 int * p1; int * p2; int var; p1 = &var; p2 = p1; free(p2); p2 = NULL;
A ton avis que vaut p1 ? et bien en fait, p1 ne vaut pas NULL. Et c'est exactement ce qui se passait lorsque tes paramètres étaient passés par un simple pointeur.

Si tu veux t'en convaincre teste ce petit programme. et regarde le résultat.
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 #include <stdlib.h> #include <stdio.h> int main () { int var,*p1,*p2; p1 = &var; p2 = p1; free(p2); p2 = NULL; printf("p1 = %p\n",p1); printf("p2 = %p\n",p2); return EXIT_SUCCESS; }
Maintenant, lorsque tu fais ceci :
Code:

1 2 void fct (int **a )
Tu as donc un pointeur sur un pointeur d'entier, et lors de l'appel, tu modifie bien aussi le pointeur que tu as passé. Ceci est du au fait que le compilateur va copier ce pointeur de pointeur et aussi au fait que nous modifions le pointeur le plus interne (donc que l'on travaille avec *a ).

Reprenons le même programme que tout à l'heure :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 #include <stdlib.h> #include <stdio.h> int main () { int var,*p1,**p2; p1 = &var; p2 = &p1; free(*p2); *p2 = NULL; printf("p1 = %p\n",p1); printf("p2 = %p\n",*p2); return EXIT_SUCCESS; }
Maintenant, p1 vaut bien NULL comme nous le voulions. Il en est donc de même avec la fonction libere_mem

11/03/2006, 00h14
michael urbain

Merci beaucoup pour les explications.
mais est ce que vous pouvez comprendre les résultats de mon code???
Pouvais vous me dire ce qui ne va pas?
Histoire d'avoir une piste pour chercher.$
Merci :lol:
11/03/2006, 08h08
Trap D

Ton erreur provient d'une mauvaise compréhension de l'arithmétique des pointeurs :

Code:

",*(tab+(i*sizeof(float))

Comme le compilateur connaît le type de tab, float, il calcule automatiquement la taille du décalage pour passer d'un float à l'autre dans le tableau et toi tu le trompes avec tes produits par sizeof(float).
Donc il faut enlever tous les *sizeof(float) dans les indiçages de tableau.
11/03/2006, 10h33
michael urbain

Un grand merci. c'etait bien les sizeof qui faisait foirait tout le bazar... ma dernière question sera donc dans quel cas les utilise t-on?
Merci encore...
11/03/2006, 10h51
Trap D

Ben, pour les allocations mémoires par exemple, pour les recopies de données, quand on est obligé de travaillé au niveau byte.