Lire des mots de 16 bits

Version imprimable

10/11/2008, 08h40
oc_alex86

Lire des mots de 16 bits

Bonjour,

je souhaite lire des mots de 16 bits dans un fichier afin de le convertir ensuite en un entier.
Comment procéder pour lire ces bits ?
10/11/2008, 10h04
matafan
Code:

1 2 3 4 if (1 != fread(buf, 2, 1, file)) { perror("fread"); ... }
Attention évidemment aux problèmes d'endianness.

Bonjour,

Il faut d'abord savoir si les mots sont stockés sous forme de texte ou binaire.
Texte :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
/* définition d'un entier court, de taille 16 bits sur x86 
(cf FAQ pour plus de précisions) */
short int i; 
int ret;
/* ouverture en mode texte */
FILE * f = fopen("mon_fichier", "r");
if(NULL == f) {
    /* gestion de l'erreur d'ouverture */
} else {
    ret = fscanf(f, "%hd", &i);
    if(1 != ret) {
        /* gestion de l'erreur de lecture */
    }
}

Binaire :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
/* définition d'un entier court */
short int i; 
int ret;
/* ouverture en mode lecture binaire */
FILE * f = fopen("mon_fichier", "rb");
if(NULL == f) {
    /* gestion de l'erreur d'ouverture */
} else {
    ret = fread(&i, sizeof(i), 1, f);
    if(1 != ret) {
        /* gestion de l'erreur de lecture */
    }
}

10/11/2008, 16h26
oc_alex86

Merci pour vos réponses.

En fait je souhaite lire un fichier quelconque afin de le crypter (je souhaite donc faire des opérations sur les bits). Une lecture binaire est donc nécessaire non ?

J'aurais aussi une autre question :
comment faire pour des mots plus grands (eg. 512 bits) ?
10/11/2008, 19h55
matafan

Citation:

Envoyé par oc_alex86

J'aurais aussi une autre question :
comment faire pour des mots plus grands (eg. 512 bits) ?

Tu changes le 2 en 512...
10/11/2008, 20h55
oc_alex86

Merci beaucoup
11/11/2008, 02h15
Emmanuel Delahaye

Citation:

Envoyé par matafan

Tu changes le 2 en 512...

Le monsieur, il a dit bits, pas octets...
12/11/2008, 18h28
oc_alex86

Merci, j'avais compris ;)

pour lire des champs de bit si tu sais par exemple qu'il y a dans ton fichier un nombre entier sur 4 octets suivit par exemple d'un nombre entier sur 2 octets puis pour finir une chaine de caractere de 5 caracteres chacuns sur 1 octets tu peux faire des lectures de structures directement en faisant :
Code:

1 2 3 4 5 6 7 typedef struct myread { int first; short second; char third[5]; } __attribute__ ((packed)) myread;
attention quand meme selon l'architecture ou tu te trouves, les tailles des types peuvent varié, ceci n'est qu'un exemple dans le cas general.

ensuite tu peux "lire" directement ta structure dans ton fichier si les bits sont cote à cote sans separateur evidement.

exemple :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 myread test; /* définition d'un entier court */ int ret; /* ouverture en mode lecture binaire */ FILE * f = fopen("mon_fichier", "rb"); if(NULL == f) { /* gestion de l'erreur d'ouverture */ } else { ret = fread(&test, sizeof(test), 1, f); //d'hab pour faire ca j'utilise des appels plus bas niveau open et read, je prefere controler au plus pret ce que fais la machine, mais je pense que ca fonctionne pareil avec fopen et fread if(1 != ret) { /* gestion de l'erreur de lecture */ }
tu peux aussi si par exemple tu veux lire 8 bits cote à cote separement
utilisé ce que l'on appel des bitfields
Code:

1 2 3 4 5 6 7 8 9 10 11 12 struct a_byte { unsigned int bit0:1; unsigned int bit1:1; unsigned int bit2:1; unsigned int bit3:1; unsigned int bit4:1; unsigned int bit5:1; unsigned int bit6:1; unsigned int bit7:1; } __attribute__((packed));
le ': x' specifie au compilateur que tu ne veux utiliser que x bit sur le type definit. le packed te permet d'etre sur qu'il n'y aura pas entre les champs de bits tampons etc.
Attention au probleme d'allignement avec ce genre d'astuce sur certaine architecture par contre.

si tu veux plus d'informations regarde du coté des attributes possible et leur utilités, et les bitfields. Je ne garantie pas la compilation de ces codes, je les ai ecris "on the fly", je n'ai pas de compilateur C sous la main actuellement pour tester. Ce n'est cas titre d'information :)

