Comments on: Find The Offset Of An Element In A Structure In C- offsetof()

By: Shantanu Goel

Shantanu Goel — Mon, 11 May 2009 04:27:34 +0000

Zombie: I agree with you on the struct declaration part. I should have been more careful while writing the declaration.
But an “unsigned long” is as bad as an “unsigned int”. There is no better option amongst these two. As you can see though, the final solution proposed, which is the crux of the article, does indeed use size_t.
And that particular statement that you refer to, was written just to show what not to do when you are going for portability. At no point of time, I “suggested” that this code be used. It was always clear that the first two forms are used by people already but they are not portable. I disagree when you say that someone should be taught only what is the right thing to do. I believe it is also equally important to tell them what’s wrong and that is exactly because “Human brain has limited capacity”. So, even if you tell them all the things that are right, they might get confused when they face something that is wrong and can’t decide on their own which side it lies on. Probably I could have explained it a bit more why it isn’t portable, yes.
Moreover, I did not mention about the struct internal padding, alignment, etc because it was not geared towards a user who was a complete novice to it. It was geared towards someone who was already in the know/using one of the first two approaches and to tell him that there is a better way.
But I’m glad that we have a learned programmer like you who keeps us in check, points out our innumerous flaws and eggs us on to write better. Thanks a lot for your contribution.

By: Santiago

Santiago — Sun, 10 May 2009 08:11:32 +0000

Zombie: yep, you are right of course. I sometimes forget that ‘void *’ cannot be used for pointer arithmetic because I always try to avoid using it altogether unless completely needed (being a disciplined programmer involves things like this

So in this first implementation instead of using directly a pointer to char I prefer to use the uintptr_t as you suggest above (it is defined for C99, but the stdint.h header can even be easily written for non-C99 compilers), and a ptrdiff_t type for storing the offsets.

Cheers

By: Zombie No. 5

Zombie No. 5 — Sat, 09 May 2009 15:35:55 +0000

Shantanu Goel: First, you code doesn’t make sense. Apparently you meant “struct example {…};” not “struct {…} example;” or maybe you meant “typedef struct {…} example” but then you’re first example is wrong again.

What a C programmer needs is discipline, discipline and discipline. Therefore a sentence like “The above snippet will work, but not always” is unworthy. It will NOT always work, period. Since there are completely portable and efficient ways to achieve what you want, there’s absolutely no point to suggest use of such nonsense code. You don’t teach people things by showing them how to do something wrong but how to do it right. The human brain has only limited capacity.

What is this int nonsense anyway? Any half-decent C programmer would at least have used “unsigned long”. A more educated progammer would have used “size_t” or even “uintptr_t”. And a good developer just uses offsetof() because it’s part of the standard.

This article would have been much more useful, if you had actually told the reader something about struct internal padding, alignment, order of elements etc. Otherwise, those readers for who any of this is news anyway, might wonder why you just don’t use sizeof(example.b) as offset. The point is, it isn’t just because that requires knowledge of the order of members, there are other reasons as well.

Santiago: You must be using GCC or some other forgiving C compiler because
((void *)x – (void *)y) as you suggest is not ‘C’ since pointer arithmetic is not legal because “void” has no size. A correct variant is casting to “(char *)”.

By: Santiago

Santiago — Sat, 09 May 2009 12:23:56 +0000

I was aware of the ‘offsetof’ macro, but for some gdb scripts I was forced to use the first implementation. However, it is a little cumbersome because you are forced to declare an instance of the struct type, for example a dummy global variable just to be easily accessible from gdb. Obviously, that can be a problem and is not very elegant.

So I find the second implementation really elegant and useful, because it doesn’t need declaring an instance of the variable. I’ll probably change those gdb scripts, thanks!

PS: IMHO the first implementation is more problematic than required, when doing pointer arithmetic is more adequate to use a pointer data type than integer types. Just operate with temp variables of type ‘void *’, and finally assign the result to an unsigned int. Casting first the addresses to unsigned int is really dangerous, in many cases the integer types are narrower than the address types.

Cheers

By: Shantanu Goel

Shantanu Goel — Fri, 08 May 2009 22:23:38 +0000

@Zombie: Care to tell what exactly is the issue with the statement?

By: Zombie No. 5

Zombie No. 5 — Fri, 08 May 2009 16:33:40 +0000

Seriously guys…is this blog a complete joke or what? You’re casting address to an unsigned int to calculate the difference between two addresses.

“Making Your Code Faster, Stronger, Safer…”

How about learning some basic knowledge of C first?

By: Shantanu Goel

Shantanu Goel — Wed, 06 May 2009 13:59:11 +0000

0 in itself is not a valid lvalue. But when you typecast it to the structure pointer type and then dereference an element from it, it becomes a valid lvalue and & operator can be used for it.

By: markandey

markandey — Tue, 05 May 2009 16:46:08 +0000

does & operator work on a constant value?