emploi de strstr()

**john_osaka** · 13/03/2006, 10h10

Bonjour,

Je suis en train de réaliser un programme qui doit etre en mesure de lire un fichier, et d'analyser celui ci de la manière suivante :

- dès qu'il trouve une occurence (de type E14D par exemple)
- il pointe sur cette occurence et regarde la valeur des six caractères suivants,
- selon la valeur de ces six caractères on fera une analyse des octets restants jusqu'a arriver sur une nouvelle trame E14D,

Mon problème est le suivant pour l'instant : je voulais faire une simple recopie du fichier dans un buffer mais il semble que cela ne fonctionne pas sur de gros fichiers (au dela de 200 Ko). Je me suis intéressé aux fonctions de type find_first_of ou strstr, et strstr correspond le plus à ce que je souhaite, car cette fonction renvoie l'endroit où l'occurence a été trouvée.

Seulement, strstr compare deux chaînes de caractère. Existe-t-il un moyen de faire un strstr('fichier.abc', chaine_a_trouver) ? peut etre pas avec str ?

Dois je plutot m'intéresser à un code de type Boyer-Moore ?

Merci pour vos réponses !

**niglo** · 13/03/2006, 10h38

Dans mes souvenirs find_first_of renvoyait également la position de la première ocurrence de la sous chaine recherchée.

Un google et ca repart !

Pour confirmer mes souvenirs: http://www.cppreference.com/cppstrin..._first_of.html

**ash.ice.loky** · 13/03/2006, 11h02

Attention,

Find_first_of (« xyz »), retourne bien une position dans la chaine, mais pas de XYZ, mais de X, Y ou Z.
Il considère la string comme une liste char à trouver.
La meilleure méthode de recherche est find de <algorithm> de la STL.
En l’utilisant sur une string, il te retournera la position de « XYZ » dans la chaine.

**john_osaka** · 13/03/2006, 11h11

effectivement find_first_of semble convenir, mais je crains qu'au dela d'un certain nombre d'octets, le programme ne soit pas en mesure d'effectuer un balayage des valeurs du fichier.

Lorsque j'utilise find_first_of je dois déclarer un pointeur *input (chaîne d'entrée) de caractères, ainsi qu'un pointeur pour le motif à rechercher, comme suit :

char *input = "AABBCDEFAAEFFBB" ;
char *pattern = "BB" ;

Seulement, en entrée j'ai bel et bien un fichier. Comment puis-je "convertir" le contenu du fichier en un char ? Dois-je déclarer un tableau de char ? Si oui, existe-t-il une taille max pour les tableaux en c++ ?

Merci encore pour vos réponses, j'avancerai beaucoup plus vite si vous êtes nombreux a m'aider

PS : ash.ice.loky => ok je vais jeter un oeil la dessus

**JulienDuSud** · 13/03/2006, 11h16

bah voyons, c'est pas compliqué pourtant :/ :

Code :

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

1
2
3
4
5
 
std::ostringstream ossBuffer;
std::ifstream iFile( "fichier.ext" );
ossBuffer << iFile;
size_t iPos = oss.str().find_first_of("E14D" );

**john_osaka** · 13/03/2006, 11h27

JulienDuSud => merci beaucoup, effectivement ca doit te paraître simple, mais étant un peu nouveau dans la prog, j'avoue, ca ne l'est pas trop pour moi

ceci dit, bizarrement, iPos me renvoie une valeur qui me semble erronée. un "cout << iPos;" me sort une valeur énorme, s'agit-il de l'index de la position du pointeur ? ou est-ce une autre valeur ?

Par ailleurs, je cherche à balayer toutes les valeurs du fichier, et j'utilise dont un :

while(!iFile.eof())

{
size_t iPos = oss.str().find_first_of("E14D");
}

je voudrais simplement ranger les valeurs iPos dans un tableau, et faire en sorte d'obtenir tous les éléments. Faut il pour cela changer le motif ? ou faut il faire plutôt une boucle for prenant en paramètre iPos afin de ne pas retomber sur le même élément ?

**Laurent Gomila** · 13/03/2006, 11h47

Question bête : est-ce que le texte "E14D" est écrit tel quel dans ton fichier, ou bien est-ce la représentation héxadécimale des octets que tu recherches ? On ne sait jamais...

Autre question : quel genre de fichier lis-tu ? C'est un format connu ?

**john_osaka** · 13/03/2006, 11h49

