Generalized function for deallocating and setting pointer to NULL

[rocco.rossi]

I've been trying to write a function capable of checking if a pointer
value is set to NULL, and if it isn't, of deallocating and setting
it's value to NULL regardless of the pointer's type. I thought "void
** " should do the trick, but I kept getting the following warning
message from gcc:

warning: passing argument 1 of 'free_var' from incompatible pointer
type

which obviously could be solved by doing an explicit cast to (void **)
in the argument list when calling the fuction. That however would put
an extra burden on the programmer, so I invented the following
solution which works quite well apparently. Please give me your
opinions on this issue.

void free_var(void *vptr)
{
void **ptr = (void **) vptr;

if (ptr != NULL) {
if (*ptr != NULL) {
free(*ptr);
*ptr = NULL;
}
}
}

Thank you.

[Barry Schwarz]

On Thu, 29 Nov 2007 09:27:09 GMT, Tomás Ó hÉilidhe <to*@lavabit.co m>
wrote:

>rocco.rossi:

>I've been trying to write a function capable of checking if a pointer
value is set to NULL, and if it isn't, of deallocating and setting it's
value to NULL regardless of the pointer's type. I thought "void ** "
should do the trick, but I kept getting the following warning message
from gcc:

void DeallocateAndNu llify(void **const pp)
{
free (*pp);

*pp = 0;
}

How would I pass an int* (or its address) to this function and avoid
the undefined behavior when sizeof(void*) != sizeof(int*)?
Remove del for email

[CBFalconer]

Barry Schwarz wrote:

Tomás Ó hÉilidhe <to*@lavabit.co mwrote:

>rocco.rossi:

>>I've been trying to write a function capable of checking if a
pointer value is set to NULL, and if it isn't, of deallocating
and setting it's value to NULL regardless of the pointer's type.
I thought "void ** " should do the trick, but I kept getting the
following warning message from gcc:

void DeallocateAndNu llify(void **const pp) {
free (*pp);
*pp = 0;
}

How would I pass an int* (or its address) to this function and
avoid the undefined behavior when sizeof(void*) != sizeof(int*)?

....
int *p;
....
DeallocAndNulli fy(&p);

--
Chuck F (cbfalconer at maineline dot net)
<http://cbfalconer.home .att.net>
Try the download section.

--
Posted via a free Usenet account from http://www.teranews.com

[=?UTF-8?q?Harald_van_D=C4=B3k?=]

On Sat, 01 Dec 2007 02:41:31 -0500, CBFalconer wrote:

Barry Schwarz wrote:

>Tomás Ó hÉilidhe <to*@lavabit.co mwrote:

>>void DeallocateAndNu llify(void **const pp) {
free (*pp);
*pp = 0;
}

How would I pass an int* (or its address) to this function and avoid
the undefined behavior when sizeof(void*) != sizeof(int*)?

....
int *p;
....
DeallocAndNulli fy(&p);

Well yes, if your code won't compile, you won't have undefined behaviour,
but I doubt that's what Barry Schwarz meant.

There is no implicit conversion from int ** to void **. There is no point
in an implicit conversion from int ** to void ** either, since the
representations of int * and void * can be completely different.

[Keith Thompson]

CBFalconer <cb********@yah oo.comwrites:

Barry Schwarz wrote:

>Tomás Ó hÉilidhe <to*@lavabit.co mwrote:

>>rocco.rossi :
I've been trying to write a function capable of checking if a
pointer value is set to NULL, and if it isn't, of deallocating
and setting it's value to NULL regardless of the pointer's type.
I thought "void ** " should do the trick, but I kept getting the
following warning message from gcc:

void DeallocateAndNu llify(void **const pp) {
free (*pp);
*pp = 0;
}

How would I pass an int* (or its address) to this function and
avoid the undefined behavior when sizeof(void*) != sizeof(int*)?

....
int *p;
....
DeallocAndNulli fy(&p);

[...]

Nope. &p is of type int**; the parameter is of type void**. There is
no implicit conversion from int** to void**.

Also, your call is to DeallocAndNulli fy rather than
DeallocateAndNu llify. (Perhaps you tried compiling your code, and the
misspelling caused the compiler not to know what the function
expects.)

[Chuck: aioe.org is free, doesn't add its own signature, and doesn't
even require signing up; you just have to set $NNTPSERVER. See their
web page for details. I've been using it myself while rr.com is under
a UDP. Please consider it.]

--
Keith Thompson (The_Other_Keit h) <ks***@mib.or g>
Looking for software development work in the San Diego area.
"We must do something. This is something. Therefore, we must do this."
-- Antony Jay and Jonathan Lynn, "Yes Minister"

[Joe Wright]

Keith Thompson wrote:

CBFalconer <cb********@yah oo.comwrites:

>Barry Schwarz wrote:

>>Tomás Ó hÉilidhe <to*@lavabit.co mwrote:
rocco.ross i:
I've been trying to write a function capable of checking if a
pointer value is set to NULL, and if it isn't, of deallocating
and setting it's value to NULL regardless of the pointer's type.
I thought "void ** " should do the trick, but I kept getting the
following warning message from gcc:
void DeallocateAndNu llify(void **const pp) {
free (*pp);
*pp = 0;
}
How would I pass an int* (or its address) to this function and
avoid the undefined behavior when sizeof(void*) != sizeof(int*)?

