The "position" of variables

[Julek]

Hi,
I wanted to know, if there is guarantee that a specific variable is
always the same number of bytes forward than the beginning of the
struct/class. Example:

class MyClass
{
....
int var;
};
....
// somewhere we create one object
MyClass obj;
....
// somewhere else we create other object
MyClass *obj2=new MyClass;
....
// check the distance from the beginning of structure
int diff1=int( ((char*)&obj.va r) - ((char*)&obj) );
int diff2=int( ((char*)&obj2->var) - ((char*)obj2) );
if(diff1 == diff2 )
{
// it's the same distance
}

Can I always assume, that diff1 == diff2, no matter how MyClass
structures are created? Even if they have multiple inheritance and
other "advanced" features?

Specifically, I want to know the answer for Visual C++ 2003, and
SunStudio.

Thanks in advance,
Julek

[Pete Becker]

On 2008-05-29 08:21:32 -0400, Julek <ju******@go2.p lsaid:

Hi,
I wanted to know, if there is guarantee that a specific variable is
always the same number of bytes forward than the beginning of the
struct/class. Example:

class MyClass
{
...
int var;
};
...
// somewhere we create one object
MyClass obj;
...
// somewhere else we create other object
MyClass *obj2=new MyClass;
...
// check the distance from the beginning of structure
int diff1=int( ((char*)&obj.va r) - ((char*)&obj) );
int diff2=int( ((char*)&obj2->var) - ((char*)obj2) );
if(diff1 == diff2 )
{
// it's the same distance
}

Can I always assume, that diff1 == diff2, no matter how MyClass
structures are created? Even if they have multiple inheritance and
other "advanced" features?

Yes. But note that this is a somewhat constrained question: var is a
direct member of MyClass. More generally, no, you can't assume that any
member of a class will always be at the same offset. In particular,
virtual base classes (and, hence, their members) can move around,
depending on how inheritance is used.

Formally, the calculation of diff1 and diff2 is equivalent to the macro
offsetof, which can only be applied to POD types. The more general way
of pointing at a selected member of an arbitrary object of type T is
with a pointer to member of T:

int MyClass::*ptr = &MyClass::va r;
MyClass obj1;
obj1.*ptr = 3; // assigns to obj1.var
MyClass obj2;
obj2.*ptr = 4; // assigns to obj2.var

If you have a pointer instead of an object or a reference, use ->* to
get at the member:

MyClass *pmc = &obj1;
int i = pmc->*ptr; // copies from obj1.var

--
Pete
Roundhouse Consulting, Ltd. (www.versatilecoding.com) Author of "The
Standard C++ Library Extensions: a Tutorial and Reference
(www.petebecker.com/tr1book)

[=?UTF-8?B?RXJpayBXaWtzdHLDtm0=?=]

On 2008-05-29 14:36, Pete Becker wrote:

On 2008-05-29 08:21:32 -0400, Julek <ju******@go2.p lsaid:

>Hi,
I wanted to know, if there is guarantee that a specific variable is
always the same number of bytes forward than the beginning of the
struct/class. Example:

class MyClass
{
...
int var;
};
...
// somewhere we create one object
MyClass obj;
...
// somewhere else we create other object
MyClass *obj2=new MyClass;
...
// check the distance from the beginning of structure
int diff1=int( ((char*)&obj.va r) - ((char*)&obj) );
int diff2=int( ((char*)&obj2->var) - ((char*)obj2) );
if(diff1 == diff2 )
{
// it's the same distance
}

Can I always assume, that diff1 == diff2, no matter how MyClass
structures are created? Even if they have multiple inheritance and
other "advanced" features?

Yes. But note that this is a somewhat constrained question: var is a
direct member of MyClass. More generally, no, you can't assume that any
member of a class will always be at the same offset. In particular,
virtual base classes (and, hence, their members) can move around,
depending on how inheritance is used.

But surely you can assume that all instances of a class/struct in a
running program have the same layout. Of course of you recompile the
program they layout can change but in each instance of a program it
should be well-defined.

--
Erik Wikström

[Pete Becker]

On 2008-05-29 12:33:55 -0400, Erik Wikström <Er***********@ telia.comsaid:

>
But surely you can assume that all instances of a class/struct in a
running program have the same layout. Of course of you recompile the
program they layout can change but in each instance of a program it
should be well-defined.

No, you can't. Virtual bases aren't always at the same offset relative
to any particular derived class.

struct base
{
int i;
};

struct i1 : virtual base
{
int j;
};

struct i2 : virtual base
{
int k;
};

struct der : i1, i2
{
int m;
};

Let's say that, for an object of type i1, the compiler puts the base
subobject immediately after the direct members of i1, and for an object
of type i2, it puts the base subobject immediately after the direct
members of i2. Now where does that base subobject end up when you have
an object of type der? If it's immediately after the direct members of
i1, then it can't be immediately after the direct members of i2, so the
offset of i from the i2 subobject is different from the offset in a
standalone i2 object. And vice versa. So one of the offsets has to
change.

This is typically implemented by putting a pointer to base in i1 and in
i2. To get at i, the compiler generates code that follows the pointer.
This isn't really the place for a more detailed explanation. Lipman's
"Inside the C++ Object Model" goes through all the details of a typical
implementation.

--
Pete
Roundhouse Consulting, Ltd. (www.versatilecoding.com) Author of "The
Standard C++ Library Extensions: a Tutorial and Reference
(www.petebecker.com/tr1book)

[=?UTF-8?B?RXJpayBXaWtzdHLDtm0=?=]

On 2008-05-29 20:45, Pete Becker wrote:

On 2008-05-29 12:33:55 -0400, Erik Wikström <Er***********@ telia.comsaid:

>>
But surely you can assume that all instances of a class/struct in a
running program have the same layout. Of course of you recompile the
program they layout can change but in each instance of a program it
should be well-defined.

No, you can't. Virtual bases aren't always at the same offset relative
to any particular derived class.

struct base
{
int i;
};

struct i1 : virtual base
{
int j;
};

struct i2 : virtual base
{
int k;
};

struct der : i1, i2
{
int m;
};

Let's say that, for an object of type i1, the compiler puts the base
subobject immediately after the direct members of i1, and for an object
of type i2, it puts the base subobject immediately after the direct
members of i2. Now where does that base subobject end up when you have
an object of type der? If it's immediately after the direct members of
i1, then it can't be immediately after the direct members of i2, so the
offset of i from the i2 subobject is different from the offset in a
standalone i2 object. And vice versa. So one of the offsets has to
change.

Yes, of course you can never make any assumptions about the offset of
member in one class based on the offset in another class. But the offset
of a member in different instances of the same class (which is what the
OP asked about) should be well defined.

--
Erik Wikström