Utilisez la méthode la plus simple et la plus compréhensible pour calculer la taille d'une structure.

Le calcul de la taille d'une structure doit suivre le principe d'alignement des octets.

Par défaut, l'alignement des octets d'une structure satisfait généralement trois règles :

  • 1) La première adresse d'une variable de structure doit être divisible par la taille de son membre de type fondamental le plus large ;
  • 2) Le décalage de chaque membre par rapport à la première adresse de la structure est un multiple entier de la taille du membre ; si nécessaire, le compilateur ajoute des octets de remplissage entre les membres (ajout interne) ;
  • 3) La taille totale de la structure est un multiple entier de la taille de son membre de type fondamental le plus large ; si nécessaire, le compilateur ajoute des octets de remplissage après le dernier membre (remplissage final).

En fait, pour l'instant, ignorez ces trois règles. Ma méthode ne nécessite que de se souvenir de la troisième : la taille de la structure doit être un multiple entier de la plus grande taille en octets parmi ses membres.

Regardez d'abord les deux structures définies ci-dessous :

struct {   char a;   short b;   char c; }S1;

struct {  char  a;  char  b;  short c; }S2;

Obtenus respectivement par test du programme :sizeof(S1)=6 , sizeof(S2)=4。

Remarque : pourquoi le simple fait de changer l'ordre des membres de la structure produit-il des résultats différents ?

Solution :

  • (1) Trouvez d'abord la plus grande taille en octets parmi les variables membres. On peut voir que pour S1 et S2, le plus grand est short, qui occupe 2 octets ;
  • (2) Par conséquent, désormais, 2 octets sont utilisés comme standard. Autrement dit, chaque membre n'a besoin que de 2 octets au maximum, et le reste est rempli par des octets de remplissage. Notez que dans le schéma ci-dessous, une case représente un octet ;
  • (3) Alors, dessinez d'abord 2 cases, puis regardez l'ordre des membres et augmentez pas à pas, avec 2 comme base d'incrément à chaque fois.
Pour S1, l'ordre estchar->short->char :

Donc pour S1, la taille de la structure est 2*3=6. Quant à la raison pour laquelle l'octet supplémentaire du deuxième char n'est pas supprimé, cela suit la troisième règle : la taille de la structure doit être un multiple entier de la taille en octets la plus grande parmi les membres.

S1=2*3=6

Pour S2, dessinez aussi un schéma, mais l'ordre estchar->char->short：

S2=2*2=4

En utilisant cette méthode, regardez une autre structure comme ceci :

struct stu1
{
    int i;
    char c;
    int j;
};

Évidemment, la plus grande taille en octets est 4. Ordre : int char int :

Parce que int occupe 4 octets, et que char en occupe déjà 1, ce qui ne suffit pas, donc ces 3 octets doivent être des octets de remplissage supplémentaires.

Stu1=3*4=12

Et si on le changeait ?

struct stu2
{
    int i;
    int j;
    char  c；
}；
Stu2=3*4=12

Regardez un autre cas : lorsqu'une variable membre de structure est une autre structure, ajoutez simplement la structure membre dans son ensemble.

typedef struct A
{
    char a1;
    short int a2;
    int a3;
    double d;
};

A=16

typedef struct B
{
    long int b2;
    short int b1;
    A a;
};

Pour B, ignorez d'abord A a, c'est-à-dire supprimez le membre A a et calculez la taille de la structure B comme étant 8, donc le résultat final est 8+16=24 ; 24 est le résultat final.

Adresse d'origine : https://www.cnblogs.com/lykbk/archive/2013/04/02/krtmbhrkhoirtj9468945.html