champs de structure

Version imprimable

champs de structure

bonjour,
je comprend pas ce que veulent dire les :4 :2 devant les champs ?

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
 
struct OmTcData {
    // Byte 0:
    // Frame number (units):
    uint framesUnits:4;
    // Binary group 1:
    uint binaryGroup1:4;
    // Byte 1:
    // Frame number (tens):
    uint framesTens:2;
    // TRUE ==> drop-frame, FALSE ==> non-drop-frame, for FldRate59_94Hz;
    // reserved, for FldRate50Hz:
    uint dropFrame_59_94:1;
    // Color-frame marker:
    uint colorFrame:1;
    // Binary group 2:
    uint binaryGroup2:4;
    }

21/08/2007, 15h00
amaury pouly

Cela veut dire que tu créé un champ de bit, le :x indique que la variable tient sur x bit. Ainsi cela permet de *découper* un entier en plusieurs morceaux de y bits.
21/08/2007, 15h03
coax81

mais quand je fais :

Code:

uint framesUnits:4;

ce la veu dire que framesUnits est de taille 4 bits , ou bien de taille 4* uint ??
21/08/2007, 15h31
screetch

4 bits

c'est un indice au compilateur, ce n'est pas forcement supporte il me semble, mais dans la mesure du possible il essayera d'allouer 4 bits pour ce champ et de laisser de la place pour le reste derriere.

en fait quand tu fais:
Code:

1 2 TYPE var : TAILLE;
Cela veut dire que var est un morceau de TYPE de taille TAILLE bits.
Exemple:
Code:

1 2 3 4 5 6 7 8 9 10 struct St { // commence un entier 32-bit que l'on va découper en deux morceaux pour simplifier son accès. uint partie1 : 16; uint partie2 : 16; // commence un entier 16-bit que l'on va découper ushort partie3 : 4; ushort partie4 : 12; };
Je ne sais pas si c'est très clair...

21/08/2007, 15h33
screetch

ca ne marche qu'avec (unsigned) int je crois.

doc de PC-Lint :

46 Field type should be int -- Bit fields in a structure
should be typed unsigned or int. If your compiler allows
other kinds of objects, such as char, then simply suppress
this message.

ca revient un peu a faire une union d'element dans le principe:

Code:

1
2
3
4
5
6
7
8
typedef union
{
    struct {
        WORD IP_Dst_Cte_field;
        WORD IP_Dst_link;
    } detail;
    DWORD IP_Dst_Add;
}IP_DEST_ADD;

22/08/2007, 13h47
NiamorH

Et bien non justement, d'après ce que je comprends de ce qui a été dis plus haut, tous les champs de la structure seront utilisables en même temps, ce qui n'est pas vrai pour l'union. J'imagine par contre que cela engendre une petite perte de rapidité à l'utilisation, mais on gagne en espace mémoire ?
22/08/2007, 14h22
koala01
Salut,

A non, une union, c'est permettre à une même valeur d'être représentée de manière différente:

Si on considère qu'un int (32 bits) fait quatre char (8 bit) et qu'un double en fait 8 (64 bits), on peut écrire
Code:

1 2 3 4 5 6 union MyUnion { char caract; int entier; double reel; };
Ce qui fera que, quand tu déclarera une variable de de type MyUnion, sa taille sera la taille nécessaire à la représentation de l'élément le plus grand (ici, la taille d'un double ;)) mais que tu peux envisager de ne mettre que les 8 bits d'un char ou que les 16 d'un int (en "perdant" l'espace restant) et que tu accepte d'envisager le fait que l'on puisse convertir n'importe quel type en un autre, en perdant une information si la taille du type d'origine est plus importante que celle du type de destination.

Par contre, le bitfield va permettre au compilateur d'organiser un peu mieux la mémoire:

Si tu n'a besoins que de, mettons, 8 fois 2 bits - ce qui, l'un dans l'autre, en fait 16, soit la taille (sur mon architecture) d'un int:

Si tu crées une structure du genre de
Code:

1 2 3 4 5 6 7 8 9 10 11 12 struct MaStruct { int /* ou char, car deux bits tiennent dans un char*/ var1; int var2; int var3; int var4; int var5; int var6; int var7; int var8; };
la taille totale de la structure sera de... 8* la taille d'un int =8*16 bits=128bits (ou 8 fois la taille d'un char= 8 * 8 bits=64 bits)... tout cela pour n'en utiliser... que 16 :P

Ca fait pas mal de place perdue :aie:

Par contre, si tu travaille avec un bitfield, sous une forme proche de
Code:

1 2 3 4 5 6 7 8 9 10 11 struct Mastruct2 { int var1:2; int var2:2; int var3:2; int var4:2; int var5:2; int var6:2; int var7:2; int var8:2; };
le compilateur saura qu'il doit "découper" la mémoire en tranche de deux bits, et donc, qu'il peut faire tenir les 8 variables... sur la taille d'un int comme le montre le code
Code:

1 2 3 4 5 6 7 int main() { cout<<"taille de Mastruct "<<sizeof(MaStruct)<<endl <<"taille de MaStruct2 "<<sizeof(Mastruct2)<<endl <<"taille d'un int "<<sizeof(int )<<endl; return 0; }
si tu déclares les deux structures ci-dessus ;)