Discussion :

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

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

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

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

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

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 ?

[totoscill]

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 :

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

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

[diogene]

Code :

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

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.

[totoscill]

Code :

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

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?

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

[totoscill]

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 :

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

[Médinoc]

Code :

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

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

[Emmanuel Deloget]

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 :

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

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

[totoscill]

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()?

[Médinoc]

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

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

Code :

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

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

[totoscill]

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 :

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

[diogene]

Médinoc :

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

[Médinoc]

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

Code :

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

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

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

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

[Médinoc]

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

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

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

[Médinoc]

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

[totoscill]

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

Code :

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

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

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

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.

[totoscill]

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 :

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

[Médinoc]

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

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