la valeur est indiquée telle quelle (par contre il faut que je vérifie au niveau des majuscules, le respect de la casse doit etre présent dans les fonctions de recherche ...)

Le format de fichier est un format quelconque, ici il s'agit d'un format texte (donc .txt)

[EDIT] Je ne comprends pas, la valeur E14D est belle et bien présente dans mon fichier mais find_first_of ne la trouve pas (la fonction renvoie -1)

[RE-EDIT] corrigé, je pointais sur un oss quelconque et non sur le buffer ...

**Laurent Gomila** · 13/03/2006, 12h00

Ok.

Donc pour corriger ton bout de code :

Code :

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

1
2
3
4
5
while(!iFile.eof())
 
{
size_t iPos = oss.str().find_first_of("E14D");
}

Deux remarques : le test eof() ne doit pas être utilisé comme ceci, cf. la FAQ C++ ; et find_first_of renvoie la position de la première occurence de l'un des caractères de la chaîne passée en paramètre.

Il faudrait donc plutôt faire ceci :

Code :

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

1
2
3
4
5
6
7
std::vector<std::string::size_type> Positions;
std::string Buffer = oss.str();
 
for (std::string::size_type Pos = Buffer.find("E14D"); Pos != std::string::npos; Pos = Buffer.find("E14D", Pos + 1))
{
    Positions.push_back(Pos);
}

Pas testé mais ça devrait être quelque chose comme ça.

**john_osaka** · 13/03/2006, 12h11

si je comprends bien ton morceau de code, tu crées un vecteur Positions qui contiendra l'ensemble des positions trouvées à l'aide de la fonction find ?

Comment puis-je récupérer les positions pour les mettre dans un tableau ? déclarer un tableau et créer une boucle for pour balayer celui ci et rentrer chaque valeur du vector une a une ?

D'autre part, la commande :

cout << Positions.front()

me fait planter le programme, je ne sais pas pourquoi ...

**Laurent Gomila** · 13/03/2006, 12h26

si je comprends bien ton morceau de code, tu crées un vecteur Positions qui contiendra l'ensemble des positions trouvées à l'aide de la fonction find ?

C'est ça.

Comment puis-je récupérer les positions pour les mettre dans un tableau ? déclarer un tableau et créer une boucle for pour balayer celui ci et rentrer chaque valeur du vector une a une ?

Ben c'est ce que mon code fait...

D'autre part, la commande :

cout << Positions.front()

me fait planter le programme, je ne sais pas pourquoi ...

Sûrement parce que ton vecteur est vide, ce qui signifierait que la recherche est buggée.

Est-ce qu'on peut voir le code complet maintenant qu'on a un peu avancé ?

**john_osaka** · 13/03/2006, 13h16

tout à fait :

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
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
#include <fstream>
#include <stdio.h>
#include <stdlib.h>
#include <iostream>
#include <string> 
#include <sstream> 
#include <algorithm>
#include <cstring>
#include <vector>
 
 
using namespace std;
 
// METHODE POUR RECUPERER LA TAILLE DU FICHIER A TRAITER
 
long GetFileSize( std::ifstream & Fichier )
{
    // sauvegarder la position courante
    long pos = Fichier.tellg();
    // se placer en fin de fichier
    Fichier.seekg( 0 , std::ios_base::end );
    // récupérer la nouvelle position = la taille du fichier
    long size = Fichier.tellg() ;
    // restaurer la position initiale du fichier
    Fichier.seekg( pos,  std::ios_base::beg ) ;
    return size ;
}
 
 
 
