Utilisation appropriée de realloc()

De l'homme realloc:Le realloc() renvoie un pointeur vers la mémoire nouvellement allouée, qui est correctement alignés pour tout type de variable et peut être différente de ptr, ou NULL si la demande échoue.

Donc dans cet extrait de code:

ptr = (int *) malloc(sizeof(int));
ptr1 = (int *) realloc(ptr, count * sizeof(int));
if(ptr1 == NULL){           //reallocated pointer ptr1
    printf("Exiting!!\n");
    free(ptr);
    exit(0);
}else{
    free(ptr);          //to deallocate the previous memory block pointed by ptr so as not to leave orphaned blocks of memory when ptr=ptr1 executes and ptr moves on to another block
    ptr = ptr1;         //deallocation using free has been done assuming that ptr and ptr1 do not point to the same address                     
}

Est-il suffisant de simplement supposer que le réaffectées pointeur pointe vers un autre bloc de mémoire et de ne pas le même bloc.Parce que si l'hypothèse devient faux et realloc renvoie l'adresse de l'origine du bloc de mémoire pointé par ptr et puis free(ptr) exécute(pour la raison donnée dans les commentaires), alors que le bloc de mémoire seraient effacés et le programme aller de noix.
Dois-je le mettre dans une autre condition qui permettra de comparer l'égalité de ptr et ptr1 et de l'exclure de l'exécution de la free(ptr) déclaration?

PS - je n'ai pas assez de points de rep pour poser une autre question similaire sur TELLEMENT j'ai eu à former une nouvelle question..

OriginalL'auteur user3163420 | 2014-01-08

21

Il suffit de ne pas appeler free() sur votre ptr dans la bonne voie. Essentiellement realloc() a fait pour vous.
```
ptr = malloc(sizeof(int));
ptr1 = realloc(ptr, count * sizeof(int));
if (ptr1 == NULL) //reallocated pointer ptr1
{       
    printf("\nExiting!!");
    free(ptr);
    exit(0);
}
else
{
    ptr = ptr1;           //the reallocation succeeded, we can overwrite our original pointer now
}
```
Dans la page de man de realloc, je ne pourrais pas trouver l'info qu'il serait lui-même appel à free()...de toute façon thnx
Vraiment? Sur mon Mac man realloc: "... Si il n'y a pas assez de place pour agrandir l'allocation de mémoire pointé par ptr, realloc() crée une nouvelle allocation, que les copies de beaucoup de anciennes données pointé par ptr correspondra à la nouvelle répartition, libère l'ancienne allocation, et retourne un pointeur vers la mémoire allouée. ..."
Ne jette pas le résultat de malloc et realloc.
Je ressens le besoin de deuxième zenith suggestion. Si ce n'était pas pour le jette, vous auriez probablement les deux plus +1s.
heh... la typecasts ne sont pas juste une horreur, mais peut causer des problèmes sur certains obscur systèmes et ne servent à rien... mais vous avez tenu à conserver le code d'origine. Maintenant, les espaces ont été introduites afin de la rendre moins d'une pollution visuelle, qui permettent également sans but fonctionnel mais ne va pas casser quoi que ce soit (contrairement à typecasts, qui sera). Mon point est, si vous voulez permettre à des espaces ajoutés pour rendre le code style attrayant, voulez-vous permettent également inutile typecasts être enlevé pour rendre le code portables à style attrayant? Je ne vais pas le modifier, mais pourriez-vous revenir si je l'ai fait?

OriginalL'auteur Aaron S. Kurland
2

OP: ... peut-être différente de ptr, ou NULL si la demande échoue.

Un: non, Pas toujours. NULL peut légitimement être retourné (pas un échec), si count est de 0.

OP: Est-il suffisant de simplement supposer que le réaffectées pointeur pointe vers un autre bloc de mémoire et de ne pas le même bloc.

R: Non

OP: dois-je le mettre dans une autre condition qui permettra de comparer l'égalité de ptr et ptr1 et de l'exclure de l'exécution de la free(ptr) déclaration?

