memory layout c++ objects

Question

Hi,

I am basically wondering how C++ lays out the object in memory. So, I hear that dynamic casts simply asjusts the object's pointer in memory with an offset; and reinterpret kind of allows us to do anything with this pointer. I dont really understand this. Details would be appreciated!

Thanks.

Answer 1

This looks like a good start, although the Question could probably be clearer.

Answer 2

If you really want to go in depth this is the best book: Inside C++ object model

Answer 3

The answer is, "it's complicated". Dynamic cast does not simply adjust pointers with an offset; it may actually retrieve internal pointers inside the object in order to do its work. GCC follows an ABI designed for Itanium but implemented more broadly. You can find the gory details here: Itanium C++ ABI.

Answer 4

Each class lays out its data members in the order of declaration.
The compiler is allowed to place padding between members to make access effecient (but it is not allowed to re-order).

How dynamic_cast<> works is a compiler implementation detail and not defined by the standard. It will all depend on the ABI used by the compiler.

reinterpret_cast<> works by just changing the type of the object. The only thing that you can gurantee that works is that casting a pointer to a void* and back to the same the pointer to class will give you the same pointer.

Answer 5

See this article for quite comprehensive description of how it's done inside the MSVC compiler.

Answer 6

As stated previously, the full details are complicated, painful to read, and really only useful to compiler developers, and varies between compilers. Basically, each object contains the following (usually laid out in this order):

1. Runtime type information
2. Non-Virtual base objects and their data (probably in order of declaration).
3. Member variables
4. Virtual base objects and their data (Probably in some DFS tree search order).

These pieces of data may or may not be padded to make memory alignment easier etc. Hidden in the runtime type information is stuff about the type, v-tables for virtual parent classes etc, all of which is compiler specific.

When it comes to casts, reinterpret_cast simply changes the C++ data type of the pointer and does nothing else, so you had better be sure you know what you're doing when you use it, otherwise you're liable to mess things up badly. dynamic_cast does very much the same thing as static_cast (in altering the pointer) except it uses the runtime type information to figure out if it can cast to the given type, and how to do so. Again, all that is compiler specific. Note that you can't dynamic_cast a void* because it needs to know where to find the runtime type information so it can do all its wonderful runtime checks.