int main(){
 
 
 
 
 
  /////////////////////////////////////////////////////////////////////////////////////////////////////////  
  //                                            CONVERSION HEXA                                          //
  /////////////////////////////////////////////////////////////////////////////////////////////////////////
 
    ifstream fichier_analyse;
    fichier_analyse.open("sony2in.rec"); //fichier de départ
    int code;
    char donnees;
    if(!fichier_analyse) // test de la présence du fichier
        {
        cout<<"Erreur en ouvrant le fichier"<<endl;
        }
 
 
    //fichier une fois converti en hexa : hexa.txt
    ofstream outfile ("hexa.txt");
    while(!fichier_analyse.eof())
    {
         // on lit mot par mot
         fichier_analyse>> donnees;
         //conversion en hexadécimal
         code = donnees; // on passe en décimal
         std::ostringstream oss;  // on génère un flux oss
         oss << std::hex << code;  // on précise une représentation hexa
         std::string Hex = oss.str(); // oss est la représentation hexa du code
         //cout << endl << oss.str() << " est la valeur ascii de : " << donnees << endl; //affichage de oss et de la valeur correspondante  
         //ecriture de la valeur hexa dans le fichier de sortie
         outfile << oss.str();  
    }
    outfile.close(); //fermeture du fichier de sortie
 
  /////////////////////////////////////////////////////////////////////////////////////////////////////////
  //                                       ANALYSE FICHIER HEXA                                          //
  /////////////////////////////////////////////////////////////////////////////////////////////////////////
 
 
//balayage des valeurs du nouveau fichier
//ouverture du fichier hexa et mise en buffer des valeurs correspondantes
 
   std::ostringstream ossBuffer; 
   std::ostringstream oss;
   std::ifstream iFile( "hexa.txt" ); 
   ossBuffer << iFile; 
 
 
   cout << "Taille du fichier : " << GetFileSize(iFile) << endl;
 
std::vector<std::string::size_type> Positions; 
std::string Buffer = oss.str(); 
 
for (std::string::size_type Pos = Buffer.find("E14D"); Pos != std::string::npos; Pos = Buffer.find("E14D", Pos + 1)) 
{ 
    Positions.push_back(Pos); 
}
cout << Positions.back();
 
 
 
 
 
 
system("PAUSE"); //permet de ne pas fermer la fenetre violemment
return(0);    
}

bref, rien de spécial si ce n'est que je crée un fichier hexa depuis le fichier source qui nous intéresse au préalable.

[EDIT] : J'ai un problème de passage sous UNIX, il semblerait que ios_base ne soit pas reconnu dans ces librairies (changement des .h effectué). Y a-t-il une librairie à rajouter pour faire fonctionner cette commande?

De plus, bizarrement sous mon shell unix, la commande PAUSE n'est pas comprise, existe t il un équivalent ? (autrement je peux faire un sleep(durée) ...)

**john_osaka** · 13/03/2006, 15h35

Finalement, mon boss ne veut pas que je passe par de l'hexa, c'est un peu dommage, vu que je n'avais qu'a rentrer une chaine plutot qu'une suite de 1 et de 0 dans les comparaisons ...

Dois je tout reformuler de manière à faire une recherche "binaire" de la séquence E14D ? il me semble que je vais devoir passer par les commandes fopen puis memcmp pour comparer les zones mémoires correspondant aux octets qui m'intéressent dans le fichier ...

**Thordax** · 14/03/2006, 10h40

Bon, j'ai paumé mon mot de passe j'utilise un autre pseudo

J'ai fait quelques modifs du fichier mais en gros j'arrive de manière synthétique a ca :

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
 
#include <fstream.h>
#include <stdio.h>
#include <stdlib.h>
#include <iostream.h>
#include <string> 
#include <sstream> 
#include <algorithm>
#include <cstring>
#include <vector.h>
 
 
using namespace std;
 
bool is_readable( const std::string & file ) 
{ 
    std::ifstream fichier( file.c_str() ); 
    return fichier != 0; 
} 
 
 
int main(){    
    char fichier_entre[50];
    cout << endl << "Quel fichier desirez vous traiter ? \n(note : le fichier doit etre dans le repertoire en cours)" << endl;
    cout << "Fichiers du repertoire : " << endl;
    system("ls -a"); //listing du répertoire
    cin >> fichier_entre;
    cout << "Vous souhaitez traiter :" << fichier_entre << endl;
 
//ouverture fichier
    ifstream fichier;
    fichier.open ("fichier_entre", ios::binary );
 
 
//le fichier existe t il
 
if ( !is_readable( "fichier_entre" ) ) 
    {
        cout << "Fichier inexistant ou non lisible.\n"; 
    } 
 
 
//recherche trames    
 
 
//MISE EN BUFFER
       std::ostringstream ossBuffer; 
       ossBuffer << fichier; 
       std::string Buffer = ossBuffer.str();
 
 
       // manipulations du buffer
       std::vector<std::string::size_type> Positions; 
       for (std::string::size_type Pos = Buffer.find("E14D"); Pos != std::string::npos; Pos = Buffer.find("E14D", Pos + 1)) 
       { 
       Positions.push_back(Pos); 
       }
 
cout << Positions.front();
 
        // fermeture fichier
        fichier.close();        
 
system("PAUSE");
}

