compter le nombre d'occurence d'un mot dans un fichier

Version imprimable

17/01/2005, 11h38
noinneh

compter le nombre d'occurence d'un mot dans un fichier

Bonjour,

Pour un moteur de recherche, je cherche une fonction qui me permettrait de calculer le nombre d'occurence d'un mot donné dans un fichier, pour l'instant je détecte la présence d'un mot avec strstr mais si le mot apparait plusieurs fois dans le fichier strstr ne m'aide pas beaucoup.
J'ai vu la fonction finfirststream qui pourrait m'aider mais je ne sais pas m'en servir alors si quelqu'un sait par ici, je suis preneur.

Merci.
17/01/2005, 11h43
matazz

Ben tu charge ton fichier dans une CString et tu fait :

Code:

Fichier.Find(TonMot);

et tu compte le nombre de fois.
Par contre il ne soccupe pas de la Casse de tes lettres.

Je connais pas de méthode toutes faites.
Il ce peut qu'avec les std::string tu ai une méthode qui te compte le nombre d'occurences d'un mot...
17/01/2005, 11h53
noinneh

ça fait presque la même chose que strstr et mon problème demeure merci quand même.
personne pour une explications de findfirststream?
17/01/2005, 12h04
matazz

Citation:

Envoyé par noinneh

...
personne pour une explications de findfirststream?

de std::stringstream
17/01/2005, 12h18
noinneh

j'arrive à capter la première occurence d'un mot dans un fichier mais pas les suivantes, mon moteur de recherche fonctionne donc tres bien mais je voudrais affiner les résultats en triant les fichiers trouvés par rapport au nombre de fois où le mot apparait.
matazz: j'ai oublier de te dire que aprés findfirststream il y a la fonction findnextstream et avec une boucle et un index je pourrais faire ce que je veux mais je ne sais pas utiliser ces fonctions.
Cela dit, en travaillant sur un CString ça doit être posssible mais trop long au niveau codage.

Si ton mot ne comporte pas d'espaces :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
#include <string>
#include <fstream>
#include <algorithm>
 
using namespace std;
 
ifstream File("Toto.txt");
 
if (!File)
    // Erreur...
 
int Occurrences = count(istream_iterator<string>(File), istream_iterator<string>(), "Coucou");

17/01/2005, 19h11
Trap D

Avec strstr, (mais c'est du c), tu obtiens un pointeur p vers la première occurence du mot, donc tu réitères la recherche avec p+1, c'est tout.

Copier-coller d'un de mes vieux codes posté ici -- pour une fois pas de grandes lignes, mais des lignes denses, tu en as de la chance. Il est interessant s'il faut stocker les résultats, à la différence de std::count qui recompte toujours tout. A voir si et comment tu voudrais gérer un cache.
Pour un meilleur parser, voir boost::tokenizer.

Code:

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
 
#include <map>       // std::map<>
#include <vector>    // std::vector<>
#include <algorithm> // std::sort()
#include <string>    // std::string
#include <sstream>   // std::istringstream; pour une petite feinte
#include <iterator>  // std::ostream_iterator
#include <iostream>
 
 
typedef std::map<std::string, int> table_type;
 
struct occurrence_wrapper
{
    typedef occurrence_wrapper self;
 
    friend bool operator<(self const & lhs, self const & rhs)
    { return lhs.elem_->second < rhs.elem_->second; }
 
    friend std::ostream & operator<<(std::ostream & os, self const & v)
    { return os << v.elem_->second << " occ. de " << v.elem_->first; }
 
    // occurrence_wrapper(const table_type::const_iterator & elem) : elem_(&elem) {}
    occurrence_wrapper(const table_type::iterator & elem) : elem_(elem) 
    {
        // std::cout << "add: " << *this << "\n";
    }
    table_type::const_iterator elem_;
};
 
 
void build_table(std::istream & is, table_type & table)
{
    std::string word;
    while (is>>word) {
        // std::cout << "\n{" << word << "} = " << 
        ++table[word];
    }
}
 
int main (int argc, char **argv)
{
    std::string sentence = "Une phrase sans grande importance et qui va être "
        "utilisée comme source des mots pour la table.\n"
        "Note: l'index (/tri) le plus important pour la table est celui "
        "selon les mots et non celui selon les occurrence.";
 
    table_type table;
    std::istringstream iss(sentence);
    build_table(iss, table);
 
    std::vector<occurrence_wrapper> index_occurrences;
    table_type::iterator begin = table.begin();
    table_type::iterator end   = table.end();
    for (; begin != end; ++begin) {
        // copie des itérateurs et non des éléments
        index_occurrences.push_back(begin);
    }
 
    std::stable_sort(index_occurrences.begin(),index_occurrences.end());
    // std::stable_sort au lieu de std::sort pour _garder_ en second
    // ordre celui de la table, i.e. l'alphabétique.
    // sinon, modifier l'opérateur<
 
    std::cout << "Dans l'ordre des occurrences : \n";
    std::copy(index_occurrences.begin(),index_occurrences.end(),
            std::ostream_iterator<occurrence_wrapper>(std::cout, "\n"));
 
    return 0;
}

18/01/2005, 10h58
noinneh

merci pour vos réponses tout le monde j'ai opté pour le strstr avec p+1 parce que je peux avoir des mots avec espace et que je n'utilise pas de tableau mais merci quand même luc et loulou