Question about Free() and Ptr-Ptr-Int

[Kehyn]

So I have a function where I have allocated space dynamically for an array of pointers to ints.

Then I dynamically create arrays of ints for each of those pointers.

Then I've returned the base address of the array of pointers to main and do stuff with it...

I now have to release the space that was allocated (for an assignment). The professor has given me this function prototype:

void FreeMatrix(int **matrix);

I'm supposed to free the space with a pointer to a pointer to an int. Here is my question: if I do a free(matrix), will that free all the allocated space, or do I have to free each element?

If I have to go in and free each element, how would I know how many elements I need to free?

I was thinking if I would be able to do a sizeof(*matrix) to find out??

I ask because I am not sure(obviously) and would like to know if my function is releasing all the memory or if my OS is.


Please and thanks!

[tabstop]

You would have to free every pointer that came from a malloc. If you don't somehow know how many rows in your table were allocated, you are SOL.

[Kehyn]

Well this function doesn't know how many rows there are so there isn't an option for me?

I guess I will ask the professor then...

[tabstop]

If you can try and sneak a global variable in somewhere (shudder), then you can use that. Otherwise, that's it.

[MK27]

If I have to go in and free each element, how would I know how many elements I need to free?

This is a harder problem to create than you maybe think, but anyway.

One failsafe is: unallocated pointers are assigned NULL when declared:

void *ptr = NULL;

if it's in a struct, initialize the members to NULL or you zero out the struct (which NULLs the pointers).

Next, de-allocated pointers are assigned NULL:

free(ptr);
ptr = NULL;

Finally, when cleaning-up: never free a NULL pointer, always free a non-NULL pointer:

if (ptr) {   // NULL == FALSE, or 0. Everything else is TRUE.
   free(ptr);
   ptr = NULL;
}

This is not the most optimal method but it's cheap enough and works well.

[tabstop]

Hey I just realized the obvious way to make this work, and MK has most of it:

This is a harder problem to create than you maybe think, but anyway.

One failsafe is: unallocated pointers are assigned NULL when declared:

void *ptr = NULL;

if it's in a struct, initialize the members to NULL or you zero out the struct (which NULLs the pointers).

Next, de-allocated pointers are assigned NULL:

free(ptr);
ptr = NULL;

Finally, when cleaning-up: never free a NULL pointer, always free a non-NULL pointer:

if (ptr) {   // NULL == FALSE, or 0. Everything else is TRUE.
   free(ptr);
   ptr = NULL;
}

This is not the most optimal method but it's cheap enough and works well.

You missed out the most important part: you will always need to have one "extra" pointer at the end of your table that is NULL, which tells you when to stop. (Otherwise you'll just go off into somebody else's memory and free it instead.)

It's not late enough for me to be forgetting things like this; where's my Mountain Dew?

[Kehyn]

This is a harder problem to create than you maybe think, but anyway.

One failsafe is: unallocated pointers are assigned NULL when declared:

void *ptr = NULL;

if it's in a struct, initialize the members to NULL or you zero out the struct (which NULLs the pointers).

Next, de-allocated pointers are assigned NULL:

free(ptr);
ptr = NULL;

Finally, when cleaning-up: never free a NULL pointer, always free a non-NULL pointer:

if (ptr) {   // NULL == FALSE, or 0. Everything else is TRUE.
   free(ptr);
   ptr = NULL;
}

This is not the most optimal method but it's cheap enough and works well.

This is fine and dandy, but no use to me. :0

If you can try and sneak a global variable in somewhere (shudder), then you can use that. Otherwise, that's it.

The problem is that during my program, I ask the user for the amount of rows and colums and allocate the "2D" array with that information...so globals are out.

[tabstop]

The problem is that during my program, I ask the user for the amount of rows and colums and allocate the "2D" array with that information...so globals are out.

There's nothing inherent about asking for input that says the variables can't be global. (Again, not necessarily good design, but we're in a bit of a box here.)

[Kehyn]

So I should be able to do something like:

if (NULL != matrix[i])
     {
      free(matrix[i]);
      }

I don't think I understand. If I have a block of memory out there somewhere and just beyond my memory is another pointer that isn't NULL this shouldn't work...

[tabstop]

So I should be able to do something like:

while (NULL != matrix[i])
     {
      free(matrix[i++]);
      }

I don't think I understand. If I have a block of memory out there somewhere and just beyond my memory is another pointer that isn't NULL this shouldn't work...

That's why if the person asks for n rows, you have malloc give you n+1 pointers and make the last one NULL. Yes this wastes a massive 4 bytes of storage. And notice the fix to the code.

[Kehyn]

That's why if the person asks for n rows, you have malloc give you n+1 pointers and make the last one NULL. Yes this wastes a massive 4 bytes of storage. And notice the fix to the code.

K I think I'll try that....I was just providing an example that would probably be in a for loop or something...

[Kehyn]

Hellz yea, got it to work. Thanks tabstop and MK27 for your help.