Discussion :

[rikau2]

Bonjour,

je cherche a lire une partie d'un fichier binaire (qui contient des trames) afin de la placer (la trame lue) dans un buffer sur lequel j'appliquerai ultérieurement des formatages...

Comment declare ton un conteneur de ce type? puis-je passer par un stream et apres en extraire des partie??

Merci de votre aide.

note: Pour le moment je me contente de venir me placer en debut de trame, et de lire chaque element un a un ou au maximum 32 bits d'un coup pour en extraire chaque partie apres. Le but de cette manip est donc de charger en memoire la trame entiere, et d'acceder aux differentes parties par l'intermediaire de getters. La trame n'est rechargée que si l'utilisateur veut explorer une autre trame.

[craryb]

pour la fin tu utilises un retour chariot?

[rikau2]

Non, en fait le fichier source est totalement en binaire, certaines parties sont de taille fixe, d'autre il faut lire la taille de la string avant de pouvoir l'extraire....

Je cherche donc a lire les parties de taille fixe d'une traite. La seule chose sure est que la taille minimal d'un bloc est 8 bits sachant que certaines parties doivent s'interpréter sur 4 bits.

Est-ce un peu plus clair?

[rikau2]

Quel est le conteneur a declarer pour pouvoir lire dans un fichier binaire un nombre donné de byte pour les interpréter après?
Pour l'instant j'ai quelquechose du genre qui evidement coince un peu...

Code :

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

1
2
3
4
5
6
        DWORD TypeId;
		std::string mystring;
		mystring.reserve(16);
		is.read(reinterpret_cast<char*>(&mystring), 16);
		from_string(mystring.substr(0,4),TypeId);
		TypeId = htonl(TypeId);

en utilisant le template de la faq suivant :

Code :

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

1
2
3
4
5
6
7
8
template<typename T>
bool from_string( const std::string & Str, T & Dest )
{
    // créer un flux à partir de la chaîne donnée
    std::istringstream iss( Str );
    // tenter la conversion vers Dest
    return iss >> Dest != 0;
}

Il me semble qu'en passant par des istream ou quelquechose du genre.... ca permettrait qu'il n'y ait pas d'interpretation des donnees lors du stockage dans las string.
Quelqu'un serait a meme de changer l'exemple pour remplacer la string par un istream?

[rikau2]

Je viens de trouver une possibilité pour lire un groupe de byte et d'extraire apres les parties qui m'intéressent. Voici le code

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
DWORD getVersionInformation (std::istream& is)
{
		DWORD TypeId;
		char tab[16];
		is.read(reinterpret_cast<char*>(&tab), 16*sizeof( char));
		TypeId = tab[0];
		TypeId = TypeId <<8;
		TypeId = TypeId + tab[1];
		TypeId = TypeId <<8;
		TypeId = TypeId + tab[2];
		TypeId = TypeId <<8;
		TypeId = TypeId + tab[3];
return TypeId;
}

Y a t'il une facon plus luxieuse de faire ceci? j'ai mis ceci dans une fonction pour l'exemple, mais dans mon code, j'ai un conteneur qui sera un char[MAX_SIZE], dans lequel mes getter prendront en interpretant la partie desirée.

Une idée d'amélioration ? Car c'est un peu brut comme code....

[Sylvain Togni]

Y a t'il une facon plus luxieuse de faire ceci?

Non c'est à peu prêt la façon standard de faire, sauf qu'on utilisera un buffer d'unsigned char plutôt que char pour manipuler les octets. Aussi, attention, il y a une erreur sur la ligne suivante

Code :

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

is.read(reinterpret_cast<char*>(&tab), 16*sizeof( char));

le '&' est en trop, il faut passer le buffer directement.

Une autre façon de faire est de se passer de buffer en lisant les octets 1 à 1 avec is.get().

[valefor]

Tu as aussi la possibilité de faire :

Code :

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

1
2
3
4
5
6
7
8
9
10
 
DWORD getVersionInformation (std::istream& is)
{
  union {
    DWORD _raw;
    char  _tab[sizeof(DWORD)];
  } id;
  is.read(id._tab, sizeof(id._tab));
  return id._raw;
}

Aux problèmes d'endianess près.

Plus généralement tu peux directement tout mettre dans une structure qui se remplira automatiquement en surchargeant l'operteur >> par exemple.

Par exemple :

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
23
24
 
struct Trame
{
  DWORD _id;
  DWORD _foo;
  DWORD _bar;
  unsigned char _data[48];
 
  friend istream & operator >> (istream & is, Trame &trame) ;
};
istream operator >> (istream & is , Trame &trame)
{
  is.read(reinterpret_cast<char *>(&trame), sizeof(trame)); 
  return is;
}
 
 
main
{
  ...
  Trame trame;
  is >> trame;
  ...
}

[EDIT]Modif de l'exemple pour montrer qu'on peut lire des trames avec des champs de taille quelconque (mais attention aux alignements et aux endiens )[/EDIT]

[rikau2]

Merci valefor, mais ce que je cherche a faire est bien de récupérer plus que 16 bits (comme 48 bytes d'un coup par exemple).
Il ne me reste qu'a changer le template definit dans la FAQ pour indiquer le nombre de bits a lire..