一个二进制文件中相同类型的不同布局

Question

Sometimes C++ compilers generate different memory layouts for the same type T within the same binary. Namely, this happens when objects occur both as non-contiguous subobject of a class, and as a standalone object or array subobject:

struct A { int i; };
struct B : virtual A { int i; };
struct C : virtual A { int i; };
struct D : B,C { int i; };
...
D d;
B b;
B* p1= &(B&)d;
B* p2= &b;

According to C++14 standard , is the compiler free to generate any number of different layouts for objects of type T within a single binary? Are the memory layouts fixed at compile time?

Spin-off: How does placement new know which layout to create?

---

Elaboration on the second question: An object t of type T may be accessed either by T* or by char* pointers. (The latter is justified by §3.10 (10)) Once the compiled program is running, one may determine the relative offsets of subobjects of t by accessing t via char pointers. Are these offsets deterministic, or may they change from one program execution to another?

Answer 1

According to C++14 standard you get UB if you convert pointer to a class to pointer to something else and then use the pointer. So you can't get offset from the class beginning and then add it class pointer.

For standard layout objects you get more guarantees and you can use offsetof and get deterministic results. Classes with virtual inheritance are tricky thing and are definitely not standard layout ones.

Answer 2

Preliminary answer (As of now, don't take this for granted):

Let's assume T is a class type with at least two non-static data members. If T is no standard-layout class, let's assume the two data members are public and private, having different access control. It is understood that the layouts described below meet the ordering and contiguity requirements imposed by the standard.

a) If T is neither trivially copyable nor standard layout, the implementation is free to use a random number generator to create a new memory layout when an object of type T is created. There is no upper limit to the number of different memory layouts for T that may be created by a single binary. (Nothing to the contrary in the standard. really? Must be missing something)

b) If T is trivially copyable, but not standard layout, the implementation is free to use a random number generator at program start to generate a layout for T. The number of possible layouts is finite. The layouts may differ from one program execution to the next one. (restrictions due to §3.9.2 and §1.8.5)

c) If T is standard-layout, there is only one possible layout. (Order and contiguity guaranteed)