#pragma pack effet

#pragma pack demande au compilateur de pack membres de structure avec notamment l'alignement. La plupart des compilateurs, lorsque vous déclarez une structure, va insérer un rembourrage entre les membres afin de s'assurer qu'ils correspondent aux adresses appropriées dans la mémoire (en général un multiple du type de la taille). Cela permet d'éviter la dégradation de la performance (ou une erreur pure et simple) sur certaines architectures associées à l'accès aux variables qui ne sont pas alignés correctement. Par exemple, étant donné entiers de 4 octets, et la structure suivante:

struct Test
{
   char AA;
   int BB;
   char CC;
};

Le compilateur pourrait choisir de jeter la structure en mémoire comme ceci:

|   1   |   2   |   3   |   4   |  

| AA(1) | pad.................. |
| BB(1) | BB(2) | BB(3) | BB(4) | 
| CC(1) | pad.................. |

et sizeof(Test) serait de 4 × 3 = 12, même si elle ne contient que 6 octets de données. L'utilisation la plus courante de cas pour la #pragma (à ma connaissance), c'est quand travail avec les périphériques matériels où vous devez vous assurer que le compilateur ne pas insérer de rembourrage dans les données et chaque membre suit la précédente. Avec #pragma pack(1), la structure ci-dessus seraient disposés comme ceci:

|   1   |

| AA(1) |
| BB(1) |
| BB(2) |
| BB(3) |
| BB(4) |
| CC(1) |

Et sizeof(Test) serait de 1 × 6 = 6.

Avec #pragma pack(2), la structure ci-dessus seraient disposés comme ceci:

|   1   |   2   | 

| AA(1) | pad.. |
| BB(1) | BB(2) |
| BB(3) | BB(4) |
| CC(1) | pad.. |

Et sizeof(Test) serait de 2 × 4 = 8.

Ordre des variables dans la structure est également important. Avec des variables ordonnées comme suit:

struct Test
{
   char AA;
   char CC;
   int BB;
};

et avec #pragma pack(2), la structure serait disposé comme ceci:

|   1   |   2   | 

| AA(1) | CC(1) |
| BB(1) | BB(2) |
| BB(3) | BB(4) |

et sizeOf(Test) serait de 3 × 2 = 6.

Il indique au compilateur de la frontière pour aligner des objets dans une structure. Par exemple, si j'ai quelque chose comme:

struct foo { 
    char a;
    int b;
};

Typique d'une machine 32 bits, que vous auriez normalement "envie" d'avoir 3 octets de remplissage entre a et b de sorte que b de la terre à une limite de 4 octets pour maximiser sa vitesse d'accès (et c'est ce qui est en général le cas par défaut).

Si, toutefois, vous devez faire correspondre un externe définie structure vous voulez vous assurer que le compilateur dispose votre structure exactement selon cette définition externe. Dans ce cas, vous pouvez donner le compilateur un #pragma pack(1) dire pas pour insérer une marge entre les membres -- si la définition de la structure comprend un rembourrage entre les membres, de l'insérer de façon explicite (p. ex., généralement avec des membres nommés unusedN ou ignoreN, ou quelque chose de cet ordre).

Un compilateur peut place membres de structure sur les limites d'octets pour des raisons de performance sur une architecture particulière. Cela peut laisser inutilisé rembourrage entre les membres. La Structure de l'emballage, les membres des forces pour être contiguës.

Cela peut être important pour exemple, si vous avez besoin d'une structure pour se conformer à un fichier en particulier ou de communication où les données dont vous avez besoin de données pour être à des positions spécifiques dans une séquence. Cependant, une telle utilisation ne traite pas avec endian-ness, de sorte que, bien utilisé, il peut ne pas être portable.

Il peut aussi exactement la superposition de registre interne de la structure de certains périphériques d'e/S comme un UART ou contrôleur USB par exemple, afin que l'accès de registre par le biais d'une structure plutôt que des adresses directes.

Vous auriez probablement souhaitez uniquement utiliser cette fonction si vous étiez le codage de certains matériels (par exemple, une mémoire périphérique mappé) qui avait des exigences strictes pour enregistrer la commande et de l'alignement.

Cependant, cela ressemble à un joli outil émoussé pour parvenir à cette fin. Une meilleure approche serait de coder un mini-pilote en assembleur et de lui donner un appel C interface plutôt que de tâtonner avec cette pragma.

J'ai vu des gens l'utiliser pour faire en sorte qu'une structure est toute la ligne de cache pour éviter les faux partage dans un contexte multithread. Si vous allez avoir un grand nombre d'objets qui vont être vaguement emballé par défaut, il peut économiser de la mémoire et améliorer les performances du cache pour les emballer serré, bien que non alignés d'accès à la mémoire sera généralement ralentir les choses donc il y aura peut être un inconvénient.