C++Talk.NET

Guest · Posted: Fri May 11, 2007 4:40 am Post subject: C++ offsetof hack

Hey all. I would like some comments on another C++ "hack" that I have
employed in some work I have done (http://www.ischo.com/xrtti). I had
to employ this hack to "work around a limitation of the C++ language.
I realize that I am doing something "dangerous" that is not permitted
by the language specification. However, I have a hard time thinking
of how a compiler could make what I am doing *not work*. Here is the
hack:

Using offsetof() in C++ is only defined to work for "POD" types (plain
old data - i.e. simple C structs or C++ classes with no virtual
methods). But I need offsetof to work for C++ classes also, so I came
up with the following hack:

void DummyFunction();

#define KnownAddress ((char *) ::DummyFunction)

#define cpp_offsetof(type, member) \
(((char *) &((type *) KnownAddress)->member) - KnownAddress)

What I'm doing here is taking an address known to be in the addres
space of the program (although I don't think this matters at runtime
but I found that the compiler I was working with - g++ - gave me
errors if I chose arbitrary addresses like 0 or 1) and casting it to a
pointer to the type in question, then addressing the member in
question from this address, then taking the address of *that* (thus
yielding a pointer to the member as it would be addressed within a
class of the given type, if the class of the given type were located
at the same address as KnownAddress), then casting that to char * (so
that the pointer math then works correctly) and subtracting the known
address back out again.

The net result is that I am left with just the difference between a
pointer to the type in question, and a pointer to the member in
question within that type. This is the "offsetof" that I am
interested in.

This is similar I believe to standard C implementations of offsetof,
which might look like this:

#define offsetof(type, member) \
(((char *) &((type *) 0)->member) - 0)

The only difference being, that I am using an address that the
compiler doesn't issue an error for (whereas with g++ I found that
trying to cast 0 to a pointer to a class gave an error, and the same
for other arbitrary integers I chose - 1, 4096, etc).

I find that this works perfectly in g++ but I haven't tried other
compilers.

I realize that I am violating some of the rules of C++ - I have read
that you are specifically disallowed from trying to get the offset of
a class member. Presumably this is because the C++ standard wants to
leave the door open for compiler implementers to do really weird
things with class layout, so that offsetof cannot work at compile time
but could only work at runtime.

The thing is, I have a hard time thinking of when a C++ compiler
writer would do something like make member variable calculations
require runtime code. I would always expect members of a C++ class to
be at a fixed, known offset from a pointer to that class, and that the
compiler would simply issue simple memory address addition
instructions to get the address of member variables of classes.

First - does anyone have any comments on this hack? Is it crazy to
think that it will work on all compilers? Can anyone think of a
reasonable way that C++ compilers might not be able to give a fixed
constant for the offset from a class to a member of the class, at
compile time, that would work for all instances of that class?

Second - if anyone wants to find out if my cpp_offsetof macro works
for their compiler, you can try this program:

------------------------------------------------------------
#include <stdio.h>

void DummyFunction() { }

#define KnownAddress ((char *) ::DummyFunction)

#define cpp_offsetof(type, member) \
(((char *) &((type *) KnownAddress)->member) - KnownAddress)

class Foo
{
public:

virtual ~Foo() { }

int a;
char b;
float c;
};

int main()
{
Foo f;

f.a = 1, f.b = 2, f.c = 3;

printf("Before: %d, %d, %f\n", f.a, f.b, f.c);

int *pA = (int *) ((char *) &f + cpp_offsetof(Foo, a));

char *pB = (char *) ((char *) &f + cpp_offsetof(Foo, b));

float *pC = (float *) ((char *) &f + cpp_offsetof(Foo, c));

*pA = 4, *pB = 5, *pC = 6;

printf("After: %d, %d, %f\n", f.a, f.b, f.c);

return 0;
}
------------------------------------------------------------

If you compile and run this program and it outputs this:

Before: 1, 2, 3.000000
After: 4, 5, 6.000000

Then my macro works on your compiler. I would love to hear if this
works or does not work for your compiler. So far I have only tried it
on g++ 4.1.1.

Thanks!
Bryan

--
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]

John Moeller · Guest

On Thu, 10 May 2007 22:40:58 CST, bji-ggcpp (AT) ischo (DOT) com wrote:

Guest · Posted: Sat May 12, 2007 4:29 am Post subject: Re: C++ offsetof hack

On May 12, 2:56 pm, Sebastian Redl <e0226...@stud3.tuwien.ac.at>
wrote:

Guest · Posted: Mon May 14, 2007 8:12 am Post subject: Re: C++ offsetof hack

On May 13, 6:58 am, Maciej Sobczak <see.my.homep...@gmail.com> wrote:

Seungbeom Kim · Guest

bji-ggcpp (AT) ischo (DOT) com wrote: