L'attribut gcc ((emballé)) / #pragma pack est-il dangereux?

c'est parfaitement sûr tant que vous accédez toujours aux valeurs via la notation . (point) ou -> .

What's not safe est de prendre le pointeur de données non alignées et d'y accéder sans en tenir compte.

aussi, même si chaque élément de la structure est connu pour être non aligné, il est connu pour être non aligné d'une manière particulière , donc la structure comme un tout doit être aligné comme le souhaite le compilateur, sinon il y aura des problèmes (sur certaines plateformes, ou à l'avenir si une nouvelle méthode est inventée pour optimiser les accès non alignés).

comme dit ams ci-dessus, ne prenez pas un pointeur vers un membre d'une structure qui est emballé. C'est tout simplement jouer avec le feu. Quand vous dites __attribute__((__packed__)) ou #pragma pack(1) , ce que vous dites vraiment, c'est "Hey gcc, je sais vraiment ce que je fais."Quand il s'avère que vous ne le faites pas, vous ne pouvez pas blâmer à juste titre le compilateur.

peut-être que nous pouvons blâmer le compilateur pour sa complaisance cependant. Alors que gcc a une option -Wcast-align , elle n'est pas activée par défaut ni avec -Wall ou -Wextra . Ceci est apparemment dû au fait que les développeurs de gcc considèrent ce type de code comme un cerveau-mort " abomination " indigne d'adresser -- dédain compréhensible, mais il n'aide pas quand un programmeur inexpérimenté bourdonne dedans.

considérer ce qui suit:

struct  __attribute__((__packed__)) my_struct {
    char c;
    int i;
};

struct my_struct a = {'a', 123};
struct my_struct *b = &a;
int c = a.i;
int d = b->i;
int *e __attribute__((aligned(1))) = &a.i;
int *f = &a.i;

ici, le type de a est une structure emballée (telle que définie ci-dessus). De même, b est un pointeur vers une paniers struct. Le type de de l'expression a.i est (fondamentalement) un int l-value avec 1 byte alignement. c et d sont tous deux normaux int s. En lisant a.i , le compilateur génère du code pour l'accès non aligné. Quand vous lisez b->i , le type de b sait toujours qu'il est emballé, donc aucun problème leur soit. e est un pointeur vers un int aligné d'un octet, donc le compilateur sait déréférencer que correctement ainsi. Mais quand vous faites la tâche f = &a.i , vous stockez la valeur d'un pointeur int non aligné dans une variable alignée pointeur int -- c'est là que vous vous êtes trompé. Et je suis d'accord, gcc devrait avoir cet avertissement activé par par défaut (pas même dans -Wall ou -Wextra ).

(ce qui suit est un exemple très artificiel préparé pour illustrer.) Une utilisation majeure des structures empaquetées est où vous avez un flux de données (disons 256 octets) auquel vous souhaitez donner un sens. Si je prends un exemple plus petit, supposons que j'ai un programme tournant sur mon Arduino qui envoie via serial un paquet de 16 octets qui ont la signification suivante:

0: message type (1 byte)
1: target address, MSB
2: target address, LSB
3: data (chars)
...
F: checksum (1 byte)

alors je peux déclarer quelque chose comme

typedef struct {
  uint8_t msgType;
  uint16_t targetAddr; // may have to bswap
  uint8_t data[12];
  uint8_t checksum;
} __attribute__((packed)) myStruct;

et ensuite je peux me référer aux octets targetAddr via aStruct.targettaddr plutôt que de jouer avec l'arithmétique pointer.

maintenant avec des choses d'alignement qui se produisent, prendre un pointeur vide* en mémoire aux données reçues et le lancer à un myStruct* ne fonctionnera pas à moins que le compilateur traite la structure comme emballée (c'est-à-dire qu'il stocke les données dans l'ordre spécifié et utilise exactement 16 octets pour cet exemple). Il y a des pénalités de performance pour les lectures non alignées, donc en utilisant des structures emballées pour les données avec lesquelles votre programme travaille activement, ce n'est pas nécessairement une bonne idée. Mais lorsque votre programme est fourni avec une liste d'octets, paniers structures facilitent l'écriture des programmes d'accès aux contenus.

sinon vous finissez par utiliser C++ et écrire une classe avec des méthodes accessor et des trucs qui font de l'arithmétique pointer dans les coulisses. En bref, les structures emballées sont pour traiter efficacement des données emballées, et des données emballées peuvent être ce que votre programme est donné à travailler avec. Pour la plupart, vous codez devrait lire les valeurs hors de la structure, travailler avec eux, et les écrire en arrière quand fait. Tout le reste doit être fait en dehors de la structure emballée. Une partie du problème est la chose de bas niveau que C essaie de cacher au programmeur, et le saut de cerceau qui est nécessaire si de telles choses ont vraiment de l'importance pour le programmeur. (Vous avez presque besoin d'une construction de 'data layout' différente dans la langue de sorte que vous pouvez dire 'cette chose est de 48 bytes de long, foo se réfère aux données 13 bytes dans, et devrait être interprété et donc'; et séparée des données structurées de construire, où vous dites " je veux une structure contenant deux entiers, appelée alice et bob, et d'un flotteur appelle carol, et je n'aime pas comment la mettre en œuvre-C ces deux cas d'utilisation sont entassé dans la structure de la construction.)