Discussion :

[shenril]

Bonjour je suis en train de faire une structure qui ne doit pas depasser les 32 bits et donc les 4 octets
Cette structure ressemble à ça :

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
typedef enum codeop{ILLOP, NOP, LOAD, STORE, ADD, SUB, BRANCH, CALL, RET, PUSH, POP, HALT} cop;
 
typedef struct instr{
    unsigned code:6;
    unsigned I:1;
    unsigned X:1;
    unsigned rc:4;
    union operande{
        unsigned op:20;
        struct index{
            unsigned rx:4;
            unsigned offset:16;
        }index;
    }operande;
}instr;

Dans mon compte ça fait bien 32 mais un sizeof() m'indique que ma structure fait 8 octets et donc 64 bits
Y'aurait'il un moyen de résoudre ce problème? Je sais que mes tailles de champs ne sont pas très catholique mais je n'ai pas eu trop le choix

Merci d'avance pour vos idées!!!!

[nicolas.sitbon]

Il n'y a rien de portable que tu puisses faire; en revanche tu peux lire la doc de ton compilateur et utliser une extension de celui ci. Sous GCC par exemple tu as l'attribut "packed".

[diogene]

Dans mon compte ça fait bien 32 mais un sizeof() m'indique que ma structure fait 8 octets et donc 64 bits
Y'aurait'il un moyen de résoudre ce problème? Je sais que mes tailles de champs ne sont pas très catholique mais je n'ai pas eu trop le choix

C'est lié à la présence de l'union à l'intérieur de la structure instr. Il ne te faudrait avoir que des champs de bits sans les structurer

Code :

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

1
2
3
4
5
6
7
typedef struct instr{
    unsigned code:6;
    unsigned I:1;
    unsigned X:1;
    unsigned rc:4;
   unsigned op:20;
}instr;

[Mat.M]

je partage la solution de Diogène

[cmoibal]

Et ça dépend aussi de arrangement des champs dans la structure par le compilateur....

Je pense que si tu sais exactement la taille d'un paquet, un tableau sera une solution très simple .... et ainsi ton code sera portable, et facilement maniable !!!!

[diogene]

Si tu veux des champs de bits, tu peux peut-être envisager une solution du type :

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
typedef union instr
{
    struct 
    {
       unsigned code:6;
       unsigned I:1;
       unsigned X:1;
       unsigned rc:4;
       unsigned op:20;
    } op;
    struct 
   {
       unsigned code:6;
       unsigned I:1;
       unsigned X:1;
       unsigned rc:4;
       unsigned unsigned rx:4;
       unsigned offset:16;
   } index;
}instr;

où les deux structures de l'union partagent un début commun.

[ram-0000]

Une autre solution, si ta structure doit faire 32 bits, tu utilises un unsigned long (32 bits donc) et ensuite tu travailles uniquement avec des masques et des opérateurs logiques. Ainsi tu es sûr que quelquesoit le compilateur, la plateforme et autre, tu auras 32 bits.

[nicolas.sitbon]

Une autre solution, si ta structure doit faire 32 bits, tu utilises un unsigned long (32 bits donc) et ensuite tu travailles uniquement avec des masques et des opérateurs logiques. Ainsi tu es sûr que quelquesoit le compilateur, la plateforme et autre, tu auras 32 bits.

Le problème est que rien ne garanti que unsigned long vaut 32 bits et même si c'est le cas, il reste le problème du padding.
On peut résoudre le problème du padding en déclarant un

Code :

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

unsigned char [4]

[shenril]

Merci bcp pour vos réponses , je vais essayer tout ça et voir si ça marche

[ram-0000]

Le problème est que rien ne garanti que unsigned long vaut 32 bits et même si c'est le cas, il reste le problème du padding.

Je pense que la norme doit tout de même définir un type qui fait 32 bits, peut être pas unsigned long effectivement mais un autre type sûrement. Non ?

[nicolas.sitbon]

Je pense que la norme doit tout de même définir un type qui fait 32 bits, peut être pas unsigned long effectivement mais un autre type sûrement. Non ?

Oui tu as raison, il y a uint32_t défini dans stdint.h, mais là encore, il faut voir ce que dis la norme concernant le padding et même la disponibilité de ce type.

[Emmanuel Delahaye]

Bonjour je suis en train de faire une structure qui ne doit pas depasser les 32 bits et donc les 4 octets
Cette structure ressemble à ça :

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
typedef enum codeop{ILLOP, NOP, LOAD, STORE, ADD, SUB, BRANCH, CALL, RET, PUSH, POP, HALT} cop;
 
typedef struct instr{
    unsigned code:6;
    unsigned I:1;
    unsigned X:1;
    unsigned rc:4;
    union operande{
        unsigned op:20;
        struct index{
            unsigned rx:4;
            unsigned offset:16;
        }index;
    }operande;
}instr;

Dans mon compte ça fait bien 32 mais un sizeof() m'indique que ma structure fait 8 octets et donc 64 bits
Y'aurait'il un moyen de résoudre ce problème?

Ton code n'est absolument pas portable. Si tu changes de machine, de système, de compilateur ou d'options, plus rien ne fonctionne.

Sur ma machine (Wintel XP):

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
 
/* http://delahaye.emmanuel.free.fr/clib/ */
#include "ed/inc/prt.h"
#include<stdio.h>
 
typedef struct instr
{
   unsigned code:6;
   unsigned I:1;
   unsigned X:1;
   unsigned rc:4;
   unsigned op:20;
}
instr;
 
int main (void)
{
   instr instruction;
 
   PRT_SIZE (instruction);
   return 0;
}

donne

Code :

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

1
2
3
4
 
sizeof instruction  =  4 bytes (32-bit)
 
Press ENTER to continue.

[Emmanuel Delahaye]

Une autre solution, si ta structure doit faire 32 bits, tu utilises un unsigned long (32 bits donc) et ensuite tu travailles uniquement avec des masques et des opérateurs logiques. Ainsi tu es sûr que quelquesoit le compilateur, la plateforme et autre, tu auras 32 bits.

C'est ce que je ferais...

C'est la seule solution portable (ici, il s'agit d'une interface externe : champs de bits inappropriés, pour ne pas dire interdits !).

http://emmanuel-delahaye.developpez.com/clib.htm
Module BITS

Le tout enrobé dans des macros ou fonctions spécialisées et c'est tout...

Ce ne sera pas plus lent que les champs de bits et au moins ce sera portable...