[Not a duplicate of [Structure padding and packing][1]. That question is about how and when padding occurs. This one is about how to deal with it.]

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 &lt;&lt; &quot;sizeof(int) = &quot;                      &lt;&lt; sizeof(int)                      &lt;&lt; &#39;\n&#39;;
    cout &lt;&lt; &quot;sizeof(double) = &quot;                   &lt;&lt; sizeof(double)                   &lt;&lt; &#39;\n&#39;;
    cout &lt;&lt; &quot;2 * sizeof(int) + sizeof(double) = &quot; &lt;&lt; 2 * sizeof(int) + sizeof(double) &lt;&lt; &#39;\n&#39;;
    cout &lt;&lt; &quot;but sizeof(X) = &quot;                    &lt;&lt; sizeof(X)                        &lt;&lt; &#39;\n&#39;;
}
```

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&#39;s 50% memory overhead! In a 3-gigabyte array of 134&#39;217&#39;728 `X`s 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&#39;t cross-compatible. Yes, under g++ an `int` is 4 bytes and a `double` is 8 bytes, but that&#39;s not necessarily always true (their alignment doesn&#39;t have to be the same either), so under a different environment this &quot;fix&quot; could not only be useless, but it 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&#39;t the compiler perform such optimizations** (swap struct/class members around to decrease padding)?

# Clarification
Due to misunderstanding and confusion, I&#39;d like to emphasize that **I don&#39;t want to &quot;pack&quot; my `struct`**. That is, I don&#39;t want its members to be unaligned and thus slower to access. Instead, I still want all members to be self-aligned, but in a way that uses the least memory on padding. This could be solved by using, for example, manual rearrangement as described here and in [The Lost Art of Packing][2] by Eric Raymond. I am looking for an automated and as much cross-platform as possible way to do this, similar to what is described in [proposal P1112][3] for the upcoming C++20 standard.


  [1]: https://stackoverflow.com/questions/4306186/structure-padding-and-packing
  [2]: http://www.catb.org/esr/structure-packing/
  [3]: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2018/p1112r1.pdf

All Struct Member-Alignment Solutions on Gang of Coders

Total of 1 Struct Member-Alignment Solutions

How do I organize members in a struct to waste the least space on alignment?