Typecasting Pointers

[brian]

Quick question:

if I have a structure:

struct foo {

unsigned char *packet;
unsigned char *ip_src;
};

and another structure:

struct foo2 {

unsigned char *packet;
};

and I do:

struct foo *a;
struct foo2 *b;

a = malloc(sizeof(s truct foo));
if (a == NULL)
return NULL;

(void)memset(a, 1, sizeof(struct foo));

b = (struct foo2 *)a;

--

Would foo2 just strip off the *packet?

And what happens to *ip?

I am trying to understand how C handles the typecast if
one structure pointed to has a different number of members
than the other. I am trying to understand how C99 treats
this situation. Both of my pointers should be correctly
aligned.

Thanks,

Brian

[brian]

Barry Schwarz wrote:

[snip]

(void)memse t(a, 1, sizeof(struct foo));
This should be to 0 or NULL. My mistake.

Not really. NULL would not portable because some systems define NULL
to be (void*)0. 0 is not portable either since their is no guarantee
that a pointer value of all bits 0 has any meaning.

Then, what is the best way to initialize the structure? Should I even
bother? Now, I'm really stuck on this piece.

[snip]
There is only one address, the one returned by malloc. The fact that
you have stored this address in two different pointers doesn't change
that.
Awesome. I just wanted to confirm this to be true with that cast. I
wasn't sure after reading the standard.

[snip]

And I cannot dereference portably because the alignment restrictions
could be different?

Yup.

That stinks. I designed my program to have a structure in my header
file, and I used functions prototypes like

int somefunc(struct foo **);

to pass the structure around the program after allocating space for it.
Is there a portable way to pass variable values around a program?

Brian

[Barry Schwarz]

On Thu, 25 Nov 2004 11:52:04 -0700, brian <tw*****@cox.ne t> wrote:

Barry Schwarz wrote:

[snip]

>(void)mems et(a, 1, sizeof(struct foo));

This should be to 0 or NULL. My mistake.

Not really. NULL would not portable because some systems define NULL
to be (void*)0. 0 is not portable either since their is no guarantee
that a pointer value of all bits 0 has any meaning.

Then, what is the best way to initialize the structure? Should I even
bother? Now, I'm really stuck on this piece.

If you define the structure, you can initialize it as part of the
definition:
struct foo a = {0};
This will cause each member of the struct to be set to the appropriate
zero value ('\0' for char, 0 for integers, 0.0 floating points, and
NULL for pointers.

If you allocate the struct, as was done up-thread, then you don't have
much choice but to do it member by member. However, if you have a
defined struct that was initialized, you can initialize the allocated
one by a simple assignment:
struct foo *b = malloc(sizeof *b);
b = a;

[snip]

There is only one address, the one returned by malloc. The fact that
you have stored this address in two different pointers doesn't change
that.
Awesome. I just wanted to confirm this to be true with that cast. I
wasn't sure after reading the standard.

[snip]

And I cannot dereference portably because the alignment restrictions
could be different?

Yup.

That stinks. I designed my program to have a structure in my header
file, and I used functions prototypes like

A header file should have only the struct declaration, not any
definition.

int somefunc(struct foo **);

to pass the structure around the program after allocating space for it.
Why would you use a pointer to pointer to struct when a simple pointer
to struct will let the function update the members at will? The
struct ** makes sense if the function will allocate the struct so it
can update the pointer directly but your comment says the struct is
already allocated.
Is there a portable way to pass variable values around a program?

Function arguments seem to work for most cases.

WHY do you want the address of a struct foo to be treated as the
address of a struct foo2? You might want to consider embedding both
structs in a union.
<<Remove the del for email>>

[Barry Schwarz]

On Fri, 26 Nov 2004 23:06:37 -0800, Barry Schwarz <sc******@deloz .net>
wrote:

On Thu, 25 Nov 2004 11:52:04 -0700, brian <tw*****@cox.ne t> wrote:

Barry Schwarz wrote:

[snip]

>>(void)mem set(a, 1, sizeof(struct foo));

This should be to 0 or NULL. My mistake.
Not really. NULL would not portable because some systems define NULL
to be (void*)0. 0 is not portable either since their is no guarantee
that a pointer value of all bits 0 has any meaning.

Then, what is the best way to initialize the structure? Should I even
bother? Now, I'm really stuck on this piece.

If you define the structure, you can initialize it as part of the
definition:
struct foo a = {0};
This will cause each member of the struct to be set to the appropriate
zero value ('\0' for char, 0 for integers, 0.0 floating points, and
NULL for pointers.

If you allocate the struct, as was done up-thread, then you don't have
much choice but to do it member by member. However, if you have a
defined struct that was initialized, you can initialize the allocated
one by a simple assignment:
struct foo *b = malloc(sizeof *b);
b = a;

That should be *b = a;
<<Remove the del for email>>

[Michael Wojcik]

In article <tZwpd.95065$SW 3.12565@fed1rea d01>, brian <tw*****@cox.ne t> writes:

Barry Schwarz wrote:

[brian wrote:]

>(void)memse t(a, 1, sizeof(struct foo));

This should be to 0 or NULL. My mistake.

Not really. NULL would not portable because some systems define NULL
to be (void*)0. 0 is not portable either since their is no guarantee
that a pointer value of all bits 0 has any meaning.

Then, what is the best way to initialize the structure? Should I even
bother? Now, I'm really stuck on this piece.

There are various alternatives, but I prefer structure assignment with
a static const initializer:

#include <stdlib.h>

static struct foo *alloc_foo(void )
{
static const struct foo foo0 = {0};
struct foo *newfoo = malloc(sizeof *newfoo);

if (newfoo)
*newfoo = foo0;

return newfoo;
}

The {0} is actually unnecessary, since static variables without an
explicit initializer are implicitly initialized to {0}, but I prefer
to make it explicit.

If multiple functions in a file need the initializer, put it at file
scope. If functions in multiple files need the initializer, you
could make it non-static, with an extern declaration in the header
that defines struct foo, but that raises issues of constraints on
and collisions of externally-visible names, so in some cases it may
be better simply to define one initializer per file (or refactor so
that only one file ever initializes dynamically-allocated variables
of that type - often the best choice).

By the way, returning to the question of Usenet signatures: your
messages should include a proper signature delimiter (a line
containing only two hyphens and a space) before your signature,
even if it only includes your name.

--
Michael Wojcik mi************@ microfocus.com

Is it any wonder the world's gone insane, with information come to be
the only real medium of exchange? -- Thomas Pynchon