NULL pointer and zero value

[vp]

If I have a pointer char * p, is it correct to assign NULL to this
pointer by:

"memset( &p, 0, sizeof(p));" instead of "p = NULL;"

The reason I ask is I have an array of structure of N function
variables, for example,

typedef struct
{
int (* func1)();
int (* func2)();
void * (* func2)(int );
} ModuleFunctions ;

#define N 100
ModuleFunction garMF[N];

When initializing, instead of making a loop to assgin NULL to each
function member of struct ModuleFunction for each member of array, is
it correct to do something like

memset( garMF, 0, sizeof(ModuleFu nctions)*N );
Thanks for your help,

DT

[Mark A. Odell]

Martin Dickopp <ex************ ****@zero-based.org> wrote in
news:bs******** *****@news.t-online.com:

So are you saying that this isn't safe?

#include <stdlib.h>

int main(void)
{
int *pVar = malloc(1024);

if (pVar) /* <--- Not safe? */
{
free(pVar);
}

return EXIT_SUCCESS;
}

The program is correct (i.e. strictly conforming). The `if' statement
doesn't look at the representation (i.e. the bits) of `pVar', it simply
compares `pVar' to `0'. A comparison between an expression of pointer
type and `0', which is a null pointer constant in such a comparison, is
valid.

Excellent. Thank you.

--
- Mark ->
--

[vp]

dt*******@yahoo .com (vp) wrote in message news:<24******* *************** ****@posting.go ogle.com>...

If I have a pointer char * p, is it correct to assign NULL to this
pointer by:

"memset( &p, 0, sizeof(p));" instead of "p = NULL;"

[...]

Thanks for all of your replies and explanation. I see that I just can
not be lazy to make that memset. I don't want to put Las Vegas into my
app :-)

DT

[vp]

"Mark A. Odell" <no****@embedde dfw.com> wrote in message news:<Xn******* *************** **********@130. 133.1.4>...

Richard Heathfield <in*****@addres s.co.uk.invalid > wrote in
news:3f******@n ews2.power.net. uk:

No. NULL is not necessarily all-bits-zero.

Your technique will, however, work by chance on quite a few platforms,
because quite a few platforms do use all-bits-zero for NULL. If you like
programming-by-casino, go ahead. :-)

So are you saying that this isn't safe?

#include <stdlib.h>

int main(void)
{
int *pVar = malloc(1024);

if (pVar) /* <--- Not safe? */
{
free(pVar);
}

return EXIT_SUCCESS;
}

I guess the compiler will do the necessary comparison in this case. I
often see this style of code "if ( pointer )", but personally I often
write it like "if ( p != NULL )" just to remind me or my co-workers
that p is of pointer-type.

DT

[Mark A. Odell]

dt*******@yahoo .com (vp) wrote in
news:24******** *************** ***@posting.goo gle.com:

if (pVar) /* <--- Not safe? */
{
free(pVar);
}

return EXIT_SUCCESS;
}

I guess the compiler will do the necessary comparison in this case. I
often see this style of code "if ( pointer )", but personally I often
write it like "if ( p != NULL )" just to remind me or my co-workers
that p is of pointer-type.

I avoid explicit checks for boolean conditions and since all my pointer
vars have a lower-case p in front, e.g. pSomeName, this is never an issue
for me. Besides, if I want to know if 'foo' is a pointer then I just hover
over it with my mouse and CodeWright shows me the definition. I thought
all editors could do such simple things. ;-)

--
- Mark ->
--

[Keith Thompson]

dt*******@yahoo .com (vp) writes:

If I have a pointer char * p, is it correct to assign NULL to this
pointer by:

"memset( &p, 0, sizeof(p));" instead of "p = NULL;"

No.

The C FAQ is at <http://www.eskimo.com/~scs/C-faq/top.html>.
Read section 5, "Null Pointers".

--
Keith Thompson (The_Other_Keit h) ks***@mib.org <http://www.ghoti.net/~kst>
San Diego Supercomputer Center <*> <http://www.sdsc.edu/~kst>
Schroedinger does Shakespeare: "To be *and* not to be"
(Note new e-mail address)

[Jack Klein]

On Tue, 30 Dec 2003 14:07:21 GMT, pete <pf*****@mindsp ring.com> wrote
in comp.lang.c:

Martin Dickopp wrote:

dt*******@yahoo .com (vp) writes:

If I have a pointer char * p, is it correct to assign NULL to this
pointer by:

"memset( &p, 0, sizeof(p));" instead of "p = NULL;"

No. The former statement sets all bits of `p' to zero, which is not
necessarily a representation of the null pointer.

