Discussion :

[noinneh]

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.

[matazz]

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

Code :

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

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...

[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?

[matazz]

...
personne pour une explications de findfirststream?

de std::stringstream

[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.

[Laurent Gomila]

Si ton mot ne comporte pas d'espaces :

Code :

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

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");

[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.

[Luc Hermitte]

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 :

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
 
#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;
}

[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