Bonjour,
Désolé de vous déranger mais dans le cadre d'un projet j'ai besoin a un moment donner de parser une suite de binaire et de les stocker dans un tableau.
J'ai ecris une fonction pour ce parsage mais je me rends compte quil est incomplet et doit etre ameliore pour etre vraiment fonctionnel. Voila mon probleme :
Les données que je reçois sont hexadécimales et ont toujours la même forme:
Une première partie qu’on appellera requête et qui contient :
Un code annonçant le début de la séquence : 0x5C (caractère \),2 code ASCII (représentant le type de requête) ,2 octets (non ASCII).
Les deux octets de fin représentent la taille que fera la partie data qui suit la partie requête.
Exemple :
String \ F Z 5
Hex. 5C 46 5A 00 05
Ici la partie donnée aura donc une taille 5.

Dans la partie data qui contiendra des données on a :
Cette fois au début de chaque séquence de données on retrouve le code 23 symbole #,2 code ASCII (représentant le type de donnée) ,2 octets (non ASCII)..Et les deux octets de fin représente la taille de la donnée a traité.
Exemple :
String. # F I 5
Hex 23 46 49 00 05
Ce qui veut dire que des données de taille 5 suivront cette séquence.

Un exemple de séquence complète en hexadécimale serait (j’ai enlevé la partie donnée de cette séquence dans l’exemple hexadécimale qui sera dans ce cas ABCDE et qui viendra à la fin de la dernière séquence et que je mettrai juste dans la traduction string) :
5C 46 49 00 0A 23 46 4E 00 23 46 49 00 05

Qui donnerait en string:
\FI10#FN0#FI5ABCDE

Je voudrais stocker dans un tableau le parsage de ces données. Il faudrait donc pour résumer reconnaître la partie requête commençant par 5C(\) et la stocké reconnaître la taille de la partie data dans la partie requête. En fonction de cette taille, traité la partie donnée. En remarquant le code hexa 23 (#) annonçant le début d’une séquence de données. Et la taille de la donnée qui suivra le code séquence et la stockée elle aussi. Dans la partie données il ya plusieurs données qui peuvent se suivre mais il ya une seule partie requête. J’espère ne pas avoir été trop confus.Voila mon code. Je compte sur vous pour m'aider a l'ameliorer et le corrigé:
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
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
   1. struct Parametre
   2. {
   3.    std::string type;
   4.    std::string valeur;
   5. };
   6. struct Commande
   7. {
   8.    std::string type;
   9.    std::vector<Parametre> parametres;
  10. };
  11.
  12. Commande parse(std::vector<char> tab);
  13.
  14. Commande parse(std::vector<char> tab)
  15. {
  16.     if ( tab.size() < 5 || tab[0] != 0x5C )
  17.     {
  18.         // Commande incorrecte
  19.
  20.         // Soit on renvoie une commande vide soit une exception
  21.         return Commande();
  22.     }
  23.
  24.     Commande commande;
  25.
  26.     // Lecture du type (2 caractères)
  27.     commande.type.assign(&tab[1], 2);
  28.
  29.     unsigned int taille = tab[3] * 256 + tab[4];
  30.
  31.     // On vérifie que tab a une taille suffisante
  32.     if ( tab.size() < taille + 5 )
  33.     {
  34.         // taille insuffisante pour tous les parametres
  35.         return Commande();
  36.     }
  37.
  38.     // position de la première valeur du premier paramètre
  39.     unsigned int offset = taille + 5;
  40.
  41.     for(unsigned int i = 5; i < taille + 5; i += 5)
  42.     {
  43.         if ( tab[i] != 0x23)
  44.         {
  45.             // Paramètre incorrecte
  46.             return Commande();
  47.         }
  48.
  49.         // Remplissage d'un nouveau paramètre
  50.         Parametre parametre;
  51.         parametre.type.assign(&tab[i+1], 2);
  52.
  53.         size_t taille_parametre = tab[ i + 3] * 256 + tab[i+4];
  54.
  55.         if ( tab.size() < offset + taille_parametre)
  56.         {
  57.             // taille insuffisante pour la valeur du paramètre
  58.             return Commande();
  59.         }
  60.
  61.         // Lecture de la valeur du paramètre
  62.         parametre.valeur.assign(&tab[offset], taille_parametre);
  63.
  64.         // positionnement pour le paramètre suivant
  65.         offset += taille_parametre;
  66.
  67.         // Ajout du paramètre à la commande
  68.         commande.parametres.push_back(parametre);
  69.     }
  70.     return commande;
  71. }
  72. //A la fin on a commande.parametres.size() pour avoir le nombre de paramètres de la commande, commande.parametres[i] pour accéder au paramètre i.
Merci davance pour vos aides.