Discussion :

[4rocky4]

Bonsoir tout le monde,

est-il possible de rechercher une chaine de caractère dans un fichier txt ?
Admettons que dans mon fichier il y a les lignes :
toto rouge
tata bleu
titi rouge

Est-il possible de vérifier si "tata" est dans notre fichier ?
J'ai fais des recherches qui me ramènent souvent sur Getline. Cela me semble inapproprié dans cette situation.

Merci par avance

[Kiwii]

Ça intéresse comme problème ! J'ai essayé de le faire à grand coup de get mais sans résultat...

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
 
#include<iostream>
#include<fstream>
#include<string>
 
using namespace std;
 
 
int main(){
 
 
 
	int compteur = 0;
	ifstream fichier("Fichier.txt");
	string mot;
	cout << "Mot a rechercher ?" << endl;
	cin >> mot;
 
	if ( mot.size() || fichier.good()){
		for( int i = 0 ; compteur != mot.size() && i <= mot.size() ; i++ ){
			if ( fichier.get() == mot.at(i) ){
				compteur += 1;
			} else {
				compteur = 0;
			}
		}
 
		if ( compteur == mot.size() ){
		cout << "Occurence du mot insere trouve" << endl;
		} else {
			cout << "Pas d'occurence du mot insere trouve" << endl;
		}
	} else {
		cout << "Fichier ou Mot Invalide";
	}
 
	return 0;
}

J'ai modifié mon code fraichement et, n'étant plus très frais je crois que je l'ai complètement bousillé : je le poste quand même

[Emmanuel Deloget]

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
 
template <class Char>
std::size_t get_file_size(std::basic_ifstream<Char>& s)
{
  s.seekg(0, std::end);
  std::size_t l = s.tellg();
  s.seekg(0, std::beg);
  return l;
}
 
bool f(const std::string& filepath, const std::string& str_to_find)
{
  std::ifstream in(filepath);
 
  if (!in) return false;
  std::size_t fsize = get_file_size(in);
  std::vector<char> v(fsize);
  in.read(&v.front(), v.size());
  std::string content(v.begin(), v.end());
 
  return (content.find(str_to_find) != std::string::npos);
}

Mis à part l'ordre des arguments de read, je pense que ça peut fonctionner

Sinon, à base de getline :

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
 
bool f(const std::string& filepath, const std::string& str_to_find)
{
  std::ifstream in(filepath);
 
  while (in && !in.eof())
  {
    std::string line;
    std::getline(in, line);
    // if (line.find(str_to_find) == std::string::npos) // erreur sur cette ligne
    if (line.find(str_to_find) != std::string::npos)
    {
      return true;
    }
  }
 
  return false;
}

Sachant que cette dernière version ne peut pas vérifier si une chaine contient un caractère '\n'.

[JolyLoic]

La première question à se poser est la taille des fichiers que tu veux traiter. Si elle est petite, le plus simple est de tout lire en mémoire dans un string, puis de faire find sur ce string.

Si le fichier peut devenir énorme, une lecture par morceau (par exemple ligne a ligne) devient nécessaire.

[Kiwii]

Voilà avec des char :

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
 
#include<iostream>
#include<fstream>
#include<string>
using namespace std
bool rechercheMot( ifstream& fichier, string mot){
	int compteur = 0;
	char charFichier;
 
	while( !fichier.eof() && compteur < mot.size()){
		fichier.get(charFichier);
		if( charFichier == mot.at(compteur)){
			compteur += 1;
		} else {
			compteur = 0;
		}
 
	}
 
	// Test de fin pour communiquer avec l'exterieur
	if ( compteur == mot.size() ){
		cout << "Occurence du mot insere trouve" << endl;
		return true;
		} else {
		cout << "Pas d'occurence du mot insere trouve" << endl;
		return false;
	}
}

C'est bien beau tout ça mais je pense que la méthode ligne par ligne est plus rapide

Edit du code selon la remarque du voisin d'en dessous

[JolyLoic]

Déjà, je ne vois pas trop la nuance que tu fais entre compteur et i, mais surtout, ce code est un peut trop naïf, et peut échouer.

Par exemple, si la chaîne recherchée est : aab
Et le fichier contient : aaab

[Kiwii]

Exact ! J'avais pas tilté sur ce point à la relecture. La différenciation i et compteur était plus explicite pour moi.

Il est vrai que la recherche caractère par caractère peut échouer, je m'étais dirigé initialement vers cela car je ne pensais pas que le getline() pouvait concerner un seul mot.

[4rocky4]

La première question à se poser est la taille des fichiers que tu veux traiter. Si elle est petite, le plus simple est de tout lire en mémoire dans un string, puis de faire find sur ce string.

Si le fichier peut devenir énorme, une lecture par morceau (par exemple ligne a ligne) devient nécessaire.

J'ai essayé cette solution mais j'obtiens cette erreur :
error: ‘struct std::stringstream’ has no member named ‘find’

Réponse : ajouter .str() au stringstream.

[JolyLoic]

J'ai essayé cette solution mais j'obtiens cette erreur :
error: ‘struct std::stringstream’ has no member named ‘find’

Tu as probablement oublié le .str() pour extraire un string à partir du stringstream.

[4rocky4]

On est synchro :p

Par contre je suis obligé d'utiliser une variable size_t ?

Code :

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

1
2
3
4
5
6
7
8
9
10
size_t found;
        if(fichier)
        {
	    stringstream buffer;
	    buffer << fichier.rdbuf(); 
	    cout << found << endl;
	    found = buffer.str().find(var_recherche);
	    cout << found << endl;
            fichier.close();
        }

Si oui, si la variable est présente il me renvoie une valeur. Si elle n'est présente il me renvoie une valeur très grande !

Comment tester ça proprement ?

[Invité]

La valeur retournée est std::string::npos, qui est un marqueur arbitraire pour désigner la fin d'une chaine de caractère( comme 0 marque le debut de la chaine) : tu peux notament l'utiliser avec substr(d'ailleurs c'est son second paramètre par défaut) :

Code :

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

1
2
3
 
maChaine.substr(3, std::string::npos);
// signifie du 3° caractère à la fin

[4rocky4]

Merci pour ta réponse, c'est bon maintenant