probleme allocation dynamique de mémoire

Version imprimable

Bonjour,

Je veux allouer de la mémoire dynamiquement pour 4 tableaux à 2 dimensions mais lors de l'éxécution, le test m'informe que l'allocation est impossible. Je programme sous labwindows CVI 8.5. Voici le code:

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
TabTimePalAlim=(int**) calloc(5,sizeof(int*));
  for(i=0; i<NbAlim; i++)
   TabTimePalAlim[i]=(int*) calloc(5,sizeof(int)); 
 
  if(TabTimePalAlim[i]==NULL)
   {
   MessagePopup("Erreur!!!", "Erreur lors de l'allocation de mémoire!");
 
   for(i=0; i<5; i++)
    {
    free(TabTimePalAlim[i]);
    TabTimePalAlim[i]=NULL;
    }
   free(TabTimePalAlim);
   TabTimePalAlim=NULL;
   }
 
  TabValPalAlim=(double**) calloc(5,sizeof(double*));
  for(i=0; i<NbAlim; i++)
   TabValPalAlim[i]=(double*) calloc(5,sizeof(double));
 
  if(TabValPalAlim[i]==NULL)
   {
   MessagePopup("Erreur!!!", "Erreur lors de l'allocation de mémoire!");
 
   for(i=0; i<5; i++)
    {
    free(TabValPalAlim[i]);
    TabValPalAlim[i]=NULL;
    }
   free(TabValPalAlim);
   TabValPalAlim=NULL;
   }
 
 
  TabTimePalCh=(int**) calloc(5,sizeof(int*));
  for(i=0; i<NbCharge; i++)
   TabTimePalCh[i]=(int*) calloc(5,sizeof(int));
 
  if(TabTimePalCh[i]==NULL)
   {
   MessagePopup("Erreur!!!", "Erreur lors de l'allocation de mémoire!");
 
   for(i=0; i<5; i++)
    {
    free(TabTimePalCh[i]);
    TabTimePalCh[i]=NULL;
    }
   free(TabTimePalCh);
   TabTimePalCh=NULL;
   }
 
  TabValPalCh=(double**) calloc(5,sizeof(double*));
  for(i=0; i<NbCharge; i++)
   TabValPalCh[i]=(double*) calloc(5,sizeof(double));
 
  if(TabValPalCh[i]==NULL)
   {
   MessagePopup("Erreur!!!", "Erreur lors de l'allocation de mémoire!");
 
   for(i=0; i<5; i++)
    {
    free(TabValPalCh[i]);
    TabValPalCh[i]=NULL;
    }
   free(TabValPalCh);
   TabValPalCh=NULL;
   }

A chaque démarrage, le problème reviend. J'ai essayer avec la fonction malloc et l'allocation se fait correctement mais lors de la réallocation de mémoire (realloc) les problèmes reviennes (run time error:Attempt to realloc pointer to freed memory ).
voici la réallocation pour infos:

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
TabTimePalAlim=realloc(TabTimePalAlim, NbAlim*sizeof(int*));
     TabTimePalAlim=realloc(TabTimePalAlim, NbPal*sizeof(int));
 
     if(TabTimePalAlim == NULL)
     {
     for(i=0; i<NbPal; i++)
      {
      free(TabTimePalAlim[i]);
      TabTimePalAlim[i]=NULL;
      }
     free(TabTimePalAlim);
     TabTimePalAlim=NULL;
     }
 
 
     TabValPalAlim=realloc(TabValPalAlim, NbAlim*sizeof(double*));
     TabValPalAlim=realloc(TabValPalAlim, NbPal*sizeof(double));
 
     if(TabValPalAlim == NULL)
     {
     for(i=0; i<NbPal; i++)
      {
      free(TabValPalAlim[i]);
      TabValPalAlim[i]=NULL;
      }
     free(TabValPalAlim);
     TabValPalAlim=NULL;
     }
 
     TabValPalCh=realloc(TabValPalCh, NbAlim*sizeof(double*));
     TabValPalCh=realloc(TabValPalCh, NbPal*sizeof(double));
 
     if(TabValPalCh == NULL)
     {
     for(i=0; i<NbPal; i++)
      {
      free(TabValPalCh[i]);
      TabValPalCh[i]=NULL;
      }
     free(TabValPalCh);
     TabValPalCh=NULL;
     }
 
     TabTimePalAlim=realloc(TabTimePalCh, NbAlim*sizeof(int*));
     TabTimePalAlim=realloc(TabTimePalCh, NbPal*sizeof(int));
 
     if(TabTimePalCh == NULL)
     {
     for(i=0; i<NbPal; i++)
      {
      free(TabTimePalCh[i]);
      TabTimePalCh[i]=NULL;
      }
     free(TabTimePalCh);
     TabTimePalCh=NULL;
     }

