mon realloc perso

**gdpasmini** · 27/10/2006, 09h02

Bonjour a tous !

Dans la famille redifinition de fonction je voudrais le realloc !

J'ai fais ce code :

Code :

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

1
2
3
4
5
6
7
8
 
void *Monrealloc(void *ptr, size_t size)
{
     void * monNouveauPointeur = Monmalloc(size);
     memcpy(monNouveauPointeur, ptr, size);
     Monfree(ptr);
     return (void *)monNouveauPointeur;
}

Ca a l'air de marcher mais est ce que le realloc fonctionne comme ceci ?

La raison de cette redeclaration est dû a des pb memoires que j'observe sur un system embarqué. En effet, il arrive parfois que la libération d'un pointeur null fasse planter la machine... Est ce normal ?

**Emmanuel Delahaye** · 27/10/2006, 09h51

Envoyé par gdpasmini

Ca a l'air de marcher mais est ce que le realloc fonctionne comme ceci ?

Pas tout à fait. Si le pointeur d'initial est NULL, le comportement doit être défini (ce qui n'est pas le cas ici).

Code :

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

1
2
3
4
5
6
 
   if (ptr != NULL)
   {
      memcpy(monNouveauPointeur, ptr, size);
   }
   ...

Note : Le cast à la fin est inutile :

Code :

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

   return monNouveauPointeur;

La raison de cette redeclaration

Tu veux sans doute dire redéfinition...

est dû a des pb memoires que j'observe sur un system embarqué. En effet, il arrive parfois que la libération d'un pointeur null fasse planter la machine... Est ce normal ?

Non. Il doit y avoir un autre problème, genre débordement de bloc alloué ou utilisation de pointeur non initialisé ou NULL...

**Jean-Marc.Bourguet** · 27/10/2006, 10h00

Il faut copier une quantité de données correspondant à ce qui était alloué précédemment, pas ce qui est nouvellement alloué.

**Médinoc** · 27/10/2006, 10h11

Pour être précis, il faut copier la plus petite des deux tailles (oui, on peut se servir de realloc() pour réduire un espace alloué).

Et aussi, une implication plus profonde de Monrealloc() dans ta gestion du tas pourrait permettre de changer la taille "sur place" s'il n'y a rien qui gène (100% de réussite pour un rétrécissement)...

**Franck.H** · 27/10/2006, 10h35

Envoyé par Emmanuel Delahaye

Pas tout à fait. Si le pointeur d'initial est NULL, le comportement doit être défini (ce qui n'est pas le cas ici).

Code :

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

1
2
3
4
5
6
 
   if (ptr != NULL)
   {
      memcpy(monNouveauPointeur, ptr, size);
   }
   ...

Il me semble que si le pointeur passé en paramètre est NULL, realloc se comporte comme malloc. Cela peut varier d'une implémentation à une autre ?

**gdpasmini** · 27/10/2006, 10h40

ok merci beaucoup.. mais pour copier la plus petite des deux tailles, il faut connaitre la taille précédement allouée or lors du realloc on a plus accès a cette information .. Si ?

D'autre part, lors de mes tests, un free fait reellement planter ma machine..
J'ai donc rajouté une protection :

Code :

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

1
2
3
4
5
6
7
8
 
Monfree(void * ptr)
{
  if(ptr == NULL)
    return;
  else
   free(ptr);
}

Depuis, ca plante moin...

**Médinoc** · 27/10/2006, 10h41

