Discussion :

[chrono23]

Salut, je suis un ptit nouveau sur le forum, mais ca fait longtemps que je profite des diverses discussions, qui m'ont souvent depanné... enfin bref....

Ma question est la suivante:

J'ai un fichier qui contient des valeurs hexa. Je veux pouvoir mettre ce fichier sous forme de map.(ou autres conteneurs si vous avez mieux a proposer).
Je dois lire le contenu du fichier puis des que j ai une valeurs hexa type (0x47) je copie le toutes les valeurs qui se trouvent jusqu'au prochain fanion(0x47).
Il me semble que cela se fait assez facilement avec les map. mais je trouve pas comment???

exemple: fichier: 47 a8 54 43 87 56 a1 c3 47 79 ...

donc tout ce qui est entre les 47 doit etre copier dans un case de la map.

merci d'avance

[chrono23]

Enfin ca se fait plutot avec un iterateur je voulais dire mais je desire contenir mes données dans une map.

[Luc Hermitte]

Une map est une table associative : on associe une donnée à une clé ; la donnée sera retrouvée grâce à la clé.
L'hexa n'est qu'une représentation textuelle que l'on applique sur des nombres.

Je n'ai pas saisi ce que tu cherchais à faire.

[chrono23]

Merci de ta réponse, je vais essayer d'etre plus clair.
le but est de decouper un fichier mpeg2 en sequence.
Un fichier mpeg2 est compose de paquet, et chacun de ces paquets commence par un fanion(fanion = permet de determiner le debut d'un paquet)
ce que je desire faire c'est mettre chacun des ces paquets dans une case de la map.

Donc pour faire cela, je dois detecter le fanion puis copier tous les bytes dans la case de la map jusque'au prochain fanion.

J'espere que c'est plus clair...

[Luc Hermitte]

Tu ne veux pas une map. Une map te réordonnerai tes paquets selon l'ordre appliquable aux clés de stockages.
Un simple vecteur de vecteurs fera très bien l'affaire dans ton cas.

Je verais bien une lecture par blocs, et au fur et à mesure, tu découperais tes blocs (de lecture) en paquets séparés par des fanions. Un truc du genre:

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
const char FLAG = 0x47;
 
typedef std::vector<char> paquet_t;
std::vector<paquet_t> paquets;
 
std::ifstream f("nom fichier", std::ios_base::in|std::ios_base::binary);
if (!f) throw std::runtime_error("cannot open ``nom fichier''");
const size_t BUFFER_SIZE = 1024; // ou autre valeur intelligente
std::vector<char> buffer(BUFFER_SIZE);
 
// On peut même faire un buffer.reserve(NB) si on connait le nombre 
// de paquets dans le fichier
packets.resize(1);
packet_t * current_packet = &packets.back();
 
while (size_t nb_read = f.read(&buffer[0], buffer.size()) ) {
    if (nb_read != buffer.size()) 
        buffer.resize(nb_read); // c'est la fin du fichier, on maj buffer.end()
 
    packet_t::const_iterator f = v.begin();
    packet_t::const_iterator p = std::find(f, buffer.end(), FLAG) ;
    for ( ; p != buffer.end() ; p = std::find(f, buffer.end(), FLAG) )
    {
        ++p; // On absorbe le FLAG
 
        // On copie ce que l'on vent de lire à la fin du paquet courant
        std::copy(f, p, std::back_inserter(*current_packet) );
 
        // paquet suivant
        packets.resize(packets.size() + 1);
        current_packet= &packets.back();
 
        // Repositionnement du marqueur de début
        f = p; 
    }
 
    // On commence à mettre ce qui reste du buffer dans le dernier paquet
    // Mais on ne passe pas au paquet suivant car la suite va de nouveau arriver dans le buffer
    std::copy(f, buffer.end(), std::back_inserter(*current_packet));
} // fin de la lecture
 
// au cas où le dernier paquet ne contiendrait rien.
if (!packets.empty() && (packets.back().size() == 0)) {
    packets.resize(packets.size() - 1);
}

Le code est certainement faux au niveau de sa machine à états (n supposant qu'il compile), mais il donne l'idée générale de ce qui doit être fait.

[chrono23]

Merci pour ta réponse, effectivement l'objet map n'est pas adapte a ce que je veux faire, vector est bien meilleure.
la strategie que je vais utiliser est la suivante, je vais reparer le FLAG, puis creer objet paquets (qui contient mon paquets). Puis stocker tous ces paquets dans un vector.
ainsi mon vector sera une sequence de paquet.

Mais j'ai quelque question concerant les iterateurs.
1. Est-ce que je peux passer un ou des iterateurs en parametre d'un constructeur pour construire mon objet paquets a partir des iterateurs?
2. Est ce que je peux faire une comparaison du type == avec des valeurs hexa declaré comme caractere?
3. derniere question, est ce que tu pourrais detailler ce qui se passe dans cette partie de code?

packet_t::const_iterator f = v.begin();
packet_t::const_iterator p = std::find(f, buffer.end(), FLAG) ;
for ( ; p != buffer.end() ; p = std::find(f, buffer.end(), FLAG) )
{
++p; // On absorbe le FLAG

// On copie ce que l'on vent de lire à la fin du paquet courant
std::copy(f, p, std::back_inserter(*current_packet) );

// paquet suivant
packets.resize(packets.size() + 1);
current_packet= &packets.back();

// Repositionnement du marqueur de début
f = p;

Merci d'avance