Pourriez vous me dire quel est le problème?

Je vous remercie.

27/02/2008, 14h57
valefor
Tu aurais du utiliser les balises code pour rendre ton message un peu moins indigeste.

Et puis je n'ai pas tout lu, j'ai plutot rien compris mais je crois pouvoir dire sans me tromper qu'il y a quelque chose de louche derrière cela :
Code:

1 2 TabTimePalAlim=realloc(TabTimePalAlim, NbAlim*sizeof(int*)); TabTimePalAlim=realloc(TabTimePalAlim, NbPal*sizeof(int));
La taille ne devrait-elle pas augmenter ?
Ne devrais-tu pas vérifier le retour de realloc ?
Mais que fait la police ?
27/02/2008, 15h41
totoscill
Citation:
Envoyé par valefor

Tu aurais du utiliser les balises code pour rendre ton message un peu moins indigeste.

Et puis je n'ai pas tout lu, j'ai plutot rien compris mais je crois pouvoir dire sans me tromper qu'il y a quelque chose de louche derrière cela :

Code:

1 2 TabTimePalAlim=realloc(TabTimePalAlim, NbAlim*sizeof(int*)); TabTimePalAlim=realloc(TabTimePalAlim, NbPal*sizeof(int));

La taille ne devrait-elle pas augmenter ?
Ne devrais-tu pas vérifier le retour de realloc ?
Mais que fait la police ?
Oui désolé, c'est vrai que c'est pas très lisible. Ce que j'ai fournis me permet en fait d'allouer de la mémoire pour 4 tableaux 2D (TabTimePalAlim, TabValPalAlim, TabTimePalCh et TabValPalCh). Dans ces tableaux je stocke des données en fonction de deux valeurs (numero outils et numero palier) concernant la configurations de mes outils qui me serviront à les piloter plus tard. Ici, j'essaie d'allouer dc mes 4 tableaux en faisant les test d'allocations à chaque fois. J'utilise la fonction "calloc" pour initialiser mes tableaux avec des valeurs "0". Les tableaux sont initialement (a l'initialisation du programme) créer sur 5 bit. Ensuite lors se que je veux utiliser ces tableaux pour stocké mes données, je réalloue la mémoire en fonction du nombre de palier configurer (NbPal) et du nombre d'outil utiliser (NbAlim) afin de ne pas utiliser de la memoire pour rien. La taille des tableau peut donc augmenter ou diminuer selon la configuration initiale choisit.

Concernant la vérification du retour de realloc, je ne comprend pas trop ce que tu veu dire. Je suis débutant en allocation de mémoire.

Peut tu m'éclairer un peu?

Je te remercie

Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 TabTimePalAlim=realloc(TabTimePalAlim, NbAlim*sizeof(int*)); TabTimePalAlim=realloc(TabTimePalAlim, NbPal*sizeof(int)); if(TabTimePalAlim == NULL) { for(i=0; i<NbPal; i++) { free(TabTimePalAlim[i]); TabTimePalAlim[i]=NULL; } free(TabTimePalAlim); TabTimePalAlim=NULL; }
Est incorrect:

- Pourquoi cette double reallocation sur TabTimePalAlim ?
- Si TabTimePalAlim == NULL alors TabTimePalAlim[i] est illégal.

De plus :

- La réallocation peut échouer et, dans ce cas, TabTimePalAlim est placé à NULL et la mémoire anciennement allouée n'est plus accessible et perdue.
Ranger le résultat du realloc dans un pointeur intermédiaire et si il est différent de NULL, le recopier dans TabTimePalAlim. On conserve alors, en cas d'échec, l'accès à la mémoire précédemment allouée via TabTimePalAlim.

- Le premier realloc change le nombre de pointeurs sur int.
Si ce nombre de pointeurs est plus petit qu'avant, les pointeurs sur int en excédent sont perdus et il est impossible de récupérer la mémoire sur laquelle il pointe
Si ce nombre est plus grand qu'avant, les nouveaux pointeurs ne sont pas initialisés. On doit faire (éventuellement, si le nombre d'éléments a changé) une realloc sur les anciens TabTimePalAlim[i] (avec les mêmes précautions) et une allocation sur les nouveaux.

