Discussion :

[fxaguessy]

Bonjour à tous,
je souhaiterais avoir des conseils sur un code que j'ai fait car il est pas très rapide, même si c'est pour traiter beaucoup de données (100 000 mots : le nombre de mots en français) Il met en gros 3 secondes à charger. Je voulais savoir si ce code pourrait être amélioré ?
Merci de vos conseils.

Voici les codes :

Dictionnaire.h

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
#include <iostream>
#include <string>
#include <fstream>
 
class Dictionnaire_fils;
 
class Dictionnaire {
 
public:
	/*constructeurs, destructeur, accesseurs*/
	Dictionnaire();
	Dictionnaire(const std::string &adresseFichierDictionnaire);
	~Dictionnaire();
 
	void setFils(Dictionnaire_fils *fils);
	Dictionnaire_fils* getFils();
 
	/* methodes*/
	void ajouterMot(const std::string &mot);
 
protected:
	/* attributs */
 
	bool m_estMot;
	Dictionnaire_fils *m_fils;
 
};

Dictionnaire.cpp:

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
#include "Dictionnaire.h"
#include "Dictionnaire_fils.h"
 
/*constructeurs, destructeur, accesseurs*/
Dictionnaire::Dictionnaire() {
	m_estMot = false;
	m_fils = 0;
}
 
Dictionnaire::Dictionnaire(const std::string &adresseFichierDictionnaire) {
	m_estMot = false;
	m_fils = NULL;
	std::ifstream fichier(adresseFichierDictionnaire.c_str());
	if(!fichier) { std::cerr << "Erreur lors de l'ouverture du dictionnaire " << adresseFichierDictionnaire << std::endl; exit(-1);  }
	std::string str;
	while(getline(fichier,str)) {
		ajouterMot(str);
		/*afficherArbre();*/
	}
}
 
Dictionnaire::~Dictionnaire() {
 
}
 
void Dictionnaire::setFils(Dictionnaire_fils *fils) {
	m_fils = fils;
}
 
Dictionnaire_fils* Dictionnaire::getFils() {
	return m_fils;
}
 
/*Méthodes*/
 
void Dictionnaire::ajouterMot(const std::string &mot) {
	if(mot.empty()) { m_estMot = true; }
	else {
		if(m_fils == NULL) {
			m_fils = new Dictionnaire_fils(mot[0],this);
			m_fils->ajouterMot(mot.substr(1));
		}
		else {
			m_fils->ajouterMotFrere(mot);			
		}
	}
}

Dictionnaire_fils.h

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
#ifndef DICTIONNAIRE_FILS
#define DICTIONNAIRE_FILS
 
#include "Dictionnaire.h"
 
Dictionnaire dico ;
 
class Dictionnaire_fils : public Dictionnaire{
public:
	Dictionnaire_fils();
	Dictionnaire_fils(char caractere,Dictionnaire *pere = NULL,Dictionnaire_fils *frere = NULL);
	~Dictionnaire_fils();
 
	char getChar();
	void setChar(const char nouveauChar);
	void setFrere(Dictionnaire_fils *frere);
 
	void ajouterMotFrere(const std::string &mot,Dictionnaire_fils *createur = NULL);
 
protected:
	char m_char;
	Dictionnaire *m_pere;
	Dictionnaire_fils *m_frere;
 
 
};

Dictionnaire_fils.cpp

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
#include "Dictionnaire_fils.h"
 
Dictionnaire_fils::Dictionnaire_fils() : Dictionnaire() {
	m_char = ' ';
	m_pere = NULL;
	m_frere = NULL;
}
 
Dictionnaire_fils::Dictionnaire_fils(char caractere, Dictionnaire *pere, Dictionnaire_fils *frere) : Dictionnaire(){
	m_char = caractere ;
	m_pere = NULL;
	m_frere = NULL;
	if(pere != NULL) {
	m_pere = pere;
	}
	if(frere != NULL) {
	m_frere = frere;
	}
}
 
Dictionnaire_fils::~Dictionnaire_fils() {
		delete m_fils;
		delete m_frere;
		delete m_pere;
}
 
char Dictionnaire_fils::getChar() {
	return m_char;
}
 
void Dictionnaire_fils::setChar(const char nouveauChar) {
	m_char = nouveauChar;
}
 
void Dictionnaire_fils::setFrere(Dictionnaire_fils *frere) {
	m_frere = frere;
}
 
 
void Dictionnaire_fils::ajouterMotFrere(const std::string &mot,Dictionnaire_fils *createur) {
	char lettre = mot[0];
	if(lettre > m_char) {
		if(m_frere == NULL) {
			m_frere = new Dictionnaire_fils(lettre,m_pere);
			m_frere->ajouterMot(mot.substr(1));
		}
		else {
			m_frere->ajouterMotFrere(mot,this);
		}
	}
	else if (lettre == m_char) {
		ajouterMot(mot.substr(1));
	}
	else {
		if(createur == NULL) { // c'est son père qui l'a appelé
			Dictionnaire_fils *nouveau_fils = new Dictionnaire_fils(lettre,m_pere,this);
			m_pere->setFils(nouveau_fils); // on met le nouveau fils au père
			nouveau_fils->ajouterMot(mot.substr(1));
		}
		else { //c'est son frère gauche qui l'a apellé
			Dictionnaire_fils *nouveau_frere = new Dictionnaire_fils(lettre,m_pere,this);
			createur->setFrere(nouveau_frere);
			nouveau_frere->ajouterMot(mot.substr(1));
		}
	}
}

[crocrodile]

L'emploie du type "string" durant l'insertion (ajouterMot / ajouterMotFils) implique l'instantiation d'un grand nombre d'objets temporaires. L'utilisation de la classe string simplifie effectivement la manipulation des chaînes, mais au détriment des performances.

Si tu utilisais des chaines de caractères (const char *) dans ajouterMot:

Code :

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

void Dictionnaire::ajouterMot(const char * mot)

alors

Code :

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

1
2
 
m_fils->ajouterMot(mot.substr(1));

(appel de fonction + création d'un nouvel objet)

pourrait efficacement être remplacé par:

Code :

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

1
2
 
m_fils->ajouterMot(mot+1);

(aucun cout de traitement ni de mémoire)

Ce n'est qu'un des points sur lesquels tu gagnerais beaucoup à utiliser des chaines natives.

[fxaguessy]

merci beaucoup je viens de modifier juste la fonction d'ajout de mot en remplaçant les string par des char* est je suis passé de 3 sec à 0.95 ! c'est quand même pas négligeable !
Je vais continuer de faire pareil avec les autres fonctions qui sont beaucoup appelées, mais en tout cas merci beaucoup, ça améliore beaucoup!

D'autres remarques ?

Edit:une autre question, est ce que c'est grave d'utiliser 30 Mo de RAM pour un programme?

[michel.bosseaux]

Ca dépend ce que fait le programme en question.

Mais si tu veux absolument réduire, regarde si les données mise en mémoire par le programme sont bien toutes utiles en même temps (s'il est critique d'y accéder rapidement, ou si ça peut se trouver sur disque / dans une DB), si elles ne peuvent pas être représentées autrement (de façon à réduire l'espace nécessaire).

[fxaguessy]

euh en fait pour l'instant j'aimerais faire un programme qui reconnaisse la nature des mots. Donc pour qu'il puisse reconnaitre plusieurs phrase en pas trop longtemps, je pense que je suis obligé de tout stocke en mémoire.