Определение выравнивания структур C / C ++ по отношению к его членам

Здесь есть два тесно связанных понятия:

1. Выравнивание, необходимое процессору для доступа к определенному объекту
2. Выравнивание, которое компилятор фактически использует для размещения объектов в памяти.

Чтобы обеспечить требования к выравниванию элементов конструкции, выравнивание конструкции должно быть по крайней мере таким же строгим, как выравнивание ее самого строгого члена. Я не думаю, что это четко прописано в стандарте, но это можно сделать вывод из следующих фактов (которые отдельно изложены в стандарте):

• Структуры могут иметь отступы между членами (и в конце).
• Массивы не могут иметь отступы между элементами.
• Вы можете создать массив любого типа структуры

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

Теперь компилятор должен обеспечить минимальное выравнивание структуры на основе требований к выравниванию ее членов, но он также может выравнивать объекты более строгим образом, чем требуется, часто это делается по соображениям производительности. Например, многие современные процессоры разрешают доступ к 32-битным целым числам при любом выравнивании, но доступ может быть значительно медленнее, если они не выровнены по 4-байтовой границе.

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

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

Я написал этот код признака типа для определения выравнивания любого типа (на основе уже обсужденных правил компилятора). Вы можете найти это полезным:

template <class T>
class Traits
{
public:
    struct AlignmentFinder
    {
        char a; 
        T b;
    };

    enum {AlignmentOf = sizeof(AlignmentFinder) - sizeof(T)};
};

Итак, теперь вы можете:

std::cout << "The alignment of structure S is: " << Traits<S>::AlignmentOf << std::endl;

Следующий макрос вернет требование выравнивания любого заданного типа (даже если это структура):

#define TYPE_ALIGNMENT( t ) offsetof( struct { char x; t test; }, test )

Примечание: я, вероятно, позаимствовал эту идею из заголовка Microsoft в какой-то момент в прошлом ...

Изменить: как указывает Роберт Гэмбл в комментариях, работа этого макроса не гарантируется. Фактически, это определенно не будет работать очень хорошо, если компилятор настроен на упаковку элементов в структуры. Поэтому, если вы решили использовать его, используйте его с осторожностью.

Некоторые компиляторы имеют расширение, позволяющее получить выравнивание типа (например, начиная с VS2002, MSVC имеет внутреннюю __alignof()). Их следует использовать, когда они доступны.

Как упоминали другие, его реализация зависит. Visual Studio 2005 использует 8 байтов в качестве выравнивания структуры по умолчанию. Внутри элементы выровнены по размеру - float имеет 4-байтовое выравнивание, double использует 8 и т. Д.

Вы можете изменить поведение с помощью #pragma pack. GCC (и большинство компиляторов) имеют аналогичные параметры компилятора или прагмы.

Можно предположить выравнивание структуры, если вы знаете более подробную информацию об используемых параметрах компилятора. Например, #pragma pack (1) приведет к принудительному выравниванию на уровне байтов для некоторых компиляторов.

Боковое примечание: я знаю, что вопрос был о выравнивании, но побочная проблема - это заполнение. Для встроенного программирования, двоичных данных и т. Д. - В общем, не предполагайте ничего о выравнивании структуры, если это возможно. При необходимости используйте в структурах явное заполнение. У меня были случаи, когда было невозможно скопировать точное выравнивание, используемое в одном компиляторе, в компилятор на другой платформе без добавления элементов заполнения. Это было связано с выравниванием структур внутри структур, поэтому добавление элементов padding исправило это.

Если вы хотите выяснить это для конкретного случая в Windows, откройте windbg:

Windbg.exe -z \path\to\somemodule.dll -y \path\to\symbols

Затем запустите:

dt somemodule!CSomeType

Я не думаю, что макет памяти каким-либо образом гарантирован каким-либо стандартом C. Это очень сильно зависит от производителя и архитектора. Могут быть способы сделать это, которые работают в 90% случаев, но они нестандартны.

Я был бы очень рад, если бы ошибся =)

Я в основном согласен с Полом Беттсом, Райаном и Дэном. На самом деле, это зависит от разработчика, вы можете либо сохранить симанику выравнивания по умолчанию, о которой заметил Роберт (объяснение Роберта - это просто поведение по умолчанию и никоим образом не принудительно или не требуется), либо вы можете настроить любое выравнивание, которое хотите / Zp [# #].

Это означает, что если у вас есть typedef с числами float, long double, uchar и т. Д. ... включены различные наборы массивов. Затем есть другой тип, который имеет некоторые из этих элементов странной формы и один байт, затем еще один нечетный член, он будет просто выровнен с любым предпочтением, определенным файлом make / solution.

Как отмечалось ранее, используя команду windbg dt во время выполнения, вы можете узнать, как компилятор размещает структуру в памяти.

Вы также можете использовать любой инструмент для чтения pdb, например dia2dump, для статического извлечения этой информации из pdb.

Изменено из блога Пеэтера Джута

Выравнивание структуры C основано на собственном типе самого большого размера в структуре, по крайней мере, обычно (исключением является что-то вроде использования 64-битного целого числа в win32, где требуется только 32-битное выравнивание).

Если у вас есть только символы и массивы символов, после добавления int этот int будет начинаться на 4-байтовой границе (с возможным скрытым заполнением перед элементом int). Кроме того, если структура не кратна sizeof (int), в конце будет добавлено скрытое заполнение. То же самое для коротких и 64-битных типов.

Пример:

struct blah1 {
    char x ;
    char y[2] ;
};

sizeof (blah1) == 3

struct blah1plusShort {
    char x ;
    char y[2] ;
    // <<< hidden one byte inserted by the compiler here
    // <<< z will start on a 2 byte boundary (if beginning of struct is aligned).
    short z ;
    char w ;
    // <<< hidden one byte tail pad inserted by the compiler.
    // <<< the total struct size is a multiple of the biggest element.
    // <<< This ensures alignment if used in an array.
};

sizeof (blah1plusShort) == 8

Я прочитал этот ответ через 8 лет и считаю, что принятый ответ от @Robert в целом правильный, но математически неверный.

Чтобы обеспечить требования к выравниванию элементов конструкции, выравнивание конструкции должно быть не менее строгим, чем наименьшее общее кратное выравнивания ее элементов. Рассмотрим странный пример, где требования к выравниванию элементов равны 4 и 10; в этом случае выравнивание структуры - это LCM (4, 10), которое равно 20, а не 10. Конечно, странно видеть платформы с таким требованием выравнивания, которое не является степенью 2, и, следовательно, для всех практических случаев , выравнивание структуры равно максимальному выравниванию ее элементов.

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

Обновление: как указано @chqrlie в комментарии, стандарт C не допускает нечетных значений выравнивания. Однако этот ответ по-прежнему доказывает, почему выравнивание структуры является максимумом выравнивания ее элементов, просто потому, что максимум оказывается наименьшим общим кратным, и, таким образом, элементы всегда выровнены относительно общего кратного адреса.