offsetof

[Alejo]

Hello,

My implementation does not define offsetof, so I have designed a little
program that 'attempts' to find the relative position of a member in its
structure. It just does not work.

Could I get some pointers on what I am doing wrong (apart from being coding
so late at night).

#include <stdlib.h>
#include <stdio.h>

int main( void )
{
struct new
{
int a;
char b;
char c;
} x;

size_t num;

num = (size_t)((struc t new *)&x.c - &x);

printf( "%u\n", num );

return EXIT_SUCCESS;
}

It always returns 0.

Thanks.

--

Alejo

[Robert W Hand]

On Tue, 15 Jul 2003 09:32:32 -0400 (EDT), "Arthur J. O'Dwyer"
<aj*@andrew.cmu .edu> wrote:

I thought offsetof() was new in C99. Am I mistaken?

It is in my copy of ANSI/ISO 9899-1990, copyright 1990. It is defined
in stddef.h.

Best wishes,

Bob

[Jack Klein]

On Tue, 15 Jul 2003 16:27:38 +0200, Shill <no****@example .com> wrote
in comp.lang.c:

My implementation does not define offsetof [...]

#define offsetof(type,m emb) ((size_t)&((typ e *)0)->memb)

Undefined behavior, dereferencing a null pointer.

The proper solution is to get a real C compiler.

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

[Dan Pop]

In <eh************ *************** *****@4ax.com> Jack Klein <ja*******@spam cop.net> writes:

On Tue, 15 Jul 2003 16:27:38 +0200, Shill <no****@example .com> wrote
in comp.lang.c:

> My implementation does not define offsetof [...]

#define offsetof(type,m emb) ((size_t)&((typ e *)0)->memb)

Undefined behavior, dereferencing a null pointer.

The proper solution is to get a real C compiler.

All the real C compilers I have ever used define offsetof in a similar
way. There is nothing preventing a C compiler from making undefined
behaviour work.

Dan
--
Dan Pop
DESY Zeuthen, RZ group
Email: Da*****@ifh.de

[Sven Gohlke,,,]

Jack Klein wrote:

On Tue, 15 Jul 2003 16:27:38 +0200, Shill <no****@example .com> wrote
in comp.lang.c:

> My implementation does not define offsetof [...]
#define offsetof(type,m emb) ((size_t)&((typ e *)0)->memb)

Undefined behavior, dereferencing a null pointer.

Thats the way most libraries implement offsetof, it works because it is a
constant expression which will be calculated at compile time. Of cause, a
more logical way would be

#define offsetof(type,m emb) ((char *)&((type *)0)->memb-(char *) 0)

because offsetof should returm an offset_t not a size_t (but that violates
the standard).
The proper solution is to get a real C compiler.

An ANSI-C compiler should be sufficient, offsetof is part of the standard
library.
--
Best Regards
Sven

[Joona I Palaste]

Sven Gohlke,,, <sv**@clio.in-berlin.de> scribbled the following:

Jack Klein wrote:

On Tue, 15 Jul 2003 16:27:38 +0200, Shill <no****@example .com> wrote
in comp.lang.c:

> My implementation does not define offsetof [...]

#define offsetof(type,m emb) ((size_t)&((typ e *)0)->memb)
Undefined behavior, dereferencing a null pointer. Thats the way most libraries implement offsetof, it works because it is a
constant expression which will be calculated at compile time. Of cause, a
more logical way would be #define offsetof(type,m emb) ((char *)&((type *)0)->memb-(char *) 0) because offsetof should returm an offset_t not a size_t (but that violates
the standard).
I think you're missing something here. The ANSI C standard does not
specify that the expression &((type *)0)->memb should be calculated all
at compile time. The people who wrote those libraries are usually the
same ones who wrote the compilers, so they can benefit from the
knowledge that on *THEIR* compiler, it's evaluated all at compile time,
so it's safe. But this doesn't imply that it would be safe on any other
compiler.
The proper solution is to get a real C compiler.

An ANSI-C compiler should be sufficient, offsetof is part of the standard
library.

The behaviour of offsetof is standard, but any particular implementation
of it is not. Jack Klein's point was that any ANSI C compiler is
required to provide *an* implementation of offsetof, but there is no
particular implementation of offsetof that the compilers would be
required to choose.
In other words: Leave offsetof for the library to implement. If you try
implementing it yourself, you'll run into undefined behaviour.

--
/-- Joona Palaste (pa*****@cc.hel sinki.fi) ---------------------------\
| Kingpriest of "The Flying Lemon Tree" G++ FR FW+ M- #108 D+ ADA N+++|
| http://www.helsinki.fi/~palaste W++ B OP+ |
\----------------------------------------- Finland rules! ------------/
"I will never display my bum in public again."
- Homer Simpson

