offsetof() macro

[Simon Morgan]

Hi,

Can somebody please help me grok the offsetof() macro?

I've found an explanation on
http://www.embedded.com/shared/print...cleID=18312031
but I'm afraid it still doesn't make sense to me.

The sticking point seems to be:

((s *)0) takes the integer zero and casts it as a pointer to s.

To my untrained eye that would basically result in a null pointer. Does
this expression result in some special behaviour or am I missing
something?

Thanks.

Simon

--
"Being a social outcast helps you stay concentrated on the really important
things, like thinking and hacking." - Eric S. Raymond

[Keith Thompson]

DevarajA <[e-mail]> writes:

Flash Gordon ha scritto:

DevarajA wrote:

Eric Laberge ha scritto:

<snip>

Both "NULL" and "offsetof" are defined in <stddef.h> (7.17 Common
de?nitions
<stddef.h>).

NULL is implementation-defined, but (6.3.2.3 Pointers) an integer
constant with value 0 is the same as NULL.

No, a constant expression in the *source* code used in a pointer
context is a null pointer constant. However, that has no bearing on
how a null pointer is represented in the program when it is run.

I suppose if, eg. the implementation decided that the value of NULL is
0x1234, then constant 0, when used as a pointer, would be equal to
0x1234.

No, NULL has to be and integer constant expression evaluating to 0
or such an expression cast to void*. However, if a null pointer is
not all bits 0 then the compiler will have to change it to whatever
representation is used for a null pointer when it compiles the code.

So, tell me if I have understood... null pointer constant needs not to
have an all-0 internal representation (it is implementation-defined),
but in the source code it must be represented as 0. And NULL macro
just expands into the null pointer constant, but I may also redefine
it. Am I right?

Close.

A "null pointer" and a "null pointer constant" are two different
things. A null pointer constant is a construct that can appear in C
source code. A null pointer is a pointer value that can occur during
execution time.

An integer constant 0 is a valid null pointer constant. If you assign
a null pointer constant to a pointer object, that object's value at
execution time will be a null pointer. The execution-time
representation of a null pointer may or may not be all-bits-zero. (If
a null pointer has a representation other than all-bits-zero, it's up
to the compiler to do whatever conversion might be necessary.)

The macro NULL expands to a null pointer constant. You cannot legally
redefine NULL yourself. Your compiler might let you get away with it,
but there's absolutely no reason to do so.

--
Keith Thompson (The_Other_Keit h) ks***@mib.org <http://www.ghoti.net/~kst>
San Diego Supercomputer Center <*> <http://users.sdsc.edu/~kst>
We must do something. This is something. Therefore, we must do this.

[Keith Thompson]

ro******@ibd.nr c-cnrc.gc.ca (Walter Roberson) writes:

In article <jY************ *********@news4 .tin.it>,
DevarajA <[e-mail]> wrote:

So, tell me if I have understood... null pointer constant needs not to
have an all-0 internal representation (it is implementation-defined),

Right.

but in the source code it must be represented as 0.

The standard does not preclude other source-code representations , but 0
is the only portable one.

(See my other followup for a discussion of the distinction between
"null pointer constants" and "null pointers".)

The standard defined a "null pointer constant" as

An integer constant expression with the value 0, or such an
expression cast to type void *.

So the following are all valid null pointer constants under any
possible conforming implementation:

0
(void*)0
(1-1)
(void*)('-'-'-')
(void*)('/'/'/'-'/'/'/')

All but the first two are considered silly, but they're no less valid
for that.

--
Keith Thompson (The_Other_Keit h) ks***@mib.org <http://www.ghoti.net/~kst>
San Diego Supercomputer Center <*> <http://users.sdsc.edu/~kst>
We must do something. This is something. Therefore, we must do this.

[Walter Roberson]

In article <ln************ @nuthaus.mib.or g>,
Keith Thompson <ks***@mib.or g> wrote:

So the following are all valid null pointer constants under any
possible conforming implementation: 0
(void*)0
(1-1)
(void*)('-'-'-')
(void*)('/'/'/'-'/'/'/')
That's sick!

I like it ;-)
All but the first two are considered silly, but they're no less valid
for that.

--
"Who Leads?" / "The men who must... driven men, compelled men."
"Freak men."
"You're all freaks, sir. But you always have been freaks.
Life is a freak. That's its hope and glory." -- Alfred Bester, TSMD

[DevarajA]

Keith Thompson ha scritto:

DevarajA <[e-mail]> writes:

Flash Gordon ha scritto:

DevarajA wrote:
Eric Laberge ha scritto:

<snip>

>Both "NULL" and "offsetof" are defined in <stddef.h> (7.17 Common
>de?nitio ns
><stddef.h> ).
>
>NULL is implementation-defined, but (6.3.2.3 Pointers) an integer
>constant with value 0 is the same as NULL.

No, a constant expression in the *source* code used in a pointer
context is a null pointer constant. However, that has no bearing on
how a null pointer is represented in the program when it is run.
>I suppose if, eg. the implementation decided that the value of NULL is
>0x1234, then constant 0, when used as a pointer, would be equal to
>0x1234.

No, NULL has to be and integer constant expression evaluating to 0
or such an expression cast to void*. However, if a null pointer is
not all bits 0 then the compiler will have to change it to whatever
representati on is used for a null pointer when it compiles the code.

So, tell me if I have understood... null pointer constant needs not to
have an all-0 internal representation (it is implementation-defined),
but in the source code it must be represented as 0. And NULL macro
just expands into the null pointer constant, but I may also redefine
it. Am I right?

Close.

A "null pointer" and a "null pointer constant" are two different
things. A null pointer constant is a construct that can appear in C
source code. A null pointer is a pointer value that can occur during
execution time.

An integer constant 0 is a valid null pointer constant. If you assign
a null pointer constant to a pointer object, that object's value at
execution time will be a null pointer. The execution-time
representation of a null pointer may or may not be all-bits-zero. (If
a null pointer has a representation other than all-bits-zero, it's up
to the compiler to do whatever conversion might be necessary.)

The macro NULL expands to a null pointer constant. You cannot legally
redefine NULL yourself. Your compiler might let you get away with it,
but there's absolutely no reason to do so.

Then using NULL is the same as using 0? So why in C many people use
NULL? Is that to avoid portability problems (in the case of a weird
non-standard implementation that has the null ptr const !=0)?

--
Devaraja (Xdevaraja87^gm ail^c0mX)
Linux Registerd User #338167
http://counter.li.org

[Keith Thompson]

DevarajA <[e-mail]> writes:

Keith Thompson ha scritto:

[...]

A "null pointer" and a "null pointer constant" are two different
things. A null pointer constant is a construct that can appear in
C source code. A null pointer is a pointer value that can occur
during execution time. An integer constant 0 is a valid null
pointer constant. If you assign a null pointer constant to a
pointer object, that object's value at execution time will be a
null pointer. The execution-time representation of a null pointer
may or may not be all-bits-zero. (If a null pointer has a
representation other than all-bits-zero, it's up to the compiler to
do whatever conversion might be necessary.) The macro NULL expands
to a null pointer constant. You cannot legally redefine NULL
yourself. Your compiler might let you get away with it, but
there's absolutely no reason to do so.

Then using NULL is the same as using 0? So why in C many people use
NULL? Is that to avoid portability problems (in the case of a weird
non-standard implementation that has the null ptr const !=0)?

The advantage of using NULL is documentation. It makes it obvious
that what's intended is a pointer value, not an integer value.

For example:

a = 0;
b = 0.0;
c = '\0';
d = NULL;

You can tell even without looking at the declarations (assuming a sane
programmer) that a is an integer, b is a floating-point variable, c is
a character, and d is a pointer.

There are those who advocate using 0 rather than the NULL macro as a
null pointer constant. They are, of course, wrong, since they
disagree with me.

(If I were designing the language from scratch, there would be a
keyword, either "nil" or "null", that would be the *only* null pointer
constant. Using 0 in a pointer context would be a constraint error.
The current confusing situation is, I think, a remnant of the early
days of C when it was assumed that a null pointer *was* all-bits-zero,
and even non-zero integer constants were commonly used as pointers.)

--
Keith Thompson (The_Other_Keit h) ks***@mib.org <http://www.ghoti.net/~kst>
San Diego Supercomputer Center <*> <http://users.sdsc.edu/~kst>
We must do something. This is something. Therefore, we must do this.

[DevarajA]

>

There are those who advocate using 0 rather than the NULL macro as a
null pointer constant. They are, of course, wrong, since they
disagree with me.

(If I were designing the language from scratch, there would be a
keyword, either "nil" or "null", that would be the *only* null pointer
constant. Using 0 in a pointer context would be a constraint error.

What do you mean by "using 0 in a pointer context"? In another post you
have said "An integer constant 0 is a valid null pointer constant. If
you assign a null pointer constant to a pointer object, that object's
value at execution time will be a null pointer."+"The macro NULL expands
to a null pointer constant." And now you say that using 0 is a
constraint error. I think I haven't understood yet :-(

And on every compiler I've tried, int *pt=0; works without errors or
warnigs. And also the standard says that a constant expression
evaluating to 0 or such an expression cast to void*, assigned to a
pointer of wathever type makes it a null pointer.

Sorry if I'm wasting your time, but I'm a bit confused...

--
Devaraja (Xdevaraja87^gm ail^c0mX)
Linux Registerd User #338167
http://counter.li.org

[Irrwahn Grausewitz]

DevarajA <[e-mail]> wrote:

[DevarajA: please preserve attribution lines, to make clear who wrote
what. Attribution restored.]

Keith Thompson wrote:

There are those who advocate using 0 rather than the NULL macro as a
null pointer constant. They are, of course, wrong, since they
disagree with me.
:-)
(If I were designing the language from scratch, there would be a
keyword, either "nil" or "null", that would be the *only* null pointer
constant. Using 0 in a pointer context would be a constraint error.

What do you mean by "using 0 in a pointer context"? In another post you
have said "An integer constant 0 is a valid null pointer constant. If
you assign a null pointer constant to a pointer object, that object's
value at execution time will be a null pointer."+"The macro NULL expands
to a null pointer constant." And now you say that using 0 is a
constraint error. I think I haven't understood yet :-(

Please read again: Keith _would_make_ using 0 in a pointer context a
constraint violation, _if_he_were_re-designing_the_l anguage_C_.

C-as-we-know-it: int *p = 0; /* correct, but bad style */
Keith's revamped C: int *p = 0; /* constraint violation */

(FWIW, I'd probably do the same.)

<snip>

Best regards
--
Irrwahn Grausewitz (ir*******@free net.de)
welcome to clc : http://www.ungerhu.com/jxh/clc.welcome.txt
clc faq-list : http://www.faqs.org/faqs/C-faq/faq/
clc frequent answers: http://benpfaff.org/writings/clc.

[DevarajA]

Irrwahn Grausewitz ha scritto:

DevarajA <[e-mail]> wrote:

[DevarajA: please preserve attribution lines, to make clear who wrote
what. Attribution restored.]

Keith Thompson wrote:

There are those who advocate using 0 rather than the NULL macro as a
null pointer constant. They are, of course, wrong, since they
disagree with me.

:-)

(If I were designing the language from scratch, there would be a
keyword, either "nil" or "null", that would be the *only* null pointer
constant. Using 0 in a pointer context would be a constraint error.
What do you mean by "using 0 in a pointer context"? In another post you
have said "An integer constant 0 is a valid null pointer constant. If
you assign a null pointer constant to a pointer object, that object's
value at execution time will be a null pointer."+"The macro NULL expands
to a null pointer constant." And now you say that using 0 is a
constraint error. I think I haven't understood yet :-(

Please read again: Keith _would_make_ using 0 in a pointer context a
constraint violation, _if_he_were_re-designing_the_l anguage_C_.

Ok, got it :-) thank you all.
C-as-we-know-it: int *p = 0; /* correct, but bad style */
Keith's revamped C: int *p = 0; /* constraint violation */

Another thing.. looking into stddef.h I've seen that for C, NULL it is
defined as ((void*)0). The standard specifies that plain 0 is already a
null pointer constant. So why that cast? Maybe this is the last stupid
question for today :-)

--
Devaraja (Xdevaraja87^gm ail^c0mX)
Linux Registerd User #338167
http://counter.li.org

[Keith Thompson]

DevarajA <[e-mail]> writes:

There are those who advocate using 0 rather than the NULL macro as a
null pointer constant. They are, of course, wrong, since they
disagree with me.
(If I were designing the language from scratch, there would be a
keyword, either "nil" or "null", that would be the *only* null pointer
constant. Using 0 in a pointer context would be a constraint error.

What do you mean by "using 0 in a pointer context"? In another post
you have said "An integer constant 0 is a valid null pointer
constant. If you assign a null pointer constant to a pointer object,
that object's value at execution time will be a null pointer."+"The
macro NULL expands to a null pointer constant." And now you say that
using 0 is a constraint error. I think I haven't understood yet :-(

Look again. I said that if I were designing the language from
scratch, using 0 in a pointer context would be a constraint error (I
meant "constraint violation"). In C as it actually exists, 0 is a
valid null pointer constant, so it *can* be used in a pointer context.

For example:

int *p;
p = 0;

This is perfectly legal C. As a matter of style and clarity, I
prefer:

int *p;
p = NULL;

(In my hypothetical, non-existent C-like language, there would be a
keyword "nil" that would be the only legal null pointer constant.
"p = 0;" would be illegal, and there would be no need for the NULL
macro. I occasionally rant about how I'd redesign C if I had the
chance; don't take it too seriously.)

--
Keith Thompson (The_Other_Keit h) ks***@mib.org <http://www.ghoti.net/~kst>
San Diego Supercomputer Center <*> <http://users.sdsc.edu/~kst>
We must do something. This is something. Therefore, we must do this.

[Irrwahn Grausewitz]

DevarajA <[e-mail]> wrote:
<snip>

Another thing.. looking into stddef.h I've seen that for C, NULL it is
defined as ((void*)0).
Depends on the implementation, yours happen to use the above
definition, another might define NULL as (0) or even
((void *)('9'-'4'-'5')).
The standard specifies that plain 0 is already a
null pointer constant. So why that cast?
I'm just guessing now; maybe the implementer thought: while we all
know that it's perfectly legitimate to implicitly convert a constant
integer expression with value 0 to any type of pointer, yielding a
null pointer of that type, I'll take a step further and _explicitly_
spell it out as ((void *)0) in the definition of the NULL macro.

Like saying: "Yes, I _really_ _really_ mean null pointer constant."

For a definite answer you'd have to ask the guy himself. ;o)
Maybe this is the last stupid
question for today :-)

There are no stupid questions, only stupid answers. :-)

Best regards
--
Irrwahn Grausewitz (ir*******@free net.de)
welcome to clc : http://www.ungerhu.com/jxh/clc.welcome.txt
clc faq-list : http://www.faqs.org/faqs/C-faq/faq/
clc frequent answers: http://benpfaff.org/writings/clc.