IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

 C++ Discussion :

Indexation fichier et nombre d'occurrences


Sujet :

C++

Vue hybride

Message précédent Message précédent   Message suivant Message suivant
  1. #1
    Membre éclairé
    Inscrit en
    Avril 2007
    Messages
    227
    Détails du profil
    Informations forums :
    Inscription : Avril 2007
    Messages : 227
    Par défaut Indexation fichier et nombre d'occurrences
    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 ???

  2. #2
    Responsable 2D/3D/Jeux


    Avatar de LittleWhite
    Homme Profil pro
    Ingénieur développement logiciels
    Inscrit en
    Mai 2008
    Messages
    27 122
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations professionnelles :
    Activité : Ingénieur développement logiciels

    Informations forums :
    Inscription : Mai 2008
    Messages : 27 122
    Billets dans le blog
    148
    Par défaut
    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é).
    Vous souhaitez participer à la rubrique 2D/3D/Jeux ? Contactez-moi

    Ma page sur DVP
    Mon Portfolio

    Qui connaît l'erreur, connaît la solution.

  3. #3
    Rédacteur/Modérateur
    Avatar de JolyLoic
    Homme Profil pro
    Développeur informatique
    Inscrit en
    Août 2004
    Messages
    5 463
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 50
    Localisation : France, Yvelines (Île de France)

    Informations professionnelles :
    Activité : Développeur informatique
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : Août 2004
    Messages : 5 463
    Par défaut
    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).
    Ma session aux Microsoft TechDays 2013 : Développer en natif avec C++11.
    Celle des Microsoft TechDays 2014 : Bonnes pratiques pour apprivoiser le C++11 avec Visual C++
    Et celle des Microsoft TechDays 2015 : Visual C++ 2015 : voyage à la découverte d'un nouveau monde
    Je donne des formations au C++ en entreprise, n'hésitez pas à me contacter.

  4. #4
    Responsable 2D/3D/Jeux


    Avatar de LittleWhite
    Homme Profil pro
    Ingénieur développement logiciels
    Inscrit en
    Mai 2008
    Messages
    27 122
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations professionnelles :
    Activité : Ingénieur développement logiciels

    Informations forums :
    Inscription : Mai 2008
    Messages : 27 122
    Billets dans le blog
    148
    Par défaut
    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).
    Vous souhaitez participer à la rubrique 2D/3D/Jeux ? Contactez-moi

    Ma page sur DVP
    Mon Portfolio

    Qui connaît l'erreur, connaît la solution.

  5. #5
    Membre émérite
    Avatar de Ekleog
    Homme Profil pro
    Étudiant
    Inscrit en
    Janvier 2012
    Messages
    448
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : Janvier 2012
    Messages : 448
    Par défaut
    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

  6. #6
    Membre éclairé
    Inscrit en
    Avril 2007
    Messages
    227
    Détails du profil
    Informations forums :
    Inscription : Avril 2007
    Messages : 227
    Par défaut
    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

  7. #7
    Expert éminent
    Avatar de koala01
    Homme Profil pro
    aucun
    Inscrit en
    Octobre 2004
    Messages
    11 644
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 53
    Localisation : Belgique

    Informations professionnelles :
    Activité : aucun

    Informations forums :
    Inscription : Octobre 2004
    Messages : 11 644
    Par défaut
    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,
    Citation Envoyé par Ekleog Voir le message
    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
    A méditer: La solution la plus simple est toujours la moins compliquée
    Ce qui se conçoit bien s'énonce clairement, et les mots pour le dire vous viennent aisément. Nicolas Boileau
    Compiler Gcc sous windows avec MinGW
    Coder efficacement en C++ : dans les bacs le 17 février 2014
    mon tout nouveau blog

Discussions similaires

  1. [Débutant] Nombre d'occurrences de mots dans un fichier
    Par aleanlastar dans le forum MATLAB
    Réponses: 4
    Dernier message: 02/01/2015, 15h35
  2. Réponses: 5
    Dernier message: 20/01/2014, 16h42
  3. Compter le nombre d'occurrences d'un mot dans un fichier texte
    Par kandro dans le forum Shell et commandes GNU
    Réponses: 8
    Dernier message: 31/12/2011, 15h32
  4. Réponses: 3
    Dernier message: 21/08/2009, 15h16
  5. Comment supprimer des fichiers en nombre ?
    Par Didier L dans le forum API, COM et SDKs
    Réponses: 13
    Dernier message: 25/01/2005, 16h01

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo