Discussion :

[adrian07]

Salut à tous,

J'essaye de réaliser un petit programme qui lit les mots d'un fichier et calcule pour chaque mot son nombre d’occurrence et affiche le résultat dans un fichier

Voici mon 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
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
 
// fichier a parcourir
ifstream lire("indexation.txt");
// fichier d'indexation
ofstream ecrire("indexation.dat", ios_base::app);
string mot;
int position = 0 ;
int occurence = 0 ;
string occ;
 
while(!lire.eof())
{ 
      lire >> mot;  
      while (!lire.eof())
      {
            lire>>mot;
            if(mot.compare(lire) == 0)
            {
                  occurence++;
            }
      }
 
 
      ecrire << mot <<"    " <<position<<"\t"<<occurence<<endl;
 
 
      }
      position++;
      occurence =0;
}

Mais malheureusement, ça ne marche pas, le fichier "indexation.dat" reste toujours vide...

Je ne trouve pas mon erreur, pouvez vous m'aider ???

[LittleWhite]

Bonjour,

Actuellement, je pense que c'est parce qu'il manque le ecrire.close(). Mais je ne suis pas sur que cela suffise.
Sinon, vous ne vérifiez pas que le "ecrire" est ouvert correctement. Vous avez peut être un problème de droit ?

Finalement, votre méthode sera beaucoup plus efficace avec une Hash_Map (on peut utiliser std::map pour des raisons de simplicité).

[JolyLoic]

Quelques problèmes en vrac :

- L'algorithme n'a pas vraiment de sens.
- Mauvais utilisation de eof. Faire plutôt while(lire >> mot) http://cpp.developpez.com/faq/cpp/?page=fichiers#FICHIERS_eof
- mot.compare(lire) : Ce code ne devrait même pas compiler. On compare une chaîne et un flux
- C'est quoi l'accolade avant position++; ?

J'ai l'impression que le code que tu montres n'est pas vraiment ton code. Peux-tu nous montrer ton code exact pour qu'on puisse t'aider ?

=> LittleWhite : Le ecrire.close n'est pas nécessaire, le destructeur d'un flux le ferme automatiquement. Le seul intérêt d'écrire le close explicitement est qu'en testant l'état du flux après un close, on a une chance de détecter certaines erreurs lors de l'écriture (mais rien n'est garanti).

[LittleWhite]

C'est bien ce que je pensais pour le close (mais j'hésite toujours )

Sinon, les remarques de JolyLoic sont justes. L'algorithme est faux et vous ne listerez pas tout les mots (et ne compterai pas toutes les occurrences).

[Ekleog]

