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.

[CBFalconer]

Keith Thompson wrote:

>

.... snip ...

>
[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.]

The problem is the associated nonsense. I plan to eventually
upgrade the newsreader. When I do I will be faced with that
nonsense, and one more piece won't cause much fuss. Who know,
maybe my ISP will start to function again! Meanwhile, I am VERY
lazy.

--
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

[santosh]

CBFalconer wrote:

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
DeallocateAndN ullify. (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);

Maybe:

if (ptr = malloc(sizeof *ptr)) release( &((void *)ptr) );

<snip>

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

On Sun, 02 Dec 2007 00:27:21 +0530, santosh wrote:

CBFalconer wrote:

>> if (ptr = malloc(sizeof *ptr)) release(&ptr);

Maybe:

if (ptr = malloc(sizeof *ptr)) release( &((void *)ptr) );

That won't compile. ((void *)ptr) is not an lvalue; you cannot take its
address.

[santosh]

Harald van D?k wrote:

On Sun, 02 Dec 2007 00:27:21 +0530, santosh wrote:

>CBFalconer wrote:

>>> if (ptr = malloc(sizeof *ptr)) release(&ptr);

Maybe:

if (ptr = malloc(sizeof *ptr)) release( &((void *)ptr) );

That won't compile. ((void *)ptr) is not an lvalue; you cannot take
its address.

Ah yes. Sorry about that.

[James Kuyper]

CBFalconer wrote:

Keith Thompson wrote:

....

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*.

The argument was a pointer to an int*, which means that even with a
suitable cast to silent the warning, *p==NULL has undefined behavior.

[Joe Wright]

James Kuyper wrote:

Joe Wright wrote:
...

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

What made you think that?

Given..

int *ip;

We can do 'ip = malloc(sizeof *ip);

And now,

void *vp = ip;

...is valid. Why do you think not?

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

[James Kuyper]

Joe Wright wrote:

James Kuyper wrote:

>Joe Wright wrote:
...

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

What made you think that?

Given..

int *ip;

We can do 'ip = malloc(sizeof *ip);

And now,

void *vp = ip;

..is valid. Why do you think not?

What you've just demonstrated is implicit conversion. Many types are
implicitly convertible to other types; section 6.3 is devoted to
describing the many ways in which this can happen. For instance, signed
char is implicitly convertible to long double _Complex. that doesn't
make them compatible.

The term "compatible types" is defined by the C standard in section
6.2.7, with cross-references to several other sections. Follow all of
those cross-references, and you won't find anything that makes "int*"
compatible with "void*".

There are only a few situations where you can access an object using an
lvalue of a one type, if the effective type of the actual object is
different. They are listed in 6.5p7, and the first one is if the lvalue
has " a type compatible with the effective type of the object". Because
int* is not compatible with void*, that case doesn't apply to this code.
Neither do any of the other cases listed in 6.5p7. Therefore, the
behavior of the program is undefined.

It might work as expected, that's one of the possibilities allowed when
the behavior of a program is undefined. On many implementations all
pointers have the same size, alignment, and representation, and on such
implementations this code could work. However, real implementations of C
have different representations for pointers to different types, and even
different sizes. This code will break on any such implementation.

[Keith Thompson]

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

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*.

No, the error is a real error.

release() expects an argument of type void**. You give it an argument
of type int**. There is no implicit conversion from int** to void**,
so this is a constraint violation; the compiler is free to reject your
code on that basis, but it chooses instead to issue a warning and
(presumably) generate an implicit conversion anyway.

The language makes certain guarantees about the semantics of
conversions to and from void* (this is separate from the fact that
such conversions can be done implicitly). It makes no such guarantees
about conversions to or from void**, which is just another pointer
type. The conversion from int** to void** (a) is not specified by the
language, and (b) could conceivably lose information.

Now it's not likely that an implementation will actually use different
representations and/or argument passing mechanisms for void** vs.
int**, but it is entirely possible that an implementation could just
reject your code.

[...]

--
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"