....
int *p;
....
DeallocAndNulli fy(&p);

[...]

Nope. &p is of type int**; the parameter is of type void**. There is
no implicit conversion from int** to void**.

But int* and void* are compatible.(?) Therefore..
DeallocAndNulli fy((void*)&p);
...should work.

--
Joe Wright
"Everything should be made as simple as possible, but not simpler."
--- Albert Einstein ---

[santosh]

Joe Wright wrote:

Keith Thompson wrote:

>CBFalconer <cb********@yah oo.comwrites:

>>Barry Schwarz wrote:
Tomás � h�ilidhe <to*@lavabit.co mwrote:
rocco.rossi :
>I've been trying to write a function capable of checking if a
>pointer value is set to NULL, and if it isn't, of deallocating
>and setting it's value to NULL regardless of the pointer's type.
>I thought "void ** " should do the trick, but I kept getting the
>followin g warning message from gcc:
void DeallocateAndNu llify(void **const pp) {
free (*pp);
*pp = 0;
}
How would I pass an int* (or its address) to this function and
avoid the undefined behavior when sizeof(void*) != sizeof(int*)?
....
int *p;
....
DeallocAndNulli fy(&p);

[...]

Nope. &p is of type int**; the parameter is of type void**. There
is no implicit conversion from int** to void**.

But int* and void* are compatible.(?) Therefore..
DeallocAndNulli fy((void*)&p);
..should work.

Pass by value semantics mean that the functions becomes useless.

[=?UTF-8?q?Harald_van_D=C4=B3k?=]

On Sat, 01 Dec 2007 10:42:02 -0500, Joe Wright wrote:

But int* and void* are compatible.(?) Therefore..
DeallocAndNulli fy((void*)&p);
..should work.

int* and void* are not compatible any more than int and double are. There
are implicit conversions between the two, but portable code can't
reinterpret the bit pattern of one as the other.

[Flash Gordon]

Joe Wright wrote, On 01/12/07 15:42:

Keith Thompson wrote:

>CBFalconer <cb********@yah oo.comwrites:

>>Barry Schwarz wrote:
Tomás Ó hÉilidhe <to*@lavabit.co mwrote:
rocco.rossi :
>I've been trying to write a function capable of checking if a
>pointer value is set to NULL, and if it isn't, of deallocating
>and setting it's value to NULL regardless of the pointer's type.
>I thought "void ** " should do the trick, but I kept getting the
>followin g warning message from gcc:
void DeallocateAndNu llify(void **const pp) {
free (*pp);
*pp = 0;
}
How would I pass an int* (or its address) to this function and
avoid the undefined behavior when sizeof(void*) != sizeof(int*)?
....
int *p;
....
DeallocAndNulli fy(&p);

[...]

Nope. &p is of type int**; the parameter is of type void**. There is
no implicit conversion from int** to void**.

But int* and void* are compatible.(?)

There is an implicit conversion between them which is not quite the same
thing.

Therefore..
DeallocAndNulli fy((void*)&p);
..should work.

No, see the comp.lang.c FAQ question 4.9 and http://c-faq.com/
I'm surprised not of the regulars have posted this reference yet.
--
Flash Gordon

[James Kuyper]

Joe Wright wrote:
....

But int* and void* are compatible.(?)

What made you think that?

[CBFalconer]

Keith Thompson wrote:

CBFalconer <cb********@yah oo.comwrites:

.... snip ...

>>
....
int *p;
....
DeallocAndNulli fy(&p);

[...]

Nope. &p is of type int**; the parameter is of type void**.
There is no implicit conversion from int** to void**.

Also, your call is to DeallocAndNulli fy rather than
DeallocateAndNu llify. (Perhaps you tried compiling your code, and
the misspelling caused the compiler not to know what the function
expects.)

Consider the following test (marked as quotation for linewrap):

[1] c:\c\junk>cat junk.c
#include <stdio.h>
#include <stdlib.h>

void release(void* *p) {
puts("Was Alive");
free(*p);
*p = NULL;
} /* release */

/* ------------------- */

int main(void) {
int *ptr;

if (ptr = malloc(sizeof *ptr)) release(&ptr);
if (ptr) puts("Alive");
else puts("Dead");

return 0;
} /* main, fcopylns */

[1] c:\c\junk>cc junk.c
junk.c: In function `main':
junk.c:15: warning: suggest parentheses around assignment used as truth value
junk.c:15: warning: passing arg 1 of `release' from incompatible pointer type

[1] c:\c\junk>a
Was Alive
Dead

Now I maintain the error is really a chimera. In release the void*
is never dereferenced, but is simply passed to free (which knows
what to do with it) and is set to NULL before exiting. The
parameter is simply a pointer to a void*.

Of course it would not do to ignore the error in passing the
parameter without analyzing the use in release, and that is
probably excessive detail.

--
Chuck F (cbfalconer at maineline dot net)
<http://cbfalconer.home .att.net>
Try the download section.
--
Posted via a free Usenet account from http://www.teranews.com