Discussion :

[oodini]

Bonjour,

Je connais très peu cette notion de padding.

D'après ce que j'ai cru comprendre, tout champ d'une structure doit commencer à un multiple de sa taille. Si on force la largeur des membres via un champs de bits via la syntaxe suivante :

Code :

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

1
2
3
4
5
6
class A
{
    ....
    uint_32t mValue : 5;
    ....
};

Puis-je me contenter d'enchaîner les membres, en m'assurant de tomber pile sur les multiples de 32 bits (ou 64 bits) ?

Si, sur une archi 32 bit, je n'ai besoin que de 30 bits, dois-je explicitement faire un champ de 2 bits que je n'utiliserai pas ?

Dois-je découper ma structure en plusieurs structure, pour limiter la taille de la structure à 32 ou 64 bits ?

Si je travaille en 64 bits, et que j'ai besoin d'une structure à 90 bits, la meilleure solution est-elle de faire une classe de 64 bits, et une autre de 32 bits (cette dernière comportant éventuellement des bits de remplissage) ?

[stardeath]

la notion de padding, d'alignement et autre c'est surtout pour optimiser les accès (et pour éviter les crashs sur certaines architectures).

si tu as besoin d'une structure compacte, utilise un #pragma pack.

le problème de tes questions c'est que c'est dépendant du compilateur, le mieux, c'est de tester en situation, et tu verras ce que ton compilateur te sortira comme tambouille.

[jblecanard]

la notion de padding, d'alignement et autre c'est surtout pour optimiser les accès (et pour éviter les crashs sur certaines architectures).

C'est aussi très utile pour faire de la sérialisation/désérialisation proprement, les données pouvant se transmettre d'une architecture à une autre ! Un #pragma pack(1) est alors bien utile dans beaucoup de cas.

Oodini: Ce que tu "dois" faire va dépendre de ton objectif. Si tu veux des structures les plus compactes possibles, pragma pack suffira. Tu n'as pas besoin de remplir toi même les octets manquants s'il y en a. Quel résultat cherches-tu à obtenir ?

[oodini]

C'est effectivement pour faire de la déserialisation.

Et j'aimerais si possible une solution Windows/Linux.

Mais vous dites que #pragma pack rend inutile de préciser le nombre de bits ?

[jblecanard]

De toute façon, tu n'alignes pas sur des bits mais sur des octets. La notion de taille (telle que la renvoie sizeof par exemple) se réfère aux octets. Tu peux bien sûr travailler quand même au bit près (encore que, je ne suis même pas sûr) mais ça complique pas mal la tâche ^^.

#pragma pack(1) va aligner ta structure sur un octet, ce qui signifie que tu n'auras pas de padding.

Lorsque tu travailles sur la sérialisation/désérialisation, prend garde aux problèmes d'endianess et au conventions en vigueur dans le protocole utilisé. Il me semble par exemple que la convention en vigueur pour les données qui transitent sur un réseau est d'utiliser Big Endian alors que la plupart des plateformes (dont x86) sont en Little Endian (je ne suis pas spécialiste en la matière, pas taper si j'ai dit une connerie).

Peut-être que protobuf peut te rendre service.

[Médinoc]

Le mieux pour désérialiser indépendamment de la plate-forme, c'est de ne reposer ni sur pack ni sur l'endianness, et toujours désérialiser byte par byte (voir ce thread par exemple).

Par contre, si tu sacrifies l'indépendance à la plate-forme, le fait d'utiliser directement une structure packée et compter sur la plate-forme pour avoir la bonne endianness permet d'accéder au contenu du fichier directement avec un mapping mémoire, ce qui est super pour les paresseux.

La vie est une question de compromis...