Salut à tous,

Je ne sais pas si le titre correspond totalement mais bon on verra bien ce n´es tpas grave.

Voil adans mon programme je voudrais ajouter une fonction de recherche mais je ne suis qu´un débutant et je ne ne connais pas tout le truc.

Pour éviter de vous encombrer avec de l´inutile je ne posterai pas mon code source. Car c´est une fonction à part entière.

Admettons ce code :

1. include < iostream>
2. include < liste.h>

using std::cout:
using std::cin;

/ *A cet endroit un prototype de la fonction " Recherche" de recherche dans la liste ( liste.h).*/

int main()
{
char Nom[64];
char Resultat[64];

cout < < " Que recherchez-vous dans la liste ? " ;
cin > > Nom;
cout < < endl;
Resultat = Recherche(Nom); / *Donc il faut que la fonction retourne une valeur Char.*/
cout < < Resultat < < " : était-ce bien ce que vous cherchiez ? \n"

system("PAUSE");
return 0;
}

En fait voila je souhaiterai tout simplement savoir comment :

- Faire un fichier liste.h contenant des mots, qui peuvent être composés et une fonction qui puissent rechercher dans ce fichier le mot voulu.

J´ai vraiment beaucoup de mal à le mettre en oeuvre. Je ne parviens pas à trouver une solution. En fait il faudrait une fonction qui compare le mot recherché à un mot de la liste et qui passe au mot suivant si le mot de correspond pas etc...

J´ai pensé à strcmp(Chaine1,Chaine2) mais comment rendre ce truc plus plus ergonomique et plus compact ( car fait des comparaison entre chaque mot d´une liste de 300 mots par exemple imaginer le truc quoi...).
De plus comment faire des chaines avec des espaces entre les mots ?

Aussi question subsidiaire : Comment afficher les caractères spéciaux dans une phrase ?
( Exemple : std::cout < < " é è ù ï î etc...")

Merci beaucoup de vos réponses

Pour la question subsidiaire, tu te sers des codes ASCII

Hum et comment les insérer dans une phrase ?

par exemple totalement au hasard :

std::cout < < " Je vais à la pêche";

( car fait des comparaison entre chaque mot d´une liste de 300 mots par exemple imaginer le truc quoi...).

--> j´imagine bien :

for(i=0;i<300;i++)
if ( strcmp(liste[i],nom)==0)
return i;

et oui, le for est uen instruction puissante !

Bon, allez, je te donne un code :

char liste[300][30];
int nbmots=0;
/ / je crée un tableau pouvant acceuillir 300 mots maxi de 30 lettres max ( a toi de changer si tu le désires ! )

void LoadMots(char* fichier)
{
FILE* F=fopen(fichier,"r");
while(!feof(F))
{
fscanf(F,"%s",&(liste[nbmots]));
nbmots++;
}
}

int Recherche(char* mot)
{
int i;
for(i=0;i<nbmots;i++)
{
if ( strcmp(liste[i],mot)==0)
return i;
}
return -1;
}

Voila, tu lances le chargement une fois pour toutes.
Ensuite, a chaque recherche tu lances ta fonction recherche. Toi tu voulais qu´elle retourne un char*, moi je pense qu´il est meilleur de lui faire retourner
un int : la position du mot dans la liste. -1 si le mot n´est pas la.
Attention a la casse : ( majuscules / minuscules) si tu veux l´ignorer, utilise stricmp.

et si tu veux une recherche rapide, tu fais un arbre lexical, ou des identifiants tries de chaines, histoire de faire le moins de comparaisons possibles ( mais en l´occurence, sur 300 mots c´est pas trop la peine.. quand t´en auras plusieurs milliers, oui)

Merci beaucoup JeanYvesYves

Je vais adapter ce code à mon programme, merci encore

Au fait ils sont bien foutu tes tuto sur ton site, j´ai appris pas mal de choses

moi je suis en train de faire un programme de scrabble:

je définit préalablement

struct noeud_dico
{
bool exist;
struct noeud_dico* lt[26];
};
typedef struct noeud_dico noeud;

noeud* pDico;

Voici ma procédure de chargement du dico dans la ram:

noeud* ChargementDico(char* nom_fichier)
{
ifstream f(nom_fichier);
if(!f.good()) return NULL;
noeud* q = new noeud;
q->exist = false;
for(int i=0;i<26;i++) q->lt[i] = NULL;
while(!f.eof())
{
char buffer[16];
f > > buffer;
noeud* p = q;
for(int i=0;buffer[i];i++)
{
int n = ( int)buffer[i] - 97;
if(!p->lt[n])
{
p->lt[n] = new noeud;
p->lt[n]->exist = false;
for(int j=0;j<26;j++)
p->lt[n]->lt[j] = NULL;
}
p = p->lt[n];
}
p->exist = true;
}
f.close();
return q;
}

Et ma procedure de recherche ( qui renvoie seulement un booléen) est la suivante:

bool VerifMotDico(char* cMot, int nLong)
{
noeud* p = pDico;
for(int i=0;i<nLong;i++)
{
int k = ( int)cMot[i]-97;
if(p->lt[k]) p = p->lt[k];
else return false;
}
return p->exist;
}

Je ne me suis inspiré de rien du tout et donc je ne sais pas ce que ca vaut... mais je trouve que c´est pas mal pour un début...

tu devrai trier ta liste de mots et effectuer une recherche par dichotomie :

c´est un cycle ki se repete :
- tu prend le mot du milieu et tu compare
- si c´est apres, tu elimine la moitie des mots ki sont avant
- si c´est avant, tu elimine la moitie des mots ki sont apres
- tu recommence jusqu´a ce qu´il te reste plus k1 seul mot

au lieu de 300 comparaisons, tu as log^2 ( 300) = 4,5 il me semble

ca fait en moyenne 9 comparaison plutot que 300, mais d´autre part il ne faut pas que la méthode dichotomique prenne trop de temps non plus...

ah oui, erreur de calcul de ma part
Si la liste n´est modifiee que rarement par le programme, alors cette methode est largement envisageable... ( c´est le principe de base :p )

si vous permettez une suggestion algorithmique, il pourrait décomposer sa base de données en sous-bases selon la première lettre, ça lui ferait gagner un peu de temps.... il n´aurait qu´une petite qté de tableaux à comparer.