Citation:
Envoyé par diogene
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 TabTimePalAlim=realloc(TabTimePalAlim, NbAlim*sizeof(int*)); TabTimePalAlim=realloc(TabTimePalAlim, NbPal*sizeof(int)); if(TabTimePalAlim == NULL) { for(i=0; i<NbPal; i++) { free(TabTimePalAlim[i]); TabTimePalAlim[i]=NULL; } free(TabTimePalAlim); TabTimePalAlim=NULL; }
Est incorrect:

- Pourquoi cette double reallocation sur TabTimePalAlim ?[/INDENT]
La double réallocation se fait pour les deux dimensions puisque je peux modifier NbAlim (1ère dimension) et NbPal(2ième dimension). Je pensai donc qu'il fallais réallouer la mémoire pour les deux dimensions.

Ai je raison?

Citation:

Envoyé par diogene

- Si TabTimePalAlim == NULL alors TabTimePalAlim[i] est illégal.

De plus :

- La réallocation peut échouer et, dans ce cas, TabTimePalAlim est placé à NULL et la mémoire anciennement allouée n'est plus accessible et perdue.
Ranger le résultat du realloc dans un pointeur intermédiaire et si il est différent de NULL, le recopier dans TabTimePalAlim. On conserve alors, en cas d'échec, l'accès à la mémoire précédemment allouée via TabTimePalAlim.

- Le premier realloc change le nombre de pointeurs sur int.
Si ce nombre de pointeurs est plus petit qu'avant, les pointeurs sur int en excédent sont perdus et il est impossible de récupérer la mémoire sur laquelle il pointe
Si ce nombre est plus grand qu'avant, les nouveaux pointeurs ne sont pas initialisés. On doit faire (éventuellement, si le nombre d'éléments a changé) une realloc sur les anciens TabTimePalAlim[i] (avec les mêmes précautions) et une allocation sur les nouveaux.

Ok, c'est vrai que ce n'est pas logique pour la réallocation. Je n'avais pas vu cette erreur. Je vous remercie. je vais modifier et voir ce que cela donne.

J'ai modifié mon code pour la réallocation. Il y avait plusieurs erreurs à force de modifier. Voici le code pour la réallocation d'un des tableau 2D:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 temp=realloc(TabTimePalAlim, NbAlim*sizeof(int*)); //réallocation 1ere D for(i=0; i<NbAlim; i++) temp[i]=realloc(TabTimePalAlim[i], NbPal*sizeof(int)); //réallocation 2eme D if(temp[i] == NULL) { for(i=0; i<NbPal; i++) { free(TabTimePalAlim[i]); TabTimePalAlim[i]=NULL; } free(TabTimePalAlim); TabTimePalAlim=NULL; } else { TabTimePalAlim=temp; for(i=0; i<NbAlim; i++) TabTimePalAlim[i]=temp[i]; }
Lors de l'exxecution, encore une erreur:
"Run Time error
Pointer arithmetic involving pointer to freed memory"