R: Non.

Si realloc() retourne NULL (et de comptage n'est pas 0), la valeur de ptr est toujours valide, pointant à l'onu-redimensionnée de données. free(ptr) ou pas dépend de vos objectifs.

Si realloc() retourne pas NULL, ne pas free(ptr), il est tout prêt libéré.

Exemple: https://codereview.stackexchange.com/questions/36662/critique-of-realloc-wrapper
```
#include <assert.h>
#include <stdlib.h>

int ReallocAndTest(char **Buf, size_t NewSize) {
  assert(Buf);
  void *NewBuf = realloc(*Buf, NewSize);
  if ((NewBuf == NULL) && (NewSize > 0)) {
    return 1;  //return failure
  }
  *Buf = NewBuf;
  return 0;
}
```
OriginalL'auteur chux
2

L'application de correctifs modifications, basé sur le bon commentaires ci-dessous.

Lecture ce comp.lang.c question, révèle 3 cas:
1. "Quand il est capable, il donne simplement vous remettre le pointeur de même que vous avez donné."
2. "Mais si elle doit aller à une autre partie de la mémoire de trouver suffisamment d'espace contigu, il retourne un pointeur différent (et la précédente valeur du pointeur devient inutilisable)."
3. "Si realloc ne peut pas trouver suffisamment d'espace à tous, elle renvoie un pointeur null, et laisse le précédent région affectée."
Ce qui peut être traduit directement de code:
```
int* ptr = (int*)malloc(sizeof(int));
int* tmp = (int*)realloc(ptr, count * sizeof(int));
if(tmp == NULL)
{
    //Case 3, clean up then terminate.
    free(ptr);
    exit(0);
}
else if(tmp == ptr)
{
    //Case 1: They point to the same place, so technically we can get away with
    //doing nothing.
    //Just to be safe, I'll assign NULL to tmp to avoid a dangling pointer.
    tmp = NULL;
}
else
{
    //Case 2: Now tmp is a different chunk of memory.
    ptr = tmp;
    tmp = NULL;
}
```
Donc, si vous pensez à ce sujet, le code que vous avez posté est très bien (ou presque). Le code ci-dessus se simplifie en:
```
int* ptr = (int*)malloc(sizeof(int));
int* tmp = (int*)realloc(ptr, count * sizeof(int));
if(tmp == NULL)
{
    //Case 3.
    free(ptr);
    exit(0);
}
else if(ptr != tmp)
{
    ptr = tmp;
}
//Eliminate dangling pointer.
tmp = NULL;
```
Note supplémentaires else if(ptr != tmp), ce qui exclut les Cas 1, au cas où vous ne souhaitez pas appeler free(ptr) parce que ptr et tmp reportez-vous à la même emplacement. Aussi, juste par sécurité, j'ai assurez-vous d'attribuer NULL à tmp pour éviter toute bancale problèmes de pointeur tout en tmp est dans la portée.

Vous n'avez pas à obéir à la "et la précédente valeur du pointeur devient inutilisable". Dans le ptr != tmp cas, la free(ptr) est faux.
D'accord avec @glglgl que cette réponse est dangereux, car vous ne devez pas appeler free(ptr) dans le cas 2.
Bon appel, appliqué comme une modification, et le commentaire de upvotes pour vous deux.

OriginalL'auteur Keeler
1

realloc sera de retour la même adresse pour ptr si elle a assez d'espace pour étendre la partie de la mémoire pointée par ptr. Autrement, il va déplacer les données vers le nouveau morceau et gratuit de l'ancien bloc. Vous ne pouvez pas compter sur ptr1 être différent de ptr. Votre programme se comporte pas défini.

Si realloc renvoie une autre adresse, il libère l'ancien, de sorte que vous n'avez pas à le faire vous-même.

Par le chemin, ne jamais lancer le retour de malloc/realloc :). Votre code devrait ressembler à ceci:
```
ptr=malloc(sizeof(int));
ptr=realloc(ptr,count*sizeof(int));
if(ptr==NULL)
{   
    //error!    
    printf("\nExiting!!");
    //no need to free, the process is exiting :)
    exit(0);
}
```
Il y a un problème: si le pointeur est NULL, free(ptr) n'a pas de sens.
Eh bien, qui fait du sens. Par ailleurs, le programme est sur le point de sortir donc pas de problème de ne pas le libérer 🙂 Fixation 🙂
C'est un détail d'implémentation et pas vrai en général: "realloc sera de retour la même adresse pour ptr si elle a assez d'espace pour étendre la partie de la mémoire pointé par ptr." Les implémentations que de séparer les crédits alloués par la taille (par exemple, OpenBSD omalloc) ont peu de chances de jamais retourner l'original de pointeur, sauf lorsque l'original et de nouvelles tailles de match.
Pour l'ajout de la note sur le casting de retour de malloc (), etc. +1
ptr=realloc(ptr,count*sizeof(int)); est brisée; quand realloc retourne NULL (ce qui n'est pas une adresse car il n'a pas de point sur un objet), vous avez une fuite de la mémoire de l'ancien objet. Le OpenGroup manuel états: "Si l'espace ne peuvent pas être attribuées, l'objet doit rester inchangée." Le C standard états: "Si la mémoire pour le nouvel objet ne peut pas être alloué, l'ancien objet n'est pas libéré, et sa valeur est inchangée."

