How is the size of a C++ class determined?

by

For POD (plain old data), the rules are typically:

  • Each member in the structure has some size s and some alignment requirement a.
  • The compiler starts with a size S set to zero and an alignment requirement A set to one (byte).
  • The compiler processes each member in the structure in order:
  1. Consider the member’s alignment requirement a. If S is not currently a multiple of a, then add just enough bytes to S so that it is a multiple of a. This determines where the member will go; it will go at offset S from the beginning of the structure (for the current value of S).
  2. Set A to the least common multiple1 of A and a.
  3. Add s to S, to set aside space for the member.
  • When the above process is done for each member, consider the structure’s alignment requirement A. If S is not currently a multiple of A, then add just enough to S so that it is a multiple of A.

The size of the structure is the value of S when the above is done.

Additionally:

  • If any member is an array, its size is the number of elements multiplied by the size of each element, and its alignment requirement is the alignment requirement of an element.
  • If any member is a structure, its size and alignment requirement are calculated as above.
  • If any member is a union, its size is the size of its largest member plus just enough to make it a multiple of the least common multiple1 of the alignments of all the members.

Consider your TestClass3:

  • S starts at 0 and A starts at 1.
  • char buf[8] requires 8 bytes and alignment 1, so S is increased by 8 to 8, and A remains 1.
  • __m128i vect requires 16 bytes and alignment 16. First, S must be increased to 16 to give the correct alignment. Then A must be increased to 16. Then S must be increased by 16 to make space for vect, so S is now 32.
  • char buf2[8] requires 8 bytes and alignment 1, so S is increased by 8 to 24, and A remains 16.
  • At the end, S is 24, which is not a multiple of A (16), so S must be increased by 8 to 32.

So the size of TestClass3 is 32 bytes.

For elementary types (int, double, et cetera), the alignment requirements are implementation-defined and are usually largely determined by the hardware. On many processors, it is faster to load and store data when it has a certain alignment (usually when its address in memory is a multiple of its size). Beyond this, the rules above follow largely from logic; they put each member where it must be to satisfy alignment requirements without using more space than necessary.

Footnote

1 I have worded this for a general case as using the least common multiple of alignment requirements. However, since alignment requirements are always powers of two, the least common multiple of any set of alignment requirements is the largest of them.

More Related Contents:

  1. Why is integer assignment on a naturally aligned variable atomic on x86?
  2. How to solve the 32-byte-alignment issue for AVX load/store operations?
  3. Compelling examples of custom C++ allocators?
  4. Memory alignment in C-structs
  5. Making std::vector allocate aligned memory
  6. Do class/struct members always get created in memory in the order they were declared?
  7. How is a vector’s data aligned?
  8. Atomicity in C++ : Myth or Reality
  9. When extending a padded struct, why can’t extra fields be placed in the tail padding?
  10. Double alignment
  11. how does malloc understand alignment?
  12. Questions about Hinnant’s stack allocator
  13. Aligning static string literals
  14. Memory alignment : how to use alignof / alignas?
  15. What is the recommended way to align memory in C++11
  16. Is it always the case that sizeof(T) >= alignof(T) for all object types T?
  17. Do I really have to worry about alignment when using placement new operator?
  18. std::tuple memory alignment
  19. What exactly is an ‘aligned pointer’?
  20. Rounding up to the nearest multiple of a number
  21. Using C++ library in C code
  22. placement new and delete
  23. Using float gives “call to overloaded function is ambiguous” error [duplicate]
  24. Why do we need to use boost::asio::io_service::work?
  25. How to use graphics.h in codeblocks?
  26. Does boost have a datatype for set operations that is simpler than the STL?
  27. Using `std::function` to call non-void function
  28. Using std::string_view with api that expects null-terminated string
  29. reinterpret_cast between char* and std::uint8_t* – safe?
  30. How to implement a unmanaged thread-safe collection when I get this error: is not supported when compiling with /clr

Leave a Comment