Question

Take the typical demonstration of how pointer values can change through casting:

struct B1 { int x; };
struct B2 { int y; };
struct D  : B1, B2 { };

int main() {
   D d;
   cout << (B1*)&d << " " << (B2*)&d << " " << &d;
}

// Typical output:
// 0xbf814ab4 0xbf814ab8 0xbf814ab4

I got to thinking; that offset probably does not exist when B1 has no members, so I checked and it’s true (at least in this case; not sure how standards-guaranteed this behaviour is):

struct B1 { };
struct B2 { };
struct D  : B1, B2 { };

int main() {
   D d;
   cout << (B1*)&d << " " << (B2*)&d << " " << &d;
}

// Typical output:
// 0xbf6ad95b 0xbf6ad95b 0xbf6ad95b

But then, sizeof(T) cannot be 0, so sizeof(B1) is still 1.

It strikes me that this “discrepancy” may potentially cause serious error-prone code where a programmer assumes that (char*)(B2*)&d - (char*)(B1*)&d == (ptrdiff_t)sizeof(B1).

Is my analysis accurate?

Answer 1

The B1 and B2 objects are subobjects of d. The sizeof operator gives information about the size of a complete object, not a subobject.

The Standard allows but does not require a base class subobject to occupy no memory. So on another compliant implementation, you could find in your second example that the subobjects have different addresses after all.

1.8p5: Unless it is a bit-field, a most derived object shall have a non-zero size and shall occupy one or more bytes of storage. Base class subobjects may have zero size. An object of trivially copyable or standard-layout type shall occupy contiguous bytes of storage.

1.8p6: Unless an object is a bit-field or a base class subobject of zero size, the address of that object is the address of the first byte it occupies. Two distinct objects that are neither bit-fields nor base class subobjects of zero size shall have distinct addresses.

And the only "safe" uses of pointer arithmetic are:

• On pointers to elements of the same array
• The guarantee that the address of a subobject y of complete object x is between &x inclusive and &x+1 exclusive.

Subtracting two void* pointers is ill-formed. You probably meant to reinterpret_cast<char*> or something. (Another sign that the code is very risky.)

5.7p4: For the purpose of these operators [binary + and -], a pointer to a nonarray object behaves the same as a pointer to the first element of an array of length one with the type of the object as its element type.

5.7p6: When two pointers to elements of the same array are subtracted, the result is the difference of the subscripts of the two array elements. … Unless both pointers point to elements of the same array object, the behavior is undefined.