Sizeof (), выравнивание в C-структурах:

На вашей платформе справедливо следующее: Размер int и float равен 4. Требование к размеру и выравниванию для double составляет 8.

Мы знаем это из показанных вами выходных данных sizeof. sizeof (T) дает количество байтов между адресами двух последовательных элементов типа T в массиве. Итак, мы знаем, что требования к выравниванию такие, как я сказал выше. ^(Note)

Теперь компилятор сообщил 16 для IntFloatAndDoubleStruct. Получается?

Предположим, у нас есть такой объект по адресу, выровненному по 16.

• Таким образом, int a находится по адресу X, выровненному по 16, так что он выровнен по 4 очень хорошо. Он будет занимать байты [X, X + 4)
• Это означает, что float c может начинаться с X + 4, который выровнен по 4, что нормально для float. Он будет занимать байты [X + 4, X + 8)
• Наконец, double d может начинаться с X + 8, который выровнен по 8, что нормально для double. Он будет занимать байты [X + 8, X + 16)
• Это оставляет X + 16 свободным для следующего объекта структуры, снова выровненного по 16.

Таким образом, нет причин запускать какие-либо члены позже, поэтому вся структура отлично умещается в 16 байтов.

^(Note) Это не совсем так: для каждого из них мы знаем, что и размер, и выравнивание <= N, что N кратно требованию выравнивания, и что не существует N1 <N, для которого это также было бы. Однако это очень мелкая деталь, и для ясности ответ просто предполагает, что фактические требования к размеру и выравниванию для примитивных типов являются неопределенными, что в любом случае является наиболее вероятным случаем на платформе OP.

Компилятор вставит заполнение, чтобы гарантировать, что каждый элемент находится со смещением, кратным его размеру.

В этом случае int будет со смещением = 0 (относительно адреса экземпляра структуры), float со смещением = 4 и double со смещением = 8, поскольку размеры int и float в сумме составляют 8.

В конце нет отступов - размер структуры уже равен 16, что кратно размеру double.

Ваша структура должна быть длиной 8*N байта, поскольку она имеет член с 8 байтами (double). Это означает, что структура находится в памяти по адресу (A), кратному 8 (A%8 == 0), и ее конечный адрес будет (A + 8N), который также будет делиться на 8.

Оттуда вы сохраняете 2 4-байтовые переменные (int + float), что означает, что теперь вы занимаетесь областью памяти [A,A+8). Теперь вы храните 8-байтовую переменную (double). Начиная с (A+8) % 8 == 0 [начиная с A%8 == 0], нет необходимости в заполнении. Итак, без прокладки вы получите 4+4+8 == 16.

Если вы измените порядок на int -> double -> float, вы займете 24 байта, поскольку исходный адрес переменной double не будет делиться на 8, и ему нужно будет заполнить 4 байта, чтобы добраться до действительного адреса (а также структура будет иметь заполнение в конце ).

|--------||--------||--------||--------||--------||--------||--------||--------|
|   each ||   cell ||  here  ||represen||-ts  4  || bytes  ||        ||        |
|--------||--------||--------||--------||--------||--------||--------||--------|

A        A+4       A+8      A+12      A+16      A+20      A+24                      [addresses]
|--------||--------||--------||--------||--------||--------||--------||--------|    
|   int  ||  float || double || double ||        ||        ||        ||        |    [content - basic case]
|--------||--------||--------||--------||--------||--------||--------||--------|

first padding to ensure the double sits on address that is divisble by 8
last  padding to ensure the struct size is divisble by the largest member's size (8)
|--------||--------||--------||--------||--------||--------||--------||--------|    
|   int  || padding|| double || double || float  || padding||        ||        |    [content - change order case]
|--------||--------||--------||--------||--------||--------||--------||--------|

Прежде всего, C не требует какого-либо выравнивания для элементов внутри структуры. Вот почему трудно сказать, какое значение возвращает sizeof () для экземпляра какой-либо структуры.

Единственное ограничение, которое C накладывает на элементы структуры, состоит в том, что адрес, выделенный для первого члена, должен быть кратным его выравниванию (так, чтобы к вектору этой структуры можно было получить доступ как указатель + sizeof () * index). В вашем случае IntFloatAndDoubleStruct должен быть выровнен по кратному размеру sizeof (int), поскольку a имеет тип int.

Внутренним членам в некоторых случаях выделяются адреса, кратные их выравниванию, чтобы работать быстрее (поэтому вставляются некоторые отступы), но это не налагается C. Таким образом, компилятор может решить вставить #pragma, чтобы изменить алгоритм, используемый для выделения конструкции. См. здесь.

Как предполагает CIsForCookies, структура будет выровнена с кратным максимальным выравниванием, чтобы вектор таких структур по-прежнему выровнял каждый член. Но это не налагается языком C, а с учетом производительности реализации, потому что в addr_struct[i]+member_offset оба термина делятся выравниванием.