Qu'est ce qui ne va pas dans mon code?

28/02/2008, 12h02
Médinoc
Code:

1 2 3 temp=realloc(TabTimePalAlim, NbAlim*sizeof(int*)); //réallocation 1ere D for(i=0; i<NbAlim; i++) temp[i]=realloc(TabTimePalAlim[i], NbPal*sizeof(int)); //réallocation 2eme D
Si NbAlim est supérieur à sa taille précédente, tu feras des realloc() sur des pointeurs non-initialisés: realloc() n'initialise pas à zéro la place supplémentaire...

Citation:
Envoyé par totoscill
Bonjour,

Je veux allouer de la mémoire dynamiquement pour 4 tableaux à 2 dimensions mais lors de l'éxécution, le test m'informe que l'allocation est impossible. Je programme sous labwindows CVI 8.5. Voici le code:
Code:

1 2 3 4 5 6 7 TabTimePalAlim=(int**) calloc(5,sizeof(int*)); for(i=0; i<NbAlim; i++) TabTimePalAlim[i]=(int*) calloc(5,sizeof(int)); if(TabTimePalAlim[i]==NULL) { MessagePopup("Erreur!!!", "Erreur lors de l'allocation de mémoire!");
La réponse en cette question tiens en un caractère.

{

Le test est censé être dans la boucle. Dons ton cas, tu testes TabTimePalAlim[i] à l'extérieur de la boucle (i == NbAlim dans ce cas).

28/02/2008, 13h34
totoscill

Citation:

Envoyé par Médinoc

Si NbAlim est supérieur à sa taille précédente, tu feras des realloc() sur des pointeurs non-initialisés: realloc() n'initialise pas à zéro la place supplémentaire...

OK, merci. La fonction realloc() ne me sert donc pas à grand chose.

Comment puis je faire alors pour remédier à ce problème?

Allouer de la mémoire pour un tableau 2D tres grand pour ensuite realloué cette mémoire en utilisant la fonction realloc()?

Non, tu peux tout simplement mieux utiliser realloc().

Par exemple, en initialisant toi-même a NULL la partie ajoutée...
Code:

1 2 3 4 5 temp=realloc(TabTimePalAlim, newNbAlim*sizeof(*temp)); //réallocation 1ere D for(i=oldNbAlim ; i<newNbAlim ; i++) temp[i] = NULL; for(i=0 ; i<newNbAlim ; i++) temp[i]=realloc(TabTimePalAlim[i], NbPal*sizeof(**temp)); //réallocation 2eme D

ok!
merci. J'ai utiliser ta fonction mais toujours le meme probleme:

run time error, Pointer arithmetic involving pointer to freed memory!

voici le code:

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
 
temp=realloc(TabTimePalAlim, NbAlim*sizeof(*temp));
       for(i=5;i<NbAlim;i++)
	 temp[i]= NULL;
       for(i=0; i<NbAlim; i++)
	 temp[i]=realloc(TabTimePalAlim[i], NbPal*sizeof(**temp));
 
 if(temp[i] == NULL)
      {
      for(i=0; i<NbPal; i++)
	{
	free(TabTimePalAlim[i]);
	TabTimePalAlim[i]=NULL;
	}
     free(TabTimePalAlim);
     TabTimePalAlim=NULL;
     }
 
else
    {
    TabTimePalAlim=temp;
    for(i=0; i<NbAlim; i++)
    TabTimePalAlim[i]=temp[i];
    }

Je ne vois plus trop ce qu'il ne va pas!

28/02/2008, 14h31
diogene

Médinoc :

Citation:

Par exemple, en initialisant toi-même a NULL la partie ajoutée...

Effectivement, le problème est là depuis le début. En effet, pour mettre à NULL, ou faire une allocation sur la partie ajoutée, il faut connaître l'ancienne taille allouée.
Le type actuel de TabTimePalAlim ne s'y prête pas, étant un simple pointeur sur un tableau de pointeurs. Il faut restructurer les données en encapsulant dans une structure le pointeur sur ce tableau + la taille couramment allouée.

Il faut également réfléchir comment grouper les traitements similaires faits sur TabTimePalAlim , TabValPalAlim, TabTimePalCh, TabValPalCh

Il y a également un problème ici, en fait:

Code:

temp[i]=realloc(TabTimePalAlim[i], NbPal*sizeof(**temp));

On n'a plus aucune assurance que TabTimePalAlim est toujours valide ici.

Je conseille de modifier les emplois de realloc() pour éviter les confusions entre temp et original:
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 realloc_IntPtr(int ***ppMem, size_t nNew) { int ret = -1; int ** pNew = realloc(*ppMem, nNew * sizeof(**ppMem)); if(pNew != NULL || nNew==0) { *ppMem = pNew; ret = 0; } return ret; } int realloc_Int(int **ppMem, size_t nNew) { int ret = -1; int * pNew = realloc(*ppMem, nNew * sizeof(**ppMem)); if(pNew != NULL || nNew==0) { *ppMem = pNew; ret = 0; } return ret; }
Et ensuite:
Code:

1 2 3 4 5 realloc_IntPtr(&TabTimePalAlim, newNbAlim); for(i=oldNbAlim ; i<NbAlim ; i++) TabTimePalAlim[i]= NULL; for(i=0 ; i<NbAlim ; i++) realloc_Int(&TabTimePalAlim[i], NbPal);
Edit: Ajouté le cas || nNew==0 pour mieux coller au comportement de realloc pour une taille nulle (équivalent de free(), retourne NULL mais c'est un succès).

En fait, on peut même en faire des macros:

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
#define DECLARE_REALLOC(name, type) \
	int realloc_ ## name (type **ppMem, size_t nNew);
 
#define IMPLEMENT_REALLOC(name, type) \
	int realloc_ ## name (type **ppMem, size_t nNew)\
	{\
		int ret = -1;\
		type * pNew = realloc(*ppMem, nNew * sizeof(**ppMem));\
		if(pNew != NULL || nNew==0)\
		{\
			*ppMem = pNew;\
			ret = 0;\
		}\
		return ret;\
	}
 
IMPLEMENT_REALLOC(IntPtr, int *)
IMPLEMENT_REALLOC(Int, int)
 
//...
 
int realloc_mat_TabTimePalAlim(int *** pTabTimePalAlim, size_t oldNbAlim, size_t newNbAlim)
{
	if(realloc_IntPtr(pTabTimePalAlim, newNbAlim) < 0)
		return -1;
 
	for(i=oldNbAlim ; i<NbAlim ; i++)
		*(pTabTimePalAlim)[i]= NULL;
	for(i=0 ; i<NbAlim ; i++)
	{
		if(realloc_Int(&(*TabTimePalAlim)[i], NbPal) < 0)
		{
			/* Erreur. Mais que faire exactement ici ? */
			/* ... */
			return -1;
		}
	}
	return 0;
}

Edit: Ajouté le cas || nNew==0 pour mieux coller au comportement de realloc pour une taille nulle (équivalent de free(), retourne NULL mais c'est un succès).

28/02/2008, 15h33
totoscill

ok!

Mais ça ne resoud pas mon probleme de pointeur sur mémoire libérée. Je me melange un peu les pinceaux avec tout ça.
28/02/2008, 15h36
Médinoc

J'ai corrigé ma dernière fonction realloc_mat_machin.
Essaie avec ce code...

Citation:
Envoyé par Médinoc
Il y a également un problème ici, en fait:

Code:

temp[i]=realloc(TabTimePalAlim[i], NbPal*sizeof(**temp));

On n'a plus aucune assurance que TabTimePalAlim est toujours valide ici.

Je conseille de modifier les emplois de realloc() pour éviter les confusions entre temp et original:
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 realloc_IntPtr(int ***ppMem, size_t nNew) { int ret = -1; int ** pNew = realloc(*ppMem, nNew * sizeof(**ppMem)); if(pNew != NULL) { *ppMem = pNew; ret = 0; } return ret; } int realloc_Int(int **ppMem, size_t nNew) { int ret = -1; int * pNew = realloc(*ppMem, nNew * sizeof(**ppMem)); if(pNew != NULL) { *ppMem = pNew; ret = 0; } return ret; }
Et ensuite:
Code:

1 2 3 4 5 realloc_IntPtr(&TabTimePalAlim, newNbAlim); for(i=oldNbAlim ; i<NbAlim ; i++) TabTimePalAlim[i]= NULL; for(i=0 ; i<NbAlim ; i++) realloc_Int(&TabTimePalAlim[i], NbPal);
Je vais voir comme ça. Je te tiens au courant.

Citation:

Envoyé par Médinoc

J'ai corrigé ma dernière fonction realloc_mat_machin.
Essaie avec ce code...

Ok merci. J'ai utilisé ta première solution sans les macros. Ca fonctionne, enfin, plus d'erreur de pointeur. Mon tableau est bien alloué. Par contre, j'ai voulu vérifié si mes donnée étai bien initialiser à 0 et ça ne fonctionne pas.
Seule mes données initialiser à l'exécution de mon programme sont à 0. Celle créer par la réallocation donne des valueurs aléatoires. Pourtant on initialise bien les données à 0.
voici le code:
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 realloc_IntPtr(&TabTimePalAlim, newNbAlim); for(i=oldNbAlim ; i<NbAlim ; i++) TabTimePalAlim[i]= NULL; for(i=0 ; i<NbAlim ; i++) realloc_Int(&TabTimePalAlim[i], NbPal); realloc_IntPtr(&TabTimePalCh, newNbCharge); for(i=oldNbCharge ; i<NbCharge ; i++) TabTimePalCh[i]= NULL; for(i=0 ; i<NbCharge ; i++) realloc_Int(&TabTimePalCh[i], NbPal); realloc_DoublePtr(&TabValPalCh, newNbCharge); for(i=oldNbCharge ; i<NbCharge ; i++) TabValPalCh[i]= NULL; for(i=0 ; i<NbCharge ; i++) realloc_Double(&TabValPalCh[i], NbPal); realloc_DoublePtr(&TabValPalAlim, newNbCharge); for(i=oldNbCharge ; i<NbCharge ; i++) TabValPalAlim[i]= NULL; for(i=0 ; i<NbCharge ; i++) realloc_Double(&TabValPalAlim[i], NbPal);

Je n'ai initialisé que les nouveaux pointeurs à zéro, pas les nouvelles données
Qu'est-ce que c'est que cette indentation!!!

Indentation corrigée:

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
 
realloc_IntPtr(&TabTimePalAlim, newNbAlim);
for(i=oldNbAlim ; i<NbAlim ; i++)
	TabTimePalAlim[i]= NULL;
for(i=0 ; i<NbAlim ; i++)
	realloc_Int(&TabTimePalAlim[i], NbPal);
 
realloc_IntPtr(&TabTimePalCh, newNbCharge);
for(i=oldNbCharge ; i<NbCharge ; i++)
	TabTimePalCh[i]= NULL;
for(i=0 ; i<NbCharge ; i++)
	realloc_Int(&TabTimePalCh[i], NbPal);
 
realloc_DoublePtr(&TabValPalCh, newNbCharge);
for(i=oldNbCharge ; i<NbCharge ; i++)
	TabValPalCh[i]= NULL;
for(i=0 ; i<NbCharge ; i++)
	realloc_Double(&TabValPalCh[i], NbPal);
 
realloc_DoublePtr(&TabValPalAlim, newNbCharge);
for(i=oldNbCharge ; i<NbCharge ; i++)
	TabValPalAlim[i]= NULL;
for(i=0 ; i<NbCharge ; i++)
	realloc_Double(&TabValPalAlim[i], NbPal);