Discussion :

[fab13]

Bonsoir,

je comprends pourquoi je dois prendre un alignement mémoire pour une structure égal à la taille la plus grande parmi ses attributs.

Maintenant, j'aimerais savoir pourquoi, une fois cet alignement choisi, je dois faire du padding de telle manière que la taille totale de la structure soit un multiple de l'alignement de cette structure et non pas multiple de la taille d'un "mot proceseur".

Voici un exemple :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
    #include <stdio.h>
 
    // Alignment requirements
    // (typical 32 bit machine)
 
    // char         1 byte
    // short int    2 bytes
    // int          4 bytes
    // double       8 bytes
 
    typedef struct structc_tag
    {
       char        c;
       double      d;
       int         s;
    } structc_t;
 
    int main()
    {
       printf("sizeof(structc_t) = %d\n", sizeof(structc_t));
 
       return 0;
    }

On pourrait penser à priori que la taille de structc_t est égal à 20 avec :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
       char        c;
       char Padding1[7]
       double      d;
       int         s;

parce que nous avons pris un alignement de structure égal à 8 (double d).

En fait, la taille totale est égale à 24 parce que 20 n'est pas un multiple de 8 et nous devons faire du padding après "int s" ( char Padding2[4] ).

Mais si je prends un tableau de cette structure (sans ajouter le deuxième padding Padding2[4]), les premiers éléments de chaque structure seront à des bonnes adresses pour un processeur 32 bits ( 0, 20, 40 ...) parce que 0, 20, 40 sont des multiples de 4, où 4 est la taille d'un "mot processeur" 32 bits.

Donc, Pourquoi je dois faire ce deuxième padding pour avoir une taille totale multiple de 8 (taille de l'alignement de la structure), c'est-à-dire 24 ici dans cet exemple alors qu'on pourrait se contenter de n'avoir qu'une taille totale de 20 (tout en étant ainsi multiple de 4 et ainsi avoir un tableau de structc_t contigu en mémoire par rapport à un processeur 32 bits) ?

Merci pour votre aide

[bacelar]

Faites le calcul de l'alignement du champ "d" du 2ème élément d'un tableau de structc_t.

Avec l'approche du compilateur, il sera sur sa frontière "naturelle" (8).

Avec votre approche, il ne sera pas aligné sur sa frontière "naturelle" (8) mais sur 4 et demandera plus de décodage sur les plateformes souples et puissantes et carrément une erreur sur les machines rustres.

Ceci n'est qu'un comportement par défaut qui donne une solution correct même si on conçoit ses structures à l'arrache. Mais il est tout à fait possible de changer ces réglages à coup de "#pragma pack" et consort si on sait ce que l'on fait.