Désactiver le rembourrage de la structure en C sans utiliser de pragma

Sur certaines architectures, la CPU elle-même s'opposera si elle est invitée à travailler sur des données mal alignées. Pour contourner ce problème, le compilateur pourrait générer plusieurs instructions de lecture ou d'écriture alignées, de déplacer et de scinder ou de fusionner les différents bits. Vous pouvez raisonnablement vous attendre à ce qu'elle soit 5 ou 10 fois plus lente que la manipulation des données alignée. Mais la norme ne nécessite pas que les compilateurs soient prêts à faire cela ... Compte tenu du coût de la performance, il n'est tout simplement pas assez de demande. Les compilateurs prenant en charge le contrôle explicite sur le rembourrage offrent leurs propres pragmes précisément parce que les pragmes sont réservés aux fonctionnalités non standard.

Si vous devez travailler avec des données pératurées, envisagez d'écrire vos propres routines d'accès. Vous voudrez peut-être expérimenter des types nécessitant moins d'alignement (par exemple, utilisez Char / int8_t), mais il est toujours possible que par exemple. La taille des structures sera arrondi aux multiples de 4, qui frustreraient des structures d'emballage étroitement, auquel cas vous aurez besoin de mettre en œuvre votre propre accès pour la région de la mémoire complète.

Soit vous laisser compiler faire un rembourrage, soit le dire de ne pas utiliser #pragma, soit vous utilisez simplement un tas d'octets comme un tableau de caractères, et vous construisez toutes vos données par vous-même (changeant et ajout d'octets). C'est vraiment inefficace mais vous contrôlerez exactement la mise en page des octets. J'ai fait cela parfois préparant des paquets de réseau à la main, mais dans la plupart des cas, c'est une mauvaise idée, même si elle est standard.

Si vous voulez vraiment des structures sans rembourrage: définissez des types de données de rechange pour courts, int, long, etc., en utilisant des structures ou des classes composées uniquement de 8 octets bits. Composez ensuite vos structs de niveau supérieur à l'aide des types de données de remplacement.

La surcharge de l'opérateur de C ++ est très pratique, mais vous pourriez obtenir le même effet dans C utilisant des structures au lieu de classes. Les ci-dessous des implémentations de moulage et d'affectation supposent que la CPU peut gérer des entiers de 32 bits malalignés, mais d'autres implémentations pourraient accueillir des processeurs plus strictes. P>

Voici l'exemple de code: P>

#include <stdint.h>
#include <stdio.h>

class packable_int { public:

  int8_t b[4];

  operator int32_t () const       { return *(int32_t*) b; }
  void operator =  ( int32_t n )  { *(int32_t*) b = n; }

};

struct SA {
  int8_t   c;
  int32_t  n;
} sa;

struct SB {
  int8_t        c;
  packable_int  n;
} sb;

int main () {
  printf ( "sizeof sa  %d\n", sizeof sa );    // sizeof sa  8               
  printf ( "sizeof sb  %d\n", sizeof sb );    // sizeof sb  5               
  return 0;
}

Nous pouvons désactiver le rembourrage de la structure en C Programme C en utilisant l'une des méthodes suivantes.

-> Utilisez __ attribut __ ((emballé)) code> derrière la définition de la structure. Pour par exemple, P>

struct node {
    char x;
    short y;
    int z;
} __attribute__((packed));