Discussion :

[Faraziel]

Bonjour (bonsoir) à tous.

J'ai une question sur la fonction realloc.
Admettons que je fasse un truc du genre :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
 
int i=0;
int* tab = (int *) malloc(sizeof(int)*15);
 
for{i=0;i<15;i++){
   tab[i]=i;
}
 
free(tab[4]);
free(tab[9]);
free(tab[14]);
 
tab = realloc(tab,sizeof(int)*12);

est-ce que realloc va reperer les zones libres les enlever et me remettre le reste dans un tableau de 12 éléments avec tab[4] = 5, tab[9]=11 et tab[12]=14, par exemple ?

nb : j'ai conscience que le code est pas terrible est qu'il faut tester chaque allocation pour éviter les erreurs, mais dans un souci de clarté j'ai pas voulu m'encombrer avec les tests habituels.

[sambia39]

Bonjour
Attention dans l'exemple poster il y a des erreurs.
la fonction

Code C :

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

void free( void* ptr );

a pour rôle de libère l'espace mémoire pointé par votre variable pointeur et elle sera sans effet, si le variable pointeur vaut nulle en plus claire, free ne marchera qu'a condition que le variable pointeur pointe sur un espace mémoire alloué par calloc realoc ou malloc.

Et pour répondre à ta question la fonction realloc travaille uniquement sur la taille de ton objet ( exemple tableaux) et non sur les éléments de ton objet en plus clair, il change la taille de ton objet pointé par ta variable pointeur.
Si la nouvelle taille est plus petite que l'ancienne taille alors, la fonction conservera uniquement le début du contenu de ton objet dans le cas contraire (si la taille souhaitée est plus grande que la taille initiale ) tout le contenue de ton objet est conserver mais, les espaces supplémentaires ne sont pas initialisés c'est donc à toi de faire le nécessaire.
Il faut également garder en tête que la fonction renvoie un pointeur sur le nouvel espace mémoire , NULL, quand tout se passe mal sinon, l'objet conserve sa taille initiale.
à bientôt

[gangsoleil]

Admettons que je fasse un truc du genre :

Je crains de ne pas admettre non

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
 
int i=0;
int* tab = (int *) malloc(sizeof(int)*15); /* Tu alloues donc 15 "int*", donc 15 pointeurs sur des int */
 
for{i=0;i<15;i++){
/*   tab[i]=i; */ /* NON. Enfin c'est légal de faire ça, mais ce n'est probablement pas ce que tu veux faire. Ici, tu mets dans tab[0] l'adresse 0, qui ne t'es pas allouée, donc si tu accèdes à son contenu, tu plantes */
   tab[i] = malloc (taille); /* taille à définir */
   if (tab[i] == NULL)
     break;
}
 
if (i != 15)
{
  /* au moins une allocation a planté. On libère et on quitte */
  for (j = i ; j >= 0 ; j--)
  { free tab[j] ; 
     tab[j] = NULL;
   }
   free (tab);
}
 
free(tab[4]);
free(tab[9]);
free(tab[14]);
 
tab = realloc(tab,sizeof(int)*12);

est-ce que realloc va reperer les zones libres les enlever et me remettre le reste dans un tableau de 12 éléments avec tab[4] = 5, tab[9]=11 et tab[12]=14, par exemple ?

Non, car tu vois bien maintenant que tab ou tab[i] sont des allocations différentes.

Par ailleurs, ton utilisation de realloc n'est pas bonne : si realloc ne peut réallouer, il retourne NULL, et laisse ta zone mémoire intacte, pour que tu puisses continuer à travailler. Mais si tu écris :

Code :

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

1
2
 
tab = realloc (tab, ....);

tu perds ton pointeur sur tab, et tu as donc une fuite mémoire. La bonne manière serait :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
int * tmp_tab;
tmp_tab = realloc (tab, nouvelle_taille);
 
if (tmp_tab == NULL)
{
/* afficher une erreur */
}
else
{
tab = tmp_tab; 
taille_tab = nouvelle_taille ;
}
/* suite de ton programme */