C'est anormal, il me semble bien que la norme dit que free(NULL) doit "échouer" silencieusement...
(à l'inverse de fclose(NULL) qui est indéfini)

**gdpasmini** · 27/10/2006, 10h45

Je ne comprends pas non plus pk si un pointeur n'est pas initialisé a NULL, il peut planté lors de l'allocation...

D'autre part, comment obtenir la taille précédement allouée ?

**Emmanuel Delahaye** · 27/10/2006, 10h47

Envoyé par Jean-Marc.Bourguet

Il faut copier une quantité de données correspondant à ce qui était alloué précédemment, pas ce qui est nouvellement alloué.

Exact, sinon, on lit dans une zone en partie indéterminée.

Problème, on ne connait pas cette taille, donc on est cuit, on ne peut pas écrire son realloc()...

Affaire réglée.

**Emmanuel Delahaye** · 27/10/2006, 10h48

Envoyé par Franck.H

Il me semble que si le pointeur passé en paramètre est NULL, realloc se comporte comme malloc.

Ben oui, d'où la protection de memcpy() par le if ...

Cela peut varier d'une implémentation à une autre ?

Pas si ces implémentations sont conformes au C standard.

**Emmanuel Delahaye** · 27/10/2006, 10h50

Envoyé par Franck.H

Il me semble que si le pointeur passé en paramètre est NULL, realloc se comporte comme malloc. Cela peut varier d'une implémentation à une autre ?

Ben oui, d'où la protection de memcpy()...

De toutes façons, comme l'a fait remarqué Jean Marc, on ne peut pas créeer son realloc() [1]. Affaire classée...

-----------------------
[1] à moins de passer un paramètre en plus : 'ancienne_taille'...

**gdpasmini** · 27/10/2006, 10h50

on ne peut pas ecrire son propre realloc ?

La protection du memcpy ne le permet il pas ?

**Médinoc** · 27/10/2006, 10h52

Envoyé par Emmanuel Delahaye

Problème, on ne connait pas cette taille, donc on est cuit, on ne peut pas écrire son realloc()...

Affaire réglée.

Pour être précis, je dirais qu'on ne peut pas écrire de realloc() à un niveau supérieur à celui des malloc() et free() : Le realloc doit au moins être au même niveau, voire à un niveau inférieur.

**gdpasmini** · 27/10/2006, 10h55

ola, dsl mai je comprends pas l'histoire des niveaux...

**Emmanuel Delahaye** · 27/10/2006, 10h55

Envoyé par gdpasmini

ok merci beaucoup.. mais pour copier la plus petite des deux tailles, il faut connaitre la taille précédement allouée or lors du realloc on a plus accès a cette information .. Si ?

Non. D'où problème. A part passer l'info sous la forme d'un paramètre, je ne vois pas d'issue.

D'autre part, lors de mes tests, un free fait reellement planter ma machine..
J'ai donc rajouté une protection :

Code :

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

1
2
3
4
5
6
7
8
 
Monfree(void * ptr)
{
  if(ptr == NULL)
    return;
  else
   free(ptr);
}

Depuis, ca plante moin...

Ca n'a strictement rien résolu du tout.

Déjà cité, mais tellement à-propos :

"Ce n'est pas en cassant le thermomètre qu'on guéri le malade."

**gdpasmini** · 27/10/2006, 10h58

pourtant je vous assure qu'en mettant un printf avant et apres le free, je vois clairement qu'il ne sort jamais de mon free..

**Emmanuel Delahaye** · 27/10/2006, 11h00

Envoyé par gdpasmini

Je ne comprends pas non plus pk si un pointeur n'est pas initialisé a NULL, il peut planté lors de l'allocation...

T'as lu ça où ?

Code :

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

1
2
3
4
 
   T *p;
 
   p = malloc(...);

et

Code :

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

   T *p = malloc(...);

sont parfaitement valides.

D'autre part, comment obtenir la taille précédement allouée ?

Il faut s'en souvenir. (une variable, par exemple, ou une structure qui regroupe le pointeur et la taille allouée).

**Emmanuel Delahaye** · 27/10/2006, 11h14

Envoyé par gdpasmini

pourtant je vous assure qu'en mettant un printf avant et apres le free, je vois clairement qu'il ne sort jamais de mon free..

On se tue à te dire que c'est la conséquence d'un problème qui c'est passé avant, comme un débordement de mémoire, ce qui a détruit le gestionnaire de mémoire allouée, d'où le crash. Isole ton code à coup de #if 0 #endif jusqu'à trouver le fautif...

**Jean-Marc.Bourguet** · 27/10/2006, 11h22

Envoyé par Emmanuel Delahaye

Problème, on ne connait pas cette taille, donc on est cuit, on ne peut pas écrire son realloc()...

Si on écrit les fonctions malloc, realloc et free, ce qui a l'air d'être le cas de l'OP, on peut stocker cette taille quelque part de sorte qu'on la retrouve après. On en a de toute manière besoin aussi pour le free.

Une technique est de faire précéder les blocs de leur taille.