Ecriture/Lecture Binaire (la suite)

Re bonsoir,

J'ai honte de poster autant de question mais le binaire c'est clairement pas mon fort donc si je le fais pas et que je n'ai pas de coup de pouce je pense rester sur cette partie très longtemps alors je tente..

Iradrille m'a passé ce jolie code qui me permet d'écrire dans l'endianess que je souhaite à peu près tout ce que je souhaite :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

#include <iostream> #include <fstream> #include <stdint.h>   template <size_t> struct unsigned_ { }; template <> struct unsigned_<1> { typedef uint8_t type; }; template <> struct unsigned_<2> { typedef uint16_t type; }; template <> struct unsigned_<4> { typedef uint32_t type; }; template <> struct unsigned_<8> { typedef uint64_t type; };   template <class T> void write(T val, std::ostream& os, bool big_endian=true) { const size_t size = sizeof(T); typedef unsigned_<size>::type type; for(size_t i=0; i<size; ++i) { type *ptr = reinterpret_cast<type*>(&val); os << static_cast<unsigned char>(((*ptr) >> (big_endian ? size-i-1: i)*8)); } }

---

Je l'ai quelque peu modifier pour que ça n'écrive pas directement dans le fichier mais plutôt en mémoire :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12

template <class T> void write(T val, char *data, bool big_endian=true) { const size_t size = sizeof(T); typedef unsigned_<size>::type type; type *ptr = reinterpret_cast<type*>(&val); unsigned char c[size]; for(size_t i=0; i<size; ++i) c[i] << static_cast<unsigned char>(((*ptr) >> (big_endian ? size-i-1: i)*8)); memcpy(data, c, size); } //et plus loins je fais le write de data dans le fichier

---

Maintenant dans data j'ai mes valeurs mais j'aimerai à présent faire la manipulation inverse, un read plus précisément.
J'ai beau tourner le truc dans tous les sens impossible que ca compile ou que ca fonctionne:

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12

