Discussion :

[theludovyc]

Bonjour,

Comme vous avez pu le lire dans le titre une question me turlupine sur la fonction realloc !!!

Vous pouvez voir dans ce post https://www.developpez.net/forums/d1...loc-ca-marche/ que je propose une interprétation de la fonction realloc :

Code :

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

1
2
3
4
5
6
7
8
9
10
 
void *realloc(void *blocACopier, size_t nouvelleTaille){
  void *tmp=malloc(nouvelleTaille); //allocation d'une nouvelle zone mémoire
  if(tmp==NULL){ //allocation raté
    return NULL;
  }
  memcopy(tmp, blocACopier, ancienneTaille); //copie
  free(blocACopier); //libération
  return tmp;
}

On peut y voir que ancienneTaille ne fait pas parti des paramètres et est déterminée par la fonction elle même. Or après plusieurs recherche obtenir la taille d'une zone mémoire allouée dynamiquement avec la bibliothèque standard est impossible, seulement realloc y arrive très bien !

D'où ma question : comment elle fait?

[dalfab]

Bonjour,
En fait malloc(), calloc() et realloc() allouent au moins 8 octets de plus que demandés, stockent dans ces octets les tailles allouées, et retournent un pointeur augmenté de 8. Le format de ces données n'est pas standardisé, c'est pourquoi on ne doit pas y accéder. Un code possible

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
void *realloc( void *blocACopier , size_t nouvelleTaille ) {
   size_t  alloues = 0;     // bytes réservés
   size_t  taille = 0;      // bytes utilisables
   if ( blocACopier ) {
      alloues = ((size_t*)blocACopier)[-1]; // une structure possible ou une autre?
      taille  = ((size_t*)blocACopier)[-2];
      while ( nouvelleTaille > alloues  &&  la-zone-suivant-le-bloc-est-disponible ) {
         fusionner-le-bloc-avec-le-bloc-suivant-et-trouver-nouvelle-valeur-pour-'alloues'
         ((size_t*)blocACopier)[-1] = alloues;
      }
   }
   if ( nouvelleTaille > alloues ) {        // allocation nécessaire ailleurs
      void *tmp = malloc( nouvelleTaille ); //allocation d'une nouvelle zone mémoire et 2*size_t avant
      if ( !tmp ) return NULL;
      if ( blocAcopier ) {
         memcpy( tmp , blocACopier , taille );
         free( blocACopier );
         blocACopier = tmp;
      }
   }
   else { // assez ou trop grand
      if ( nouvelleTaille + TAILLE_HYSTERESIS < alloues ) { // trop grand
         couper-le-bloc-ne-garder-que-le-necessaire-et-trouver-nouvelle-valeur-pour-'alloues'
         ((size_t*)blocACopier)[-1] = alloues;
      }
      ((size_t*)blocACopier)[-2] = nouvelleTaille;  // noter la nouvelle taille utile
   }
   return blocACopier;
}

[theludovyc]

Bonjour @dalfab,

Merci pour ta réponse. C'est dommage que ça ne soit pas standardisé, pourquoi un tel choix a t'il été fait?

[Jamatronic]

Pour interdire aux programmeurs d'aller consulter ces données et faire des bidouilles avec ?

Si vous le faites, c'est à vos risques et périls.

[Mat.M]

Code :

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

memcopy(tmp, blocACopier, ancienneTaille);

si ancienneTaille est supérieure à nouvelleTaille bonjour les plantages et dépassement mémoire !

[theludovyc]

Pour interdire aux programmeurs d'aller consulter ces données et faire des bidouilles avec ?

Si vous le faites, c'est à vos risques et périls.

Bonjour @Jamatronic,
Je ne vois pas l'intérêt d'interdire cela au programmeur. Le faire d'accord, où est ce que je peut trouvé des tutos précis là dessus?

Code :

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

memcopy(tmp, blocACopier, ancienneTaille);

si ancienneTaille est supérieure à nouvelleTaille bonjour les plantages et dépassement mémoire !

Bonjour @Mat.M
J'ai mis un lien vers mon post ou j'explique que je fait cette interprétation qu'en cas d'une augmentation.

[Médinoc]

Bonjour,
En fait malloc(), calloc() et realloc() allouent au moins 8 octets de plus que demandés, stockent dans ces octets les tailles allouées, et retournent un pointeur augmenté de 8.

C'est un détail d'implémentation et rien ne garantie que ce soit vraiment le cas (un OS pourrait stocker ses tailles quelque part en espace Kernel à la place, voire les déduires de ses listes chaînées de blocs...).

---

Le fait est que le standard C ne prévoit aucun moyen de demander à l'implémentation la taille d'un bloc alloué. Choix délibéré ou oubli, je l'ignore.
D'autres bibliothèques faisant de l'allocation de mémoire (comme les diverses de Windows) proposent de telles fonctions (LocalSize()/GlobalSize() pour LocalAlloc()/GlobalAlloc() (retournent la taille réelle du bloc, qui peut être plus grande que celle initialement demandée), HeapSize() pour HeapAlloc(), VirtualQuery() pour VirtualAlloc(), mais rien pour la mémoire allouée via CoTaskMemAlloc())

Résultat, si tu fais un programme en C standard, c'est à toi de garder trace des tailles allouées (y compris, par exemple, en utilisant la tactique mentionnée par dalfab).

[Matt_Houston]

Choix délibéré ou oubli, je l'ignore.

Quelle en serait l'utilité ? Ce serait imposer d'énormes contraintes au système d'allocation pour bien peu d'avantages offerts au programmeur au final.


@dalfab : même si ce que tu écris était vérifié dans 85% des cas ça reste de la pure spéculation. La libc fait ce qu'elle veut en fin de compte.

[Christophe]

malloc fonctionne sur des systèmes différents allant de Linux à MS-DOS. Il peut donc être logique que la façon dont la fonction gère l'allocation soit différente et qu'il ne faille pas "bricoler". C'est l'intérêt d'une fonction système, tu ne te préoccupe pas de son fonctionnement, tu lui donnes une (ou plusieurs) entrée(s) et tu attend un résultat en sortie.

Tu peux toujours étudier le code source de la fonction.

Ou plus facile d'accès un tuto comme celui-ci :
http://www.inf.udec.cl/~leo/Malloc_tutorial.pdf

[theludovyc]

Merci pour vos réponses c'est hyper enrichissant !

On s'éloigne un peu du sujet alors j'ai ouvert une nouvelle discussion https://www.developpez.net/forums/d1...irie-standard/