Problème : toujours au niveau du vector, celui ci semble vide... La condition dans le if est elle mauvaise ? mon fichier est à présent binaire, la séquence E14D n'est pas telle quelle dans le fichier, elle apparait en correspondance ASCII, c'est à dire les deux caractères : áM.

Dois je faire une recherche des deux caractères ?

**Thordax** · 14/03/2006, 17h09

bon je fais monologue mais tant pis j'aime ca je crois

j'ai pu corriger les problèmes liés au find précédent. Maintenant le problème est tout autre. Je cherche à récupérer les trois octets suivant la trame E14D trouvée, et comparer ces trois octets avec des trames connues. Exemple:

-si la trame vaut 00 00 00 on laisse tomber,
-idem si la trame vaut FF FF FF,
-sinon, on calcule la somme des trois valeurs.

Pour cela, je fais la commande :

Code :

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

string trois_octets=buffer.str().substr(tag_E14D+2,3);

Je souhaite ensuite comparer cette string avec une trame hexa de type "00 00 00". Dois je déclarer un char[] ou un

Code :

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

const char trame_nulle[]={0x00 , 0x00 ,0x00}

et faire un simple la simple commande suivante ? :

Code :

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

if(trois_octets==trame_nulle)

J'imagine qu'on ne peut pas pas simplement comparer un tableau de char avec une string. De même, il est déconseillé d'utiliser les tableaux de char. Dois je faire une conversion du tableau de char {0x00 , 0x00 ,0x00} en une string correspondante ? ou dois-je déclarer une string directement ? (j'ai essayé la derniere option, std::string=000; mais évidemment "000000" n'est pas un char...

**b4u** · 14/03/2006, 17h18

tu peux acceder a chaque caractere d'une string individuellement grace a l'operateur [], par exemple avec:

Code :

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

1
2
string toto = "hello";
char e = toto[1];

l'octet e vaudra 'e'.

**b4u** · 14/03/2006, 17h23

mais sinon dans ton cas tu peux aussi faire:

Code :

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

1
2
3
4
if (trois_octets == "000000" || trois_octets == "FFFFFF")
	laisse_tomber();
else
	...

**john_osaka** · 14/03/2006, 20h53

yes merci bien ! ca marche impec !

**Thordax** · 15/03/2006, 15h06

J'ai un autre problème à présent, je cherche à créer une méthode renvoyant un tableau de données, j'ai donc pensé a créer une méthode renvoyant un vector.

Seulement je n'ai aucune idée du formalisme ... J'imagine qu'il s'agit de quelque chose dans le genre :

J'ai un nouveau problème à présent ... Je cherche à créer une méthode permettant de renvoyer un vector, il me faudrait un truc du style :

Code :

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

1
2
3
4
5
6
7
8
9
10
 
std::vector<int> recup_mc(std::bitset<8u> et1)
{
std::vector<int> mc;
mc.push_back( et1[0] );
mc.push_back( et1[1] );
mc.push_back( et1[2] );
mc.push_back( et1[3] );
 
return(mc);}

(note et1 est un tableau de données binarisées, mais bon cela importe peu dans mon problème ..)

des idées ? merci pour votre aide !

**b4u** · 15/03/2006, 15h28

Pour le prototype de ta fonction:

Code :

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

std::vector<int> recup_mc(std::bitset<8u> et1)

ou

Code :

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

vector<int> recup_mc(bitset<8u> et1)

si tu es dans le namespace std.

[Edit: ah c'est bon tu as corrigé en éditant]

Sinon, je trouverais plus élégant de retourner ton vecteur par référence ou par pointeur (surtout si celui-ci contient beaucoup de données):

Code :

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

1
2
3
4
5
6
std::vector<int> &recup_mc(std::bitset<8u> et1)
{
std::vector<int> *mc = new std::vector<int>;
for (int i = 0; i <= 3; i++)
	mc->push_back(et1[i]);
return(*mc);}

ou

Code :

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

1
2
3
4
5
6
std::vector<int> *recup_mc(std::bitset<8u> et1)
{
std::vector<int> *mc = new std::vector<int>;
for (int i = 0; i <= 3; i++)
   mc->pushback(et1[i]);
return(mc);}

[Edit: j'ai modifié pour m'adapter a ton edit

]

Assure-toi également que le type 8u peut etre implicitement casté en int.

emploi de strstr()

C++

Vue hybride

Discussions similaires

Partager

Partager