emplate <class T> void read(T *val, char *data, bool big_endian=true) { const size_t size = sizeof(T); typedef unsigned_<size>::type type; type *ptr = reinterpret_cast<type*>(&val); unsigned char c[size]; memcpy(c, data, size); // Je prends la zone mémoire concernée for(size_t i=0; i<size; ++i) static_cast<unsigned char>(((*ptr) >> (big_endian ? size-i-1: i)*8)) = c[i]; // Ce que j'aurai voulu faire mais pas possible d'assigner à un cast   }

---

Merci encore pour votre aide.

Hello,

Tu peux t'en sortir en prenant T comme un unsigned char[] et en le remplissant dans le bon ordre.

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32

template <class T> void read(T& val, const unsigned char* data, bool big_endian=true) { const size_t size = sizeof(T); unsigned char *ptr = reinterpret_cast<unsigned char*>(&val); for(size_t i=0; i<size; ++i) { ptr[big_endian ? size-i-1: i] = data[i]; } }   int main() { const unsigned char data[] = { 0x00, 0x7f, 0x12, 0x01, 0x0a, 0x0b, 0x12, 0x34, 0x42, 0x28, 0x00, 0x00 }; uint16_t i16; uint8_t i8; float f;   read(i16, &data[0]); std::cout << i16 << std::endl; read(i8, &data[2]); std::cout << (unsigned int)i8 << std::endl; read(i8, &data[3]); std::cout << (unsigned int)i8 << std::endl; read(i8, &data[4]); std::cout << (unsigned int)i8 << std::endl; read(i8, &data[5]); std::cout << (unsigned int)i8 << std::endl; read(i16, &data[6]); std::cout << i16 << std::endl; read(f, &data[8]); std::cout << f << std::endl;   return 0; }

---

Merci beaucoup ça fonctionne parfaitement.
Et si maintenant l'étape d'après c'était non plus d'écrire ou de lire des octets mais plutôt des bits, serait ce complètement différent et beaucoup plus dur? (je crois connaitre la réponse et je vais pas beaucoup dormir encore moi :cry:)
Mon responsable veut qu'on puisse par exemple dans un octet mettre 8 booléens ou un booléen et un énumératif (pouvant aller de 0 a 127 donc). Plus généralement il veuille que je puisse écrire ou je veux, ce que je veux sans modifier ce qu'il y a autour. Quelqu'un a une corde ou un avis sur la manière à procéder?

C'est exactement le même principe.

Au lieu de lire/écrire des octets, on lit/écrit des bits.

Code:

---

1 2 3 4

unsigned char val = 0;   val |= (1 << 3); // mise à 1 du 4ème bit (en partant de la droite) val &= ~(1 << 3); // mise à 0 du 4éme bit (en partant de la droite toujours.)

---

Citation:

---

Envoyé par DarKaa

Merci beaucoup ça fonctionne parfaitement.
Et si maintenant l'étape d'après c'était non plus d'écrire ou de lire des octets mais plutôt des bits, serait ce complètement différent et beaucoup plus dur? (je crois connaitre la réponse et je vais pas beaucoup dormir encore moi :cry:)
Mon responsable veut qu'on puisse par exemple dans un octet mettre 8 booléens ou un booléen et un énumératif (pouvant aller de 0 a 127 donc). Plus généralement il veuille que je puisse écrire ou je veux, ce que je veux sans modifier ce qu'il y a autour. Quelqu'un a une corde ou un avis sur la manière à procéder?

---

Salut,

Tu n'as qu'à dire que, au niveau du processeur, tout est déjà écrit sous la forme de bits :D

Plus sérieusement: un ordinateur n'est jamais qu'une machine qui fonctionne (pour l'instant du moins) avec une multitude d'interrupteurs qui laissent passer le courent (ca vaut 1 par convention) ou non (ca vaut alors 0 par convention).

Un byte (que l'on traduit de manière indue par octet en francais) n'est jamais qu'une suite de (on va dire 8, uniquement pour aller avec l'octet :D, bien que ce ne soit pas forcément juste) interrupteurs pris ensemble.

Si tu veux pouvoir travailler au bit à bit, l'une des solutions les plus simples consiste sans doute à travailler sur une énumération.

Les valeurs énumérées seraient un peu particulières dans le sens où elles seraient toutes représentable avec un seul bit. Elle prendrait alors la forme de

Code:

---

1 2 3 4 5 6 7 8 9 10 11

enum BitsField{ zero = 0, // qui l'eut cru ??? :D un = 1, // vaut 1 deux = 1<<1 , //décalage de deux bits vers la gauche, correspond à 1*2 trois = 1 <<2, // correspond à 1*2*2 = 4 quatre = 1<<3, // correspond à 1*2*2*2 = 8 cinq = 1<<4, // correspond à 1*2*2*2*2 = 16 six = 1<<5, // correspond à 1*2*2*2*2*2 = 32 sept = 1<<6, // correspond à 1*2*2*2*2*2*2 = 64 huit = 1<<7, // correspond à 1*2*2*2*2*2*2*2 = 128 };

---

Une fois que tu as cela, tu peux déjà définir la valeur de chaque bit, mais il peut sembler intéressant de préciser les quelques opérateur de manipulation de bits:

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27

inline BitsField operator&(BitsField a, BitsField b) { return BitsField(static_cast<int>(a) & static_cast<int>(b)); }   inline BitsField operator|(BitsField a, BitsField b) { return BitsField(static_cast<int>(a) | static_cast<int>(b)); }   inline BitsField operator^(BitsField a, BitsField b) { return BitsField(static_cast<int>(a) ^ static_cast<int>(b)); }   inline BitsField operator~(BitsField a) { BitsField(~static_cast<int>(a)); }   inline const BitsField& operator|=(BitsField & a, BitsField b) { return a = a | b; }   inline const BitsField& operator&=( BitsField & a, BitsField b) { return a = a & b; }   inline const BitsField& operator^=(BitsField & a, BitsField b) { return a = a ^ b; }

---

De cette manière, tu peux facilement assembler les différentes valeurs:

Code:

---

1 2 3 4 5 6

int main(){ BitsField a(un); BitsField b(deux); BitsField c = a|b; std::cout<< a<<" "<<b<<" "<<c<<std::endl; }

---

donnera la sortie

Code:

---

1 2 3

---

Tu peux aussi assez facilement vérifier si un bit est mis à un ou à 0 sous une forme proche de

Code:

---

1 2 3 4 5

int main(){ BitsField a=un | deux | trois |quatre ; //00001111 en binaire std::cout<<" bit un vaut 1 ? "<<std::boolalpha<<(a& un) <<std::endl <<" bit cinq vaut 1 ? "<<std::boolalpha<<(a &cinq); }

---

aura pour sortie

Code:

---

1 2	bit un vaut un ? true bit cinq vaut 1? false

---

tu peux inverser la valeur d'un (ou de plusieurs) bit(s) particulier(s) indépendamment de sa (leur)valeur d'origine (s'il vaut 1 avant, il vaut 0 après et inversement):

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

int main(){ BitsField a=un | deux | trois |quatre ; //00001111 en binaire std::cout<<"avant: "<<a<<std::endl; a^=trois; std::cout<<"apres : "<<a<<std::endl; a^=trois; std::cout<<"revenons a la valeur d'origine :"<<a<<std::endl <<"et changeons la valeur du cinquieme bit : "; a^=cinq; std::cout<<a<<std::endl; std::cout<<"inverson la valeur de deux bits (le 3eme et le 5eme) :"; BitsField b=trois |cinq; a^=b; std::cout<<a<<std::endl; }

---

te donnera la sortie

Code:

---

1 2 3 4 5

avant: 15 apres : 11 revenons a la valeur d'origine : 15 et changeons la valeur du cinquieme bit : 31 inverson la valeur de deux bits (le 3eme et le 5eme) : 11

---

Bref, tu peux t'amuser comme un petit fou :D

Et bien sur, l'ordre dans lequel tu introduit les valeur n'a aucune espèce d'importance, du moment que tu utilises le bon opérateur, et tu peux utiliser les opérateurs de comparaison:

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12

int main(){ BitsField a=un | deux | trois |quatre ; //00001111 en binaire BitsField b=un | deux | cinq |quatre ; //00011011 en binaire std::cout<<"avant :"<<a <<" "<<b<<std::endl; if(a!= b){ std::cout<<"oups je me suis gouru "<<std::endl; b^= (cinq | trois); std::cout<<"apres :"<<a <<" "<<b<<std::endl; }   }

---

donnera la sortie

Code:

---

1 2 3

avant 15 27 oups je me suis gouru apres 15 15

---

Merci Iradrille et koala01 pour ces explications.
Donc maintenant si j'ai un espace mémoire E de N octets et une variable de type T, qui doit être à l'adresse A, d'access Size de S, de lsb L, de msb M et de valeur V.
Il me faut une fonction qui aille à l'adresse A dans E, et qui dans les S octets écrive/lise du bit L à M chacun des bits de la conversion de V en binaire.

Quand j'y pense j'ai le doute qu'il va falloir qu'extraie la zone et peut être la swaper en fonction de l'endianess avant d'écrire dans la zone et la réinsérer. A confirmer. RIP :kill:

Code:

---

1 2 3 4 5 6 7 8 9 10

template <class T> void read(T& val, const unsigned char* data, int msb, int lsb, bool big_endian=true) { const size_t size = sizeof(T); unsigned char *ptr = reinterpret_cast<unsigned char*>(&val); for(size_t i=0; i<size; ++i) ptr[big_endian ? size-i-1: i] = data[i]; binary(val); val <<= lsb; val >>= (sizeof(val) * CHAR_BIT - msb - 1);

---

Permet il bien de lire une taille T d'octet(s) et bien pendre les bits de lsb à msb ?

Tu devrais lire le n° de juin de Linux Magazine.