13/11/2008, 14h49
Emmanuel Delahaye

Citation:

Envoyé par oniric

pour lire des champs de bit si tu sais par exemple qu'il y a dans ton fichier un nombre entier sur 4 octets suivit par exemple d'un nombre entier sur 2 octets puis pour finir une chaine de caractere de 5 caracteres chacuns sur 1 octets tu peux faire des lectures de structures directement en faisant :

Pour de multiples raison (endianness, padding, ordre de champs de bits), rien de ceci n'est portable. A éviter.
13/11/2008, 14h53
oniric

certe je l'ai bien precisé dans mon message, mais je trouve cela bien utile quand meme si le code n'a pas besoin d'etre portable sur toutes les architectures. De plus il y a moyen de rendre cela portable. Ceci n'est qu'un exemple.
13/11/2008, 14h58
Emmanuel Delahaye

Citation:

Envoyé par oniric

De plus il y a moyen de rendre cela portable.

Non. Pas sur une architecture 16-bit ou 32-bit dure (j'en vois qui ricanent... OK) comme 68k ou PowerPC.

Quand aux champs de bits, selon les architectures, il peuvent être totalement inversés, avoir des largeurs différentes, ce qui est infernal...
13/11/2008, 15h17
oniric

dans ce cas la, c'est la lecture de bit en general qui est infernal et non portable, car que l'on utilise un champ de bit ou un short de 2 octets comme vous faites au dessus n'est pas portable non plus, dans un cas le masque pour le short sera par exemple 0xFF00 et dans un autre 0x00FF si l'on est en little ou big endian.

Ceci n'est en rien une aggression, plutot une curiosité de ma part, car j'en viens à me poser la question aussi.
est ce que le 1er code (qui a mes yeux mise à part le coté portabilité est plus du bricolage) est portable ? si l'on change d'archi, donc de taille de type, donc d'endianness aussi imaginons ?
13/11/2008, 16h49
3DArchi

Vu sa question, j'ai l'impression que ce qui l'intéresse est la lecture de mots et pas leur interprétation. Quand il demande à lire 2 octets, il ne se soucie pas de savoir s'il s'agit d'un short (...) mais il veut seulement 2 octets. D'où le fread 'brut' avec le nombre d'octets voulus. Par contre avec une structure ou un champs de bit, là tu interprète ce que tu lis. D'où risque!

Citation:

Envoyé par oniric

est ce que le 1er code (qui a mes yeux mise à part le coté portabilité est plus du bricolage) est portable ? si l'on change d'archi, donc de taille de type, donc d'endianness aussi imaginons ?

Pour être portable, il faut définir un format de flux (fichier, réseau) indépendant de l'architecture.

Une manière simple est de définir le format de flux selon la norme 'réseau', c'est à dire "MSB en tête" :
Code:

1 2 3 4 5 Entier de 16-bit : [0] octet MSB [1] octet LSB
ensuite pour écrire dans le flux, on fait :
Code:

1 2 3 4 5 unsigned data = 0x1234; fputc ((data >> (8 * 1), fp); /* MSB : 0x12 */ fputc ((data >> (8 * 0), fp); /* LSB : 0x34 */
a la lecture, on fait le contraire :
Code:

1 2 3 4 5 unsigned data = 0; data |= (fgetc (fp) << (8 * 1)); /* MSB : 0x1200 */ data |= (fgetc (fp) << (8 * 0)); /* LSB : 0x1234 */
En fait, c'est un peu plus compliqué, car il faut surveiller EOF, mais le principe est là... On peut aussi passer par un tableau de unsigned char que l'on ecrit / lit à la main et utiliser fwrite() / fread()...

La version 32-bit :
Code:

1 2 3 4 5 6 7 Entier de 32-bit : [0] octet MSB [1] octet [2] octet [3] octet LSB
Code:

1 2 3 4 5 6 7 unsigned long data = 0x12345678; fputc ((data >> (8 * 3), fp); /* MSB : 0x12 */ fputc ((data >> (8 * 2), fp); /* : 0x34 */ fputc ((data >> (8 * 1), fp); /* : 0x56 */ fputc ((data >> (8 * 0), fp); /* LSB : 0x78 */
Code:

1 2 3 4 5 6 7 unsigned long data = 0; data |= (fgetc (fp) << (8 * 3)); /* MSB : 0x12000000 */ data |= (fgetc (fp) << (8 * 2)); /* : 0x12340000 */ data |= (fgetc (fp) << (8 * 1)); /* : 0x12345600 */ data |= (fgetc (fp) << (8 * 0)); /* LSB : 0x12345678 */