7

I have this error with the following code:

int main(){
    point   *points = malloc(sizeof(point));
    if (points == NULL){
        printf("Memory allocation failed.\n");
        return 1;
    }
    other_stuff(points);
    free(points);
    return 0;
}
void other_stuff(point points[]){
    //stuff
    realloc(points, number*sizeof(point))
}

I have searched, but found only examples where it was clear there was no allocation.

Here, I used malloc to initialise points, and later changed its size with realloc; so how is the pointer "not allocated" when I come to free it?

OJFord
  • 10,522
  • 8
  • 64
  • 98

3 Answers3

7

realloc may move the memory to a new location (if there is not enough space to expand the old pointer). If that happens, you need to free the new pointer.

Try this tweak:

int main(){
    point   *points = malloc(sizeof(point));
    if (points == NULL){
        printf("Memory allocation failed.\n");
        return 1;
    }
    other_stuff(&points);
    free(points);
    return 0;
}
void other_stuff(point **points){
    //stuff
    point *temp = realloc(*points, number*sizeof(point));
    if(temp != NULL) {
      *points = temp;
      // and do your stuff
    }
    else {
      // panic? memory reallocation failed. Deal with it gracefully.
    }
}

By passing a handle to other_stuff, we give it control not only over the place where the pointer is pointing, but to the address of the pointer itself. This allows it to move the memory around. Handles are a good way to manage memory dynamically; but conceptually a pointer to a pointer takes some getting used to...

Floris
  • 45,857
  • 6
  • 70
  • 122
  • -1 If `realloc` fails you are leaking memory. You assign to a temporary first when using `realloc` and then check the result. – Ed S. Dec 14 '13 at 00:45
  • 1
    Thanks for the correction! "Always check the return value" - even when writing a quick answer... – Floris Dec 14 '13 at 01:02
2

realloc returns a new pointer. That is what you need to free (eventually) if the function succeeded. Otherwise, it failed, and you keep the old pointer around for this case.

How to use realloc:

whataver *f = malloc(count * sizeof(*f));
/* ... */
whatever *temp = realloc(f, new_count * sizeof(*temp));
if (temp)
    f = temp;  // realloc worked, f is no longer valid/needed
else
    free(f);   // error

realloc may return the same pointer, or it may not. The point is that you no longer care about the original pointer if realloc succeeded. If it had to allocate a new block then the original pointer is invalid. If it didn't then it returned the same pointer, and you certainly don't want to deallocate that right away.

Ed S.
  • 122,712
  • 22
  • 185
  • 265
  • Sorry about that, points not local to main in code, edited my OP. – OJFord Dec 14 '13 at 00:43
  • @OllieFord: The edit didn't fix that issue, but whatever, it's not important. – Ed S. Dec 14 '13 at 00:43
  • @OllieFord: Yes. Either A) you get the same pointer back, or B) the original memory was `free`'d for you. – Ed S. Dec 14 '13 at 02:20
  • So if on `else` I take user input again for a new size, (so I'm just going to loop through `realloc` until no error) do I need to `free` before each successive `realloc`? – OJFord Dec 14 '13 at 02:49
  • @OllieFord: If `realloc` fails you have more to worry about. If you can't allocate memory your program is in a very unstable state, you can't assume any future actions will succeed. There's little more to do than to exit. If you have stuff laying around that you don't need you can free it, but unless this is a mission critical sort of application you'll probably just exit. – Ed S. Dec 14 '13 at 03:19
  • Okay, thanks. Not working when I replicated in another function though.. `typedef struct {double distance; int origpos;} entry; entry *positions = malloc(sizeof(entry)); function(&positions); int function(entry **positionarray){entry *tmp = realloc(*positions, n*sizeof(entry))}` returns `NULL`.. but the other function looks the same (different var, ptr names) and works. – OJFord Dec 14 '13 at 04:30
0

Thank you for the solution : realloc (MAY) return a NEW pointer.

Further, I believe that the following may help:

int main(){
    point   *points = malloc(sizeof(point));
    if (points == NULL){
        printf("Memory allocation failed.\n");
        return 1;
    }
    other_stuff(&points); /* Send address of points */
    free(points);
    return 0;
}
void other_stuff(point (*ppoints)[]){
    //stuff
    realloc(*ppoints, number*sizeof(point))  /* If a new storage area is assigned by     realloc the original points location will be updated in main */

}

robert d. sands
  • 1
  • 1