[Jack Klein]

On 16 Jul 2003 10:07:16 GMT, Da*****@cern.ch (Dan Pop) wrote in
comp.lang.c:

In <eh************ *************** *****@4ax.com> Jack Klein <ja*******@spam cop.net> writes:

On Tue, 15 Jul 2003 16:27:38 +0200, Shill <no****@example .com> wrote
in comp.lang.c:

> My implementation does not define offsetof [...]

#define offsetof(type,m emb) ((size_t)&((typ e *)0)->memb)

Undefined behavior, dereferencing a null pointer.

The proper solution is to get a real C compiler.

All the real C compilers I have ever used define offsetof in a similar
way. There is nothing preventing a C compiler from making undefined
behaviour work.

Dan

Of course not, in many instances a compiler is required to make
undefined behavior work. For example, how fopen() actually
establishes a connection to some type of physical device is undefined,
but a compiler makes it work.

One can't implement the entire standard C library without doing some
things that are undefined according to the standard. The
implementation and its library are not bound by the same constraints
as conforming programs.

The point is the OP says his compiler lacks a definition of the
offsetof() macro. Even free-standing implementations , which are not
required to provide even one single standard library function, are
required to provide the offsetof() and other macros in stddef.h, among
other things.

So either the OP is mistaken, or whatever it is he is using is not a C
compiler, in which case he's off-topic here.

The C language does not define an implementation that does not provide
a workable offsetof() macro in stddef.h.

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

[Dan Pop]

In <k4************ *************** *****@4ax.com> Jack Klein <ja*******@spam cop.net> writes:

The point is the OP says his compiler lacks a definition of the
offsetof() macro. Even free-standing implementations , which are not
required to provide even one single standard library function, are
required to provide the offsetof() and other macros in stddef.h, among
other things.

So either the OP is mistaken, or whatever it is he is using is not a C
compiler, in which case he's off-topic here.
If we adopt a rigid black and white position, then there is probably no C
compiler out there, they're complex enough programs to have bugs of one
kind of another.

Furthermore, this group is still dealing with pre-ANSI C issues and no
pre-ANSI C compiler can even hope to qualify as a conforming C compiler.
The C language does not define an implementation that does not provide
a workable offsetof() macro in stddef.h.

This doesn't prevent the existence of implementations that don't do that.
Either because they predate the C standard or because they did not
attempt to be conforming implementations (for one reason or another).

Therefore, questions about how to implement the functionality of offsetof
are topical in this newsgroup, even if the most portable solution invokes
undefined behaviour.

But I still suspect that the OP simply failed to include <stddef.h> and
expected offsetof to be available as some kind of compiler or preprocessor
built-in functionality.

Dan
--
Dan Pop
DESY Zeuthen, RZ group
Email: Da*****@ifh.de

[Emmanuel Delahaye]

In 'comp.lang.c', "Arthur J. O'Dwyer" <aj*@andrew.cmu .edu> wrote:

I thought offsetof() was new in C99. Am I mistaken?

Yes. It came with C90 in <stddef.h>

--
-ed- em**********@no os.fr [remove YOURBRA before answering me]
The C-language FAQ: http://www.eskimo.com/~scs/C-faq/top.html
<blank line>
FAQ de f.c.l.c : http://www.isty-info.uvsq.fr/~rumeau/fclc/

[Dan Pop]

In <Xn************ *************** @130.133.1.4> Emmanuel Delahaye <em**********@n oos.fr> writes:

In 'comp.lang.c', "Arthur J. O'Dwyer" <aj*@andrew.cmu .edu> wrote:

I thought offsetof() was new in C99. Am I mistaken?

Yes. It came with C90 in <stddef.h>

Nope, it came with C89.

Dan
--
Dan Pop
DESY Zeuthen, RZ group
Email: Da*****@ifh.de

[Shill]

>> Yes. It came with C90 in <stddef.h>

Nope, it came with C89.

http://gcc.gnu.org/onlinedocs/gcc-3....Standards.html

The original ANSI C standard (X3.159-1989) was ratified
in 1989 and published in 1990. This standard was ratified
as an ISO standard (ISO/IEC 9899:1990) later in 1990.
There were no technical differences between these
publications, although the sections of the ANSI standard
were renumbered and became clauses in the ISO standard.
This standard, in both its forms, is commonly known as C89,
or occasionally as C90, from the dates of ratification.

C89 and C90 are synonymous.