Discussion :

[coax81]

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

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
 
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;
    }

[amaury pouly]

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

[coax81]

mais quand je fais :

Code :

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

  uint framesUnits:4;

ce la veu dire que framesUnits est de taille 4 bits , ou bien de taille 4* uint ??

[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.

[amaury pouly]

en fait quand tu fais:

Code :

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

1
2
 
TYPE var : TAILLE;

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

Code :

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

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...

[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.

[rikau2]

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

Code :

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

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;

[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 ?

[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 :

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

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 :

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

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

Ca fait pas mal de place perdue

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

Code :

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

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 :

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

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