Pointer sizes and dereferencing a void *

Let's say I have a function that receives a void ** and I want to dereference the pointer and do something to whatever it points to. I know right away I would have to cast the void ** to something else.

If I just wanted to free whatever the void ** points to, I imagine this should work, even though it looks quite ugly:

Code:

---

void mgfree(void **p)
{
        if(p != NULL)
        {
                free(*((char **)p));
                *((char **)p) = NULL;
        }
        return;
}

---

So, basically, will the above block of code free the block of memory pointed to by p for any data type?

Are there any assumptions I should or should not make regarding pointer sizes on different platforms?

Edit: I just want to add that I'm asking if this is guarenteed to behave the same way on all systems.

While it is true that any object can be punned into an array of unsigned char, I think it would be much cleaner if you just did something like

Code:

---

void mgfree( void *p ) {
  free( p );
  p = NULL;
}

---

Why pass a pointer to pointer?

Here's an example why:

Code:

---

#include <stdio.h>
#include <stdlib.h>

void mgfree(void *p);

int main(int argc, char *argv[])
{
        int *p = malloc(sizeof(*p));
       
        if(!p)
        {
                printf("No memory.\n");
                return 1;
        }
        mgfree(p);
        printf("p should be null but it is: %p\n",p);
       
        return 0;
}

void mgfree(void *p)
{
        if(p != NULL)
        {
                free(p);
                p = NULL;
        }
}

---

Output:

Code:

---

p should be null but it is: 0x001444a8

---

This is possibly playing with undefined behavior here, but it shows that p was not set to NULL as it should have been. If I want to change the value of the pointer in the calling function, I have to pass its address.

How would you call it?

This code results in
$ gcc -W -Wall -ansi -pedantic -O2 foo.c
foo.c: In function `main':
foo.c:16: warning: passing arg 1 of `mgfree' from incompatible pointer type

Code:

---

void mgfree(void **p)
{
        if(p != NULL)
        {
                free(*p);
                *p = NULL;
        }
        return;
}

int main( ) {
    int *p = malloc(10);
    mgfree( &p );
    return 0;
}

---

You don't need all those casts, you can dereference a void** if all you're doing is calling free, and assigning NULL.
&p only results in a valid void** if p is a void* to begin with.

If you want to automatically NULL your pointer after free, then perhaps

Code:

---

void *myFree ( void *p ) {
    free( p );
    return NULL;
}
#define MYFREE(p) do { free(p); p = NULL; } while(0)

int main( ) {
    int *p = malloc(10);
    p = myFree( p );
    MYFREE(p);
    return 0;
}

---

Quote:

---

Originally Posted by Salem

Code:

---

#define MYFREE(p) do { free(p); p = NULL; } while(0)

---

---

I would suggest:

Code:

---

#define MYFREE(p) (free(p), p = NULL)

---

But such macros are not always appropriate.

Thought for sure that the compiler complained when I tried to dereference it, but obviously I was doing something else wrong.

Anyway, if I pass a char ** to this with warnings turned up:

Code:

---

void mgfree(void **p)
{
        if(p != NULL)
        {
                free(*p);
                *p = NULL;
        }
        return;
}

---

Quote:

---

Warning mgsafeio.c: 40 assignment of pointer to pointer to char to pointer to pointer to void
Warning mgsafeio.c: 57 assignment of pointer to pointer to char to pointer to pointer to void
Warning mgsafeio.c: 97 assignment of pointer to pointer to char to pointer to pointer to void
Warning mgsafeio.c: 108 assignment of pointer to pointer to char to pointer to pointer to void
0 errors, 5 warnings

---

I believe this is what Salem is referring to. Is this inherently unsafe to do? I imagine it is because the compiler is complaining, but why is this unsafe? Obviously, casting makes the compiler shut up, but that seems very silly to cast to a void **.

I take it, then, that a macro is the best way of handling this.

Is there anything else I should know about this?

Jeez. Why do people struggle with this so much?

Code:

---

void free_and_null(void *p)
{
    free(*(void **)p);
    *(void **)p = NULL;
}

---

And you use like this:

Code:

---

char *p = malloc(100);
free_and_null(&p);
/* p is now free, and set to NULL */

---

This code assumes that all pointer types are equal in size. On platforms where this is the case, the above function works.

It is not "silly" to cast to void **, it is the only appropriate way to do it.

EDIT: Just realized I'm being abrasive again. Sorry. Some spill-over from other irritating things going on.

Code:

---

void free_and_null(void *p);

char *p = malloc(100);
free_and_null(&p);  /* This makes a pointer to a pointer */

---

Don't you mean this?

Code:

---

free_and_null(p);

---

[edit] I'm just guessing. I don't have a C compiler on me. [/edit]

Quote:

---

Originally Posted by dwks

Don't you mean this?
[code]free_and_null(p);

---

No -- how could the function possibly alter the value of p unless a POINTER to p is passed?

EDIT: Maybe you're confused by the fact that the function takes a void *. That's just to allow any type of pointer-to-pointer to be passed. Don't let the single star fool you -- the argument is a pointer-to-pointer. void *, by definition, can hold any kind of pointer, including a pointer-to-pointer. There's no reason the number of stars has to be equal.

Unlike void *, void ** is not a special type. It is a pointer to a void *. Whereas a void * can hold ANY kind of pointer, a void ** can ONLY hold a pointer to void *.

I think he meant:

Code:

---

void free_and_null(void **p)

---

Quote:

---

Originally Posted by swoopy

I think he meant:

Code:

---

void free_and_null(void **p)

---

---

I did not.

Which dwks nicely demonstrates that a function taking just void* can be infinitely abused without comment from the compiler.
Seems to me like an invitation to replace one kind of bug with another kind of bug.

You've changed the semantics of free to the extent that free_and_null(p); is going to be one hell of a common mistake to make, because everyone is used to writing free(p);

> p = myFree( p );
The worst that can happen by writing
myfree(p);
is that the pointer isn't set to NULL automatically. It certainly doesn't hose the system in unpredictable ways by trying to free something which wasn't allocated in the first place.

Everybody seems very confused by this. You all seem to have a strong tendency to want the NUMBER of stars to match up: if you're passing a char **, then surely the argument type must be void **, right? WRONG.

There is only ONE MAGICAL POINTER TYPE in C, and that is "void *." This pointer type can be used to hold ANY kind of pointer: char *, double *, void **, char ***, int (*)(int), whatever. However, the INTERFACE of this function dictates that a pointer to a pointer be passed. This pointer is then forceably cast to void **, and then dereferenced in order to become a void *, which is deallocated. Then, this pointer is again dereferenced in order to set the original pointer to NULL.

Once you understand this, you REALLY understand pointers.

Why do void** pointers exist, then?

[edit] Why not have a function like this? Then if the programmer doesn't care about setting the variable to NULL, they just ignore the return value.

Code:

---

void *free_and_null(void *p) {
    free(p);
    return NULL;
}

free_and_null(p);
q = free_and_null(q);

---

[/edit]

Quote:

---

Originally Posted by Salem

You've changed the semantics of free to the extent that free_and_null(p); is going to be one hell of a common mistake to make, because everyone is used to writing free(p);

---

I strongly disagree. Any COMPETENT programmer understands that if a function modifies its argument, that argument must be a POINTER to the value.

And anyway, what are you complaining to me for? I didn't bring up this topic, MacGyver did. He asked how such a function would be written. I wrote it how it should be written. I have not indicated one way or the other if I would personally use such a function, have I?