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

[Jack Klein]

On Wed, 31 Dec 2003 12:46:37 GMT, pete <pf*****@mindsp ring.com> wrote
in comp.lang.c:

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 ?

I should have elaborated. {0} works in all cases to initialize any
static or automatic scalar or aggregate type.

The C standard allows two definitions for the macro NULL. For
simplicity's sake, they are "0" and "(void *)0", or equivalent. My
experience is that most (but definitely not all) C compilers use the
cast to (void *) rather than the raw numeric constant.

In this case, since the first element of the structure has pointer
type, either definition of NULL will work. If the structure had a
non-pointer first member, it would be correct on implementations that
used a raw 0 for NULL, but be a constraint violation on those that
defined NULL as "(void *)0".

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

[Jack Klein]

On Tue, 30 Dec 2003 22:01:29 GMT, Kevin Goodsell
<us************ *********@never box.com> wrote in comp.lang.c:

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

I should have elaborated. {0} works in all cases to initialize any
static or automatic scalar or aggregate type.

The C standard allows two definitions for the macro NULL. For
simplicity's sake, they are "0" and "(void *)0", or equivalent. My
experience is that most (but definitely not all) C compilers use the
cast to (void *) rather than the raw numeric constant.

In this case, since the first element of the structure has pointer
type, either definition of NULL will work. If the structure had a
non-pointer first member, it would be correct on implementations that
used a raw 0 for NULL, but be a constraint violation on those that
defined NULL as "(void *)0".

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

[stau]

On Wed, 31 Dec 2003 15:37:42 +1100, Peter Nilsson wrote:

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

No, he explained why,and it makes logic.

[Peter Nilsson]

"stau" <st**@pretogal. pt> wrote in message
news:pa******** *************** *****@pretogal. pt...

On Wed, 31 Dec 2003 15:37:42 +1100, Peter Nilsson wrote:

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

No, he explained why,and it makes logic.

How is "{0} works in all cases..." significantly different to what I said?
It's more succinct and better phrased, I grant you, but I don't see how my
sentence runs contrary to it.

P.S. Jack's replies were not available on my news server at the time I made
the post.

--
Peter

[pete]

Jack Klein wrote:

On Wed, 31 Dec 2003 12:46:37 GMT, pete <pf*****@mindsp ring.com> wrote
in comp.lang.c:

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 ?

I should have elaborated. {0} works in all cases to initialize any
static or automatic scalar or aggregate type.

What you said, could also be used to explain a preference for
char *pointer = 0;
over
char *pointer = NULL;

Is that your preference also ?

--
pete

[Peter Pichler]

"pete" <pf*****@mindsp ring.com> wrote...

Jack Klein wrote:

I should have elaborated. {0} works in all cases to initialize any
static or automatic scalar or aggregate type.
What you said, could also be used to explain a preference for
char *pointer = 0;
over
char *pointer = NULL;

Not quite. Since a void* is implicitly converted to any type*, the two
examples are exactly equivalent regardless of any of the two standard
definitions of NULL.
Is that your preference also ?

My preference is the latter, but it is only a style issue, nothing else.

[pete]

Peter Pichler wrote:

"pete" <pf*****@mindsp ring.com> wrote...

Jack Klein wrote:

I should have elaborated.
{0} works in all cases to initialize any
static or automatic scalar or aggregate type.

What you said, could also be used to explain a preference for
char *pointer = 0;
over
char *pointer = NULL;

Not quite.
Since a void* is implicitly converted to any type*, the two
examples are exactly equivalent regardless of any of the two standard
definitions of NULL.

Exactly quite.

ModuleFunction garMF[N] = {NULL};
and
ModuleFunction garMF[N] = {0};

are exactly equivalent regardless of any of the two standard
definitions of NULL.

Is that your preference also ?

My preference is the latter,
but it is only a style issue, nothing else.

Style issues are on topic.
Reasons for prefering one style over another
which involve legibility and maintainability ,
are the more interesting ones.

--
pete

[Peter Pichler]

"pete" <pf*****@mindsp ring.com> wrote...

Jack Klein wrote:

I should have elaborated. {0} works in all cases to initialize any
static or automatic scalar or aggregate type.
What you said, could also be used to explain a preference for
char *pointer = 0;
over
char *pointer = NULL;

Not quite. Since a void* is implicitly converted to any type*, the two
examples are exactly equivalent regardless of any of the two standard
definitions of NULL.
Is that your preference also ?

My preference is the latter, but it is only a style issue, nothing else.

[Peter Pichler]

"pete" <pf*****@mindsp ring.com> wrote...

Jack Klein wrote:

I should have elaborated. {0} works in all cases to initialize any
static or automatic scalar or aggregate type.
What you said, could also be used to explain a preference for
char *pointer = 0;
over
char *pointer = NULL;

Not quite. Since a void* is implicitly converted to any type*, the two
examples are exactly equivalent regardless of any of the two standard
definitions of NULL.
Is that your preference also ?

My preference is the latter, but it is only a style issue, nothing else.

[Peter Pichler]

"pete" <pf*****@mindsp ring.com> wrote...

Peter Pichler wrote:

"pete" <pf*****@mindsp ring.com> wrote...

Jack Klein wrote:

What you said, could also be used to explain a preference for
char *pointer = 0;
over
char *pointer = NULL;

Not quite.
Since a void* is implicitly converted to any type*, the two
examples are exactly equivalent regardless of any of the two standard
definitions of NULL.

Exactly quite.
ModuleFunction garMF[N] = {NULL};
and
ModuleFunction garMF[N] = {0};
are exactly equivalent regardless of any of the two standard
definitions of NULL.

Only if garMF[N] is a pointer.

If I remember correctly, the thread started with explicit initialization
of struct members with memset, {NULL} or {0}. Of those three, memset can
only be portably used if the struct is a wrapper for an usigned char array,
anything else may lead to a UB. {NULL} can only be used if the first member
of such struct is a pointer. {0}, however, can be used in any context.

Is that your preference also ?

My preference is the latter,
but it is only a style issue, nothing else.

Style issues are on topic.
Reasons for prefering one style over another
which involve legibility and maintainability ,
are the more interesting ones.

I didn't say it was not on-topic. Whether or not it is a /good/ topic
is quite a different question though ;-)

Peter