Sinon, pour en revenir au problème initial (rien qui ne s'écrit), bien que je n'en incite pas moins à lire les réponses précédentes attentivement pour les soucis qui vont revenir après, la raison me semble être ofstream ecrire("indexation.dat", ios_base::app); qui devrait être ofstream ecrire("indexation.dat", ios_base::app | ios_base::out);.

LittleWhite> s/compterai/compterez

[adrian07]

Merci pour vos réponses....

Et bien, c'est mon code ...
C'est un petit programme que je dois réaliser pour indexer un fichier...Le travail consiste à passer un fichier en paramètre pour extraire les mots non vides(on a un tableau de mots vides comme référence) puis donner pour chaque mot le nombre d'occurrences...

J'ai commencé en un premier essai par donner pour chaque mot sa position dans le fichier et ça a bien marché mais ensuite lorsque j'ai voulu passe au nombre d'occurrences, j'étais bloqué et j'ai pas pu m'en sortir, je viens juste de débuter en c++

En tout cas, voici l'intégralité du 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
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
 
 
#include <fstream>
#include<cstdlib>
#include <dirent.h>
#include <cstdlib>
#include <iostream>
#include <string>
 
using namespace std;
 
/*Indexation d'un fichier*/
 
bool chercherVide(string mot, string vide[]){
    for(int i=0; i<50;i++){
        if(vide[i] == mot){
            return true;
            break;
        }
    }
    return false;
}
int main(int argc, char** argv) {
    // tableau contenant les mots vides
    string vide[100] = {"je","tu","il","nous","vous","ils","le","la","les","un","une","de","du","des","à","au","sur","sous","et","on","en","ou","se","ce","ça","cela","ceci"};
 
 
    // fichier a parcourir
    ifstream lire("indexation.txt");
    // fichier d'indexation
    ofstream ecrire("indexation.dat", ios_base::app);
    string mot;
    int position = 0 ;
    int occurence = 0 ;
    string occ;
 
 
    while(!lire.eof()){ // boucler jusqu'à la fin du fichier
        lire >> mot;  // lire mot par mot
        while (!lire.eof()){
            lire>>mot;
 
            if(mot.compare(lire) == 0){
                occurence++;
            }
        }
        if(!chercherVide(mot,vide)){ // vérifier si le mot est vide ou non
 
            ecrire << mot <<"    " <<position<<"\t"<<occurence<<endl;// si non, l'insérer dans le fichier d'indexation avec sa position
 
 
         }
        position++;
        occurence =0;
          }
       cout<<"fichier indexé avec succès"<<endl;
 
    return 0;
}

et merci d'avance pour toute aide

[koala01]

Salut,

Déjà, je commencerais par faire un algorithme correct

La première chose, à faire, c'est de lire le fichier en entier afin de compter les différentes occurrences de chaque mot et remplir une structure "qui va bien".

Ce ne sera en effet qu'une fois que l'on aura lu l'ensemble du fichier que nous serons, effectivement, de dire qu'il y a eu X occurrences du mot untel et Y occurrences du mot telautre .

si l'on a pris soin de garder, en plus, les positions des différentes occurrences de chaque mots, le fichier d'index se créera "tout seul" (ou presque)

Si l'on peut, par la meme occasion,

Sinon, pour en revenir au problème initial (rien qui ne s'écrit), bien que je n'en incite pas moins à lire les réponses précédentes attentivement pour les soucis qui vont revenir après, la raison me semble être ofstream ecrire("indexation.dat", ios_base::app); qui devrait être ofstream ecrire("indexation.dat", ios_base::app | ios_base::out);.

Je ne vois vraiment pas pourquoi utiliser ofstream ecrire("indexation.dat", ios_base::app); (ni meme pourquoi utiliser ofstream ecrire("indexation.dat", ios_base::app | ios_base::out); d'ailleurs ):

ecrire est un flux de type ofstrem, ce qui fait qu'il a , d'office, le flag ios_base::out à true

De plus, comme il n'est ouvert qu'une fois, il n'est absolument pas nécessaire de forcer le fait de placer le "curseur" d'écriture à la fin du fichier

Parlons un peu de cette "structure qui va bien"

Le standard fournit depuis très longtemps déjà une classe géniale qui permet d'associer une clé à une valeur: la classe std::map.

Cette classe présente deux intérêts majeurs (enfin, dans le cadre de ce que l'on veut faire ici ) :

1. Celui d'implémenter un arbre binaire de recherche, et donc de trouver très rapidement l'élément correspondant à la clé recherchée
2. Celui d'exposer un opérateur [clé] qui présente la particularité de créer la clé (avec la valeur correcte) si la clé recherchée n'existe pas.

Comme il s'agit de trouver la position de toutes les occurrences d'un même mot (en fait de tous les mots se trouvant dans le fichier lu ), je verrais bien le fait de faire en sorte que la valeur correspondante soit... un tableau de position, tout simplement

Nous pourrions donc parfaitement travailler avec quelque chose comme

Code :

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

std::map<std::string, std::vector<unsigned int> > index;

la clé sous forme de std::string représentant à chaque fois un mot "unique", le vecteur d'entiers non signés permettant de garder l'ensemble des indexes auquel le mot en question apparait dans le fichier

Il reste un problème potentiel que l'on va cependant décider d'ignorer, c'est le fait que la comparaison de chaines de caractères prend énormément de temps...

Malgré le nombre de comparaisons qui seront effectuées, nous devrions malgré tout ne pas perdre "trop" de performances lors de la création de l'index

La lecture du fichier pourrait etre "on ne peut plus simple" et prendre une forme proche de

Code :

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

1
2
3
4
5
6
7
8
9
10
11
void read(std::string const & filename, std::map<std::string, std::vector<unsigned int> > & lamap)
{
    std::ifstream ifs(filename.c_str()); //RAII oblige: on ouvre le fichier directement ;)
    unsigned int index = 0;
    std::string in;
    while( ifs>> in)
    {
        lamap[in].push_back(index);
        ++index;
    }
}

S'il y a une ligne de code qui risque de vous faire vous interroger, c'est très certainement lamap[in].push_back(index);

Voyons la un peu en détail
lamap[in] va renvoyer un std::vector<unsigned int> qui, selon le cas

• sera vide si l'on n'a pas encore rencontré le mot in (cf ce que j'ai expliqué plus haut ou
• contiendra les index correspondant au mot in qui ont déjà été rencontré

Quant à .push_back(index), cela aura pour effet de rajouter index au tableau d'indexes obtenu grace à la première partie

L'écriture du fichier d'indexation ne sera pas beaucoup plus compliquée

Elle pourrait prendre la forme de

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
void write(std::string const & filename, std::map<std::string, std::vector<unsigned int> > const & lamap)
{
    std::ofstream ofs(filename.c_str());
    for(std::map<std::string, std::vector<unsigned int> >::const_iterator it = lamap.begin();
        it!=lamap.end();++it)
    {
        ofs<<it->first<<" " it->second.size()<<" occurrences";
        for(size_t i = 0; i<it->second.size();++i)
            ofs<<" "<<it->second[i];
        ofs<<std::endl;
    }
}

Le tout serait sans doute utilisé sous une forme proche de

Code :

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

1
2
3
4
5
6
7
int main()
{
    std::map<std::string, std::vector<unsigned int> > lamap;
    read("indexation.txt",lamap);
    write("indexation.dat",lamap);
    return 0;
}

Magique, non