Когда мы не должны использовать пакет #pragma?

Разработчик прошивки здесь. #pragma pack очень знакомая территория. Я объясню.

Как правило, вы не должны использовать #pragma pack. Да, это уменьшит размер ваших структур в памяти, поскольку устраняет все отступы между элементами структуры. Но это может сделать доступ к этим элементам намного более дорогим, поскольку они могут больше не соответствовать требуемому выравниванию. Например, в архитектурах ARM 4-байтовые целые обычно должны быть выровнены по 4 байтам, но в упакованной структуре это может быть не так. Это означает, что компилятору необходимо добавить дополнительные инструкции для безопасного доступа к этому элементу структуры, или разработчик должен обращаться к нему побайтно и вручную восстанавливать целое число. В любом случае это приводит к большему количеству кода, чем выровненный доступ, поэтому ваша структура становится меньше, но ваш код доступа потенциально заканчивается медленнее и больше.

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

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

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

В большинстве архитектур базовый доступ должен соответствовать выравниванию данных, к которым осуществляется доступ.

Это означает, что если у вас есть 32-битное значение, вы можете эффективно получить к нему доступ, если оно хранится по адресу, который делится на четыре.

Если вы используете #pragma pack, расположение переменной может быть любым, и компилятор должен обращаться к элементу по частям и объединять их вместе. В частности, ниже приведен сгенерированный код для чтения обычного int на V850E (популярный микроконтроллер в мире встраиваемых систем):

LD.W        a[zero],r5

Соответственно, следующий код для доступа к int в упакованной структуре:

LD.BU       g+3[zero],r1
SHL         8,r1
LD.BU       g+2[zero],r6
OR          r1,r6
SHL         8,r6
LD.BU       g+1[zero],r7
OR          r6,r7
SHL         8,r7
LD.BU       g[zero],r1
OR          r7,r1

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

Я настоятельно рекомендую вам вообще не использовать '#pragma pack', за исключением случаев крайней необходимости. Если у вас есть контроль над определением структуры, существуют методы, позволяющие убедиться, что макет структуры не содержит отступов. Если нет, лучшим подходом будет копирование любых невыровненных данных в новую, выровненную структуру и использование ее в вашем приложении.

Директива пакета #pragma предлагает способ выполнить это требование. Эта директива определяет выравнивание упаковки для элементов конструкции. Прагма вступает в силу при первом объявлении структуры после появления pragma. Компилятор Turbo C/C++ не поддерживает эту функцию, компилятор VC++ поддерживает.

Вы никогда не должны использовать #pragma pack или подобное. Это всегда приводит к опасным проблемам переносимости. Например, рассмотрим структуру:

struct foo {
    char a;
    int b;
} bar;

и позвоните scanf("%d", &bar.b). На машинах без неправильного доступа это приведет к ошибке (или повреждению памяти!) внутри scanf! Это связано с тем, что &bar.b на самом деле не является действительным int * - оно смещено, но код, которому он передается, не может знать об этом и работать с этим, как компилятор, если бы вы только что написали bar.b = 42;.

Единственное предназначенное использование упакованных структур — это сериализация, но это также приводит к непереносимости файлов. Вы должны просто написать правильные функции сериализации.