Comportement étrange sur Realloc: taille suivante invalide

Question

Je sais qu'il ya des tonnes d'autres questions et réponses realloc et j'ai lu presque tous, mais je ne pouvais toujours pas réussi à résoudre mon problème.

j'ai décidé d'arrêter d'essayer quand j'ai découvert accidentaly un comportement très étrange de mon code. J'ai introduit une ligne pour essayer quelque chose, mais bien que je n'utilise pas la valeur de newElems dans main, la ligne change le comportement.

Lorsque la ligne est commenté, le code échoue au premier realloc. Y compris la ligne, le premier travail realloc. (Il se bloque toujours sur le second).

Des idées sur ce qui pourrait se passer?

int main(int argc, char** argv) { 
    Pqueue q = pqueue_new(3); 
    Node a = {.name = "a"}, b = {.name = "b"}, 
     c = {.name = "c"}, d = {.name = "d"}; 

    push(& q, & a, 3); 
    // the next one is the strange line: as you can see, it doesn't modify q 
    // but commenting it out produces different behaviour 
    Pqueue_elem* newElems = realloc(q.elems, 4 * q.capacity * sizeof *newElems); 
    push(& q, & b, 5); 
    push(& q, & c, 4); 

    char s[5]; 
    Node* n; 
    for (int i = 1; i <= 65; ++i) { 
     sprintf(s, "%d", i); 
     n = malloc(sizeof *n); 
     n->name = strdup(s); 
     push(& q, n, i); 
    } 

    Node* current = NULL; 
    while ((current = pop(& q))) { 
     printf("%s ", current->name); 
    } 
    return 0; 
} 

et la fonction Push:

void push(Pqueue* q, Node* item, int priority) { 
    if (q->size >= q->capacity) { 
     if (DEBUG) 
      fprintf(stderr, "Reallocating bigger queue from capacity %d\n", 
        q->capacity); 
     q->capacity *= 2; 
     Pqueue_elem* newElems = realloc(q->elems, 
             q->capacity * sizeof *newElems); 
     check(newElems, "a bigger elems array"); 
     q->elems = newElems; 
    } 

    // append at the end, then find its correct place and move it there 
    int idx = ++q->size, p; 
    while ((p = PARENT(idx)) && priority > q->elems[p].priority) { 
     q->elems[idx] = q->elems[p]; 
     idx = p; 
    } 
    // after exiting the while, idx is at the right place for the element 
    q->elems[idx].data = item; 
    q->elems[idx].priority = priority; 
} 

La fonction pqueue_new:

Pqueue pqueue_new(unsigned int size) { 
    if (size < 4) 
     size = 4; 
    Pqueue* q = malloc(sizeof *q); 
    check(q, "a new queue."); 
    q->capacity = size; 
    q->elems = malloc(q->capacity * sizeof *(q->elems)); 
    check(q->elems, "queue's elements"); 

    return *q; 
} 

Answer 1

Merci à tous pour vos suggestions! Je ne l'aurais pas résolu sans eux,

Le comportement étrange a été provoqué par une erreur d'un par un. Je réallouais la file d'attente seulement quand q->size >= q->capacity, mais puisque q a été indexé de 0, cela signifiait qu'avant realloc j'écrivais dans un endroit interdit (q->elems[q->size]), qui a tout gâché.

Answer 2

realloc va changer la quantité de mémoire allouée, le cas échéant. Il est également possible de déplacer les données vers un autre endroit en mémoire si cela est plus efficace (en évitant la fragmentation de la mémoire).
La fonction renvoie alors un nouveau pointeur nouveau vers l'emplacement nouveau dans la mémoire où vos données se cachent. Vous appelez realloc et allouez (probablement) quatre fois plus de mémoire qu'avant, il est donc très probable que cette mémoire allouée se trouve ailleurs dans la mémoire.

Dans votre commentaire, vous avez dit realloc fonctionne comme free + malloc. Eh bien, dans certains cas, il peut se comporter de la même , cependant: realloc et free sont différentes fonctions, qui font des tâches différentes. Les deux sont des fonctions qui gèrent la mémoire dynamique, donc oui, évidemment il y a des similitudes, et dans le cas de realloc, ils peuvent parfois sembler être faire la même chose, cependant: As I explained here, realloc and free are fundamentally different functions

Cependant, ne pas attribuer la valeur de retour de realloc à q.elems, il vous reste un pointeur vers une adresse de mémoire qui n'est plus valide. Le reste de votre programme peut et montre probablement des signes de comportement indéfini.

Sauf si vous montrez un code plus, je soupçonne que cela prendra soin du problème:

//change: 
Pqueue_elem* newElems = realloc(q.elems, 4 * q.capacity * sizeof *newElems); 
//to 
q.elems = realloc(q.elems, 4 * q.capacity * sizeof *newElems); 

Ou mieux encore, vérifiez pointeurs NULL:

Pqueue_elem* newElems = realloc(q.elems, 4 * q.capacity * sizeof *newElems); 
if (newElems == NULL) 
    exit(EXIT_FAILURE);// + fprintf(stderr, "Fatal error..."); 
q.elems = newElems;//<-- assign new pointer! 

---

En regardant votre pqueue_new fonction, je proposerais une approche différente. Renvoyez le pointeur sur Pqueue.Vous travaillez avec un morceau de mémoire dynamique, le traiter en conséquence, et que votre code reflète que tout le chemin à travers:

Pqueue * pqueue_new(size_t size) 
{//size_t makes more sense 
    if (size < 4) 
     size = 4; 
    Pqueue* q = malloc(sizeof *q); 
    check(q, "a new queue."); 
    q->capacity = size; 
    q->elems = malloc(q->capacity * sizeof *(q->elems)); 
    check(q->elems, "queue's elements"); 

    return q; 
} 

Vous pouvez également passer la fonction d'un pointeur vers une variable de la pile:

void pqueue_new(Pqueue *q, size_t size) 
{ 
    if (q == NULL) 
    { 
     fprintf(stderr, "pqueue_new does not do NULL pointers, I'm not Chuck Norris"); 
     return;//or exit 
    } 
    if (size < 4) 
     size = 4; 
    check(q, "a new queue."); 
    q->capacity = size; 
    q->elems = malloc(q->capacity * sizeof *(q->elems)); 
    check(q->elems, "queue's elements"); 
} 
//call like so: 
int main (void) 
{ 
    Pqueue q; 
    pqueue_new(&q, 3); 
} 

Ce seraient les approches les plus courantes.