I have just realized how much memory is wasted as a result of alignment in C++. Consider the following simple example:

struct X

 int a;
 double b;
 int c;
;

int main()

 cout << "sizeof(int) = " << sizeof(int) << 'n';
 cout << "sizeof(double) = " << sizeof(double) << 'n';
 cout << "2 * sizeof(int) + sizeof(double) = " << 2 * sizeof(int) + sizeof(double) << 'n';
 cout << "but sizeof(X) = " << sizeof(X) << 'n';

When using g++ the program gives the following output:

sizeof(int) = 4
sizeof(double) = 8
2 * sizeof(int) + sizeof(double) = 16
but sizeof(X) = 24

That's 50% memory overhead! In a 3-gigabyte array of 134'217'728 Xs 1 gigabyte would be pure padding.

Fortunately, the solution to the problem is very simple - we simply have to swap double b and int c around:

struct X

 int a;
 int c;
 double b;
;

Now the result is much more satisfying:

sizeof(int) = 4
sizeof(double) = 8
2 * sizeof(int) + sizeof(double) = 16
but sizeof(X) = 16

There is however a problem: this isn't cross-compatible. Yes, under g++ an int is 4 bytes and a double is 8 bytes, but that's not necessarily always true (their alignment doesn't have to be the same either), so under a different environment this "fix" could not only be useless, but could also potentially make things worse by increasing the amount of padding needed.

Is there a reliable cross-platform way to solve this problem (minimize the amount of needed padding without suffering from decreased performance caused by misalignment)? Why doesn't the compiler perform such optimizations (swap struct/class members around to decrease padding)?

EDIT

Due to misunderstanding and confusion, I'd like to emphasize that I don't want to "pack" my struct. I still want it to be aligned, but in a way that uses the least memory on padding.

gcc has the -Wpadded warning that warns when padding is added to a structure:

https://godbolt.org/z/iwO5Q3:

<source>:4:12: warning: padding struct to align 'X::b' [-Wpadded]
 4 | double b;
 | ^

<source>:1:8: warning: padding struct size to alignment boundary [-Wpadded]
 1 | struct X
 | ^

And you can manually rearrange members so that there is less / no padding. But this is not a cross platform solution, as different types can have different sizes / alignments on different system (Most notably pointers being 4 or 8 bytes on different architectures). The general rule of thumb is go from largest to smallest alignment when declaring members, and if you're still worried, compile your code with -Wpadded once (But I wouldn't keep it on generally, because padding is necessary sometimes).

As for the reason why the compiler can't do it automatically is because of the standard ([class.mem]/19). It guarantees that, because this is a simple struct with only public members, &x.a < &x.c (for some X x;), so they can't be rearranged.

There really isn't a portable solution in the generic case. Baring minimal requirements the standard imposes, types can be any size the implementation wants to make them.

To go along with that, The compiler is not allowed to reorder class member to make it more efficient. The standard mandates that the objects must be laid out in their declared order (by access modifier), so that's out as well.

You can use fixed width types like

struct foo

 int64_t a;
 int16_t b;
 int8_t c;
 int8_t d;
;

and this will be the same on all platforms, provided they supply those types, but it only works with integer types. There are no fixed width floating point types and many standard objects/containers can be different sizes on different platforms.

You can use #pragma pack(1), but the very reason of this is that the compiler optimizes. Accessing a variable through the full register is faster than accessing it to the least bit.

Specific packing is only useful for serialization and intercompiler compatibility, etc.

As NathanOliver correctly added, this might even fail on some platforms.

Well, maybe I'm cooking the concept wrong, but you can use std::aligned_storage to allocate your data. Applied to the struct, considered above, it could be something like that:

#include <type_traits>
#include <iostream>
#include <algorithm>

struct X

 int a;
 double b;
 int c;
;


int main()

 const std::size_t TOTAL_SIZE = sizeof(int) + sizeof(double) + sizeof(int);
 // const std::size_t MAX_ALIGNMENT = std::max(alignof(double), alignof(int));
 const std::size_t MAX_ALIGNMENT = alignof(X); //probably a better approach than above

 std::aligned_storage<TOTAL_SIZE, MAX_ALIGNMENT>::type buffer;
 X* pX = new(static_cast<void*>(&buffer)) X;

 std::cout << "but sizeof(buffer) = " << sizeof(buffer) << std::endl;
 pX->a = 10;
 pX->b = 12334.5353;
 pX->c = 44;

 std::cout << pX->a << "t" << pX->b << "t" << pX->c << std::endl;

 return 0;

There is no delete, because placement-new handles the allocation, so that it happenes on stack (buffer is a stack variable). Also, something more sophisticated should be passed as template parameters, some compile-time calculations of the desired buffer size and alignment (honestly, that's where I'm not quite sure of myself). ...and maybe you'll have to use types like int16_t, and probably you'd better reorder members of the struct taking into account all the considerations, that have already been proposed about that.

But the primary idea is like that.

AFAIK, different tricks like "Small Object Optimization" are done that way, if you compiler supports the corresponding standard, that trick should save your efforrts. Standard library implementation's sources from GCC are full of similar things, just a lot more well-thought-out.