The reason I ask is I have an array of structure of N function
variables, for example,

typedef struct
{
int (* func1)();
int (* func2)();
void * (* func2)(int );
} ModuleFunctions ;

#define N 100
ModuleFunction garMF[N];

When initializing, instead of making a loop to assgin NULL to each
function member of struct ModuleFunction
for each member of array, is it correct to do something like

memset( garMF, 0, sizeof(ModuleFu nctions)*N );

Otherwise (if `garMF' doesn't have static storage duration)
you'll have to loop.

I disagree about the necessity of a loop.

ModuleFunction garMF[N] = {NULL};

I would much prefer {0} to {NULL} here.

--
Jack Klein
Home: http://JK-Technology.Com
FAQs for
comp.lang.c http://www.eskimo.com/~scs/C-faq/top.html
comp.lang.c++ http://www.parashift.com/c++-faq-lite/
alt.comp.lang.l earn.c-c++ ftp://snurse-l.org/pub/acllc-c++/faq

[Kevin Goodsell]

Mark A. Odell wrote:

So are you saying that this isn't safe?

#include <stdlib.h>

int main(void)
{
int *pVar = malloc(1024);

if (pVar) /* <--- Not safe? */
{
free(pVar);
}

return EXIT_SUCCESS;
}

Answers already given, but I wanted to mention that this is also valid:

int *p = 0;

regardless of the object-representation of the null pointer value. This
is somewhat obvious, because even on systems where the null-pointer
value is not represented by all-bits-zero, NULL must still be defined as
a constant expression with the value 0, possibly cast to void*, so this:

int *p = NULL;

is translated by the preprocessor to something equivalent to one of the
following:

int *p = 0;

or

int *p = (void *)0;

It follows somewhat logically that things like these:

if (p)
if (p == 0)

are actually testing p against the null pointer value, whatever its
representation is.

-Kevin
--
My email address is valid, but changes periodically.
To contact me please use the address from a recent posting.

[Kevin Goodsell]

Jack Klein wrote:

On Tue, 30 Dec 2003 14:07:21 GMT, pete <pf*****@mindsp ring.com> wrote
in comp.lang.c:

ModuleFunctio n garMF[N] = {NULL};

I would much prefer {0} to {NULL} here.

Is {NULL} even correct here if NULL happens to be #defined with a cast
to void*?

-Kevin
--
My email address is valid, but changes periodically.
To contact me please use the address from a recent posting.

[Peter Nilsson]

"Kevin Goodsell" <us************ *********@never box.com> wrote in message
news:ZA******** ***********@new sread1.news.pas .earthlink.net. ..

Jack Klein wrote:

On Tue, 30 Dec 2003 14:07:21 GMT, pete <pf*****@mindsp ring.com> wrote
in comp.lang.c:

ModuleFunctio n garMF[N] = {NULL};

I would much prefer {0} to {NULL} here.

Is {NULL} even correct here if NULL happens to be #defined with a cast
to void*?

Yes. Since NULL is a null pointer constant.

6.3.2.3p4: "Conversion of a null pointer to another pointer type yields a
null pointer of that type. ...". [There is no limitation with respect to
function pointers in this regard.]

6.7.8p11 Initialization: "...the same type constraints and conversions as
for simple assignment apply,..."

6.5.16.1p1 Simple Assignment - Constraints: "... - the left operand is a
pointer and the right is a null pointer constant; ..."

6.5.16.1p2 Simple Assignment - Semantics: "In simple assignment (=), the
value of the right operand is converted to the type of the assignment
expression and replaces the value stored in the object designated by the
left operand."

I think Jack prefers {0} because it's a more consistent (and well
understood) paradigm in general.

--
Peter

[pete]

Jack Klein wrote:

On Tue, 30 Dec 2003 14:07:21 GMT,
pete <pf*****@mindsp ring.com wrote in comp.lang.c:

> typedef struct
> {
> int (* func1)();
> int (* func2)();
> void * (* func2)(int );
> } ModuleFunctions ;
>
> #define N 100
> ModuleFunction garMF[N];

ModuleFunction garMF[N] = {NULL};

I would much prefer {0} to {NULL} here.

All of the members of all of the elements of the array
will be initialized to NULL. Why do you like {0} better ?

--
pete