为 struct 成员分配的内存是否连续？ 如果结构成员是数组怎么办？

Question

In C/C++ suppose I define a simple struct named test as follows.

struct test
{
   double height;
   int    age;
   char   gender;
}

For a specific instance of this struct say test A are A.height, A.age, A.gender contiguous in memory?

More generally, how do the layouts in memory for a Structure of Arrays and an Array of structures look like? A picture would be really helpful.

Answer 1

They will not necessarily be contiguous in memory. This is due to struct padding .

However, in your particular case, it may very well be contiguous. But if you changed the order to something like this:

struct test
{
    char   gender;
    int    age;
    double height;
}

then they most likely will not be. However, in your particular case, you will still likely get padding after gender , to realign the struct to 8 bytes.

---

The difference between SoA ( Struct of Arrays ) and AoS ( Array of Structs ) would be like this:

SoA:

-----------------------------------------------------------------------------------
| double | double | double | *pad* | int | int | int | *pad* | char | char | char |
-----------------------------------------------------------------------------------

AoS:

-----------------------------------------------------------------------------------
| double | int | char | *pad* | double | int | char | *pad* | double | int | char |
-----------------------------------------------------------------------------------

Note that AoS pads within each struct. While SoA pads between the arrays.

These have the following trade-offs:

1. AoS tends to be more readable to the programmer as each "object" is kept together.
2. AoS may have better cache locality if all the members of the struct are accessed together.
3. SoA could potentially be more efficient since grouping same datatypes together sometimes exposes vectorization.
4. In many cases SoA uses less memory because padding is only between arrays rather than between every struct.

Answer 2

The individual fields are contiguous in the sense that there will be no other variables stored in-between them. They are also guaranteed to be stored in the order that you declared. But the compiler is free to insert padding in-between the individual fields to align things to word boundaries, for instance. So the following:

struct test
{
    double height;
    char   gender;
    int    age;
};

may look like this in memory:

         +7  +6  +5  +4  +3  +2  +1  +0
        +---+---+---+---+---+---+---+---+
0x0000  |            height             |
        +---+---+---+---+---+---+---+---+
0x0008  |      age      |           |gen|
        +---+---+---+---+---+---+---+---+

As for the difference between SoA and AoS, they're laid out exactly as you might imagine.

Answer 3

Other than the standard disclaimer of "it depends on your platform, compiler, blahblahblah"... yes, height , age , and gender will be contiguous in memory with no padding in between:

height|age|gender

However, if you have an array of test , each array element will have padding in between them after each's gender so that the next element's height is properly aligned.

|height0|age0|gender0|padding0|height1|age1|gender1|padding1|...

If your goal is to use the least amount of memory possible, then you should go with "structure of arrays" since it uses no padding.

|height0|height1|...

|age0|age1|...

|gender0|gender1|...