OriginalL'auteur Paulo Bu
0

Si realloc se déplace à vos données, il permettra de libérer l'ancien pointeur pour vous dans les coulisses. Je n'ai pas de copie de la norme C11, mais il est garanti dans le standard C99.

Le C11 projet de norme est n1570.pdf, que vous pouvez trouver par une recherche sur google. Je trouve utile de citer à l'aide de liens (par exemple, en cliquant sur ce lien vous mènera à la realloc section de n1570.html, qui a été converti à partir n1570.pdf).

OriginalL'auteur tabstop
0

Vous devriez pas free original de votre pointeur si le realloc réussit. Si vous free le pointeur si le realloc échoue dépend des besoins de votre application particulière, si vous absolument ne peut pas continuer sans que de la mémoire supplémentaire, alors ce serait une erreur fatale et vous libérer de tout lieu de stockage et de sortie. Si, otoh, que, vous pouvez toujours continuer à (peut-être exécuter une autre opération et espère que la mémoire seront disponibles plus tard), vous voudrez probablement s'en tenir à ce mémoire et d'une tentative d'un autre realloc plus tard.

Le chapitre et le verset:
7.22.3.5 La fonction realloc

Synopsis

1
```
     #include <stdlib.h>
     void *realloc(void *ptr, size_t size);
```
Description

2 La realloc la fonction libère l'ancien objet pointé par ptr et renvoie un
pointeur vers un objet de la taille spécifiée par size. Le contenu de la nouvelle
l'objet doit être le même que celui de l'ancien objet, avant la libération, jusqu'à la moindre de
le nouveau et l'ancien tailles. Tous les octets de la nouvelle chose au-delà de la taille de l'objet ancien ont
indéterminée valeurs.

3 Si ptr est un pointeur null, la realloc fonction se comporte comme le malloc fonction de la
la taille indiquée. Sinon, si ptr ne correspond pas à un pointeur retourné plus tôt par un mémoire
de gestion de la fonction, ou si l'espace a été libéré par un appel à la free ou
realloc fonction, le comportement est indéfini. Si la mémoire pour le nouvel objet ne peut pas être
alloués, l'ancien objet n'est pas libéré, et sa valeur est inchangée.

Renvoie

4 La realloc fonction retourne un pointeur vers le nouvel objet (qui peut avoir le même
valeur comme un pointeur vers l'objet ancien), ou un pointeur null si le nouvel objet n'a pas pu être
alloués.
Italiques ajoutés. Note l'article 4; le pointeur retourné peut être le même que l'original de votre pointeur.

OriginalL'auteur John Bode

Vous devez vous connecter pour publier un commentaire.