offsetof( ) macro

[Kavya]

offsetof(T,m) (size_t)&(((T*) 0)->m)

Why do we always start from 0 in this macro to access the offset of
structure or union. Does standard guarantees that structure and union
reside at address 0? If yes, then what if I have two or more
structures. How can they reside at same address?.

[Clark S. Cox III]

Stuart Redmann wrote:

Pete Becker wrote:

>Stuart Redmann wrote:

>>>
A more platform-independent version of offsetof would be:
#define offsetof(T,m) (size_t)(&(((T* )0)->m) - &((T*)0))

Don't try and write platform-independent versions of standard library
hacks. One of the main reasons offsetof is in the standard library is
that it can't be written portably.

Note, too, that this version just doesn't work. It's ill-formed unless
m and T are related types, and even then, it gets the wrong answer.
You need to cast both pointers to some flavor of char*.

Yes, I'm sorry for overlooking this.

>By the time you've done that, it'll be pretty much unreadable.

Agreed. But it would be portable, wouldn't it?

No, it wouldn't. It dereferences a NULL pointer and is therefore undefined.
--
Clark S. Cox III
cl*******@gmail .com

[Fred Zwarts]

"Greg" <gr****@pacbell .netwrote in message news:11******** **************@ h48g2000cwc.goo glegroups.com.. .

Fred Zwarts wrote:

>The problem is that the standard library does not cover all cases.
It only handles compile time constant offsets.
In order to calculate run-time offsets one needs to use a macro.
Example:

struct T {
int I[10];
};

size_t F (int J) {
return offsetof (T,I[J]);
}

This does not compile with some compilers, because the offset
cannot be determined at compile time. In such a case one
needs to fall back to a macro. It might be undefined according to
the standard, but it turns out that it works on almost all platforms
and the standard offers no alternative.

But F() could be written so that it would return the correct offset on
all platforms:

size_t F( int j )
{
return offsetof(T, I) + j * sizeof( int );
}

Greg

Yes, for this simple example. But in more complex cases it would be nice if the
compiler did the arithmetic for the indices, in particular if this must be done many
times for different complex structures.