La solution (2 : la gestion du dictionnaire)



Nous avons fait le tour des fonctionnalités de base de notre programme. Il contient tout ce qu'il faut pour gérer une partie, mais il ne sait pas sélectionner un mot au hasard dans un dictionnaire de mots. Vous pouvez voir à quoi ressemble mon code source au complet à ce stade de son écriture (donc sans la gestion du dictionnaire) sur le web. Je ne l'ai pas placé ici car il prend déjà plusieurs pages et ferait doublon avec le code source final complet que vous verrez un peu plus bas.

Avant d'aller plus loin, la première chose à faire maintenant est de créer ce fameux dictionnaire de mots. Même s'il est court ce n'est pas grave, il conviendra pour les tests.

Je vais donc créer un fichier dico.txt dans le même répertoire que mon projet. Pour le moment, j'y mets les mots suivants :

MAISON

BLEU

AVION

XYLOPHONE

ABEILLE

IMMEUBLE

GOURDIN

NEIGE

ZERO


Une fois que j'aurai terminé de coder le programme, je reviendrai bien sûr sur ce dictionnaire et j'y ajouterai évidemment des tooonnes de mots tordus comme XYLOPHONE, ou à rallonge comme ANTICONSTITUTIONNELLEMENT. Mais pour le moment, retournons à nos instructions.

Préparation des nouveaux fichiers


La lecture du « dico » va demander pas mal de lignes de code (du moins, j'en ai le pressentiment). Je prends donc les devants en ajoutant un nouveau fichier à mon projet : dico.c (qui sera chargé de la lecture du dico). 


Dans la foulée, je crée le dico.h qui contiendra les prototypes des fonctions contenues dans dico.c.

Dans dico.c, je commence par inclure les bibliothèques dont j'aurai besoin ainsi que mon dico.h.


A priori, comme souvent, j'aurai besoin de stdio et stdlib ici. En plus de cela, je vais être amené à piocher un nombre au hasard dans le dico, je vais donc inclure time.h comme on l'avait fait pour notre premier projet « Plus ou Moins ». Je vais aussi avoir besoin de string.hpour faire un strlen vers la fin de la fonction :

#include <stdio.h>

#include <stdlib.h>

#include <time.h>

#include <string.h>


#include "dico.h"


La fonction piocherMot


Cette fonction va prendre un paramètre : un pointeur sur la zone en mémoire où elle pourra écrire le mot. Ce pointeur sera fourni par le main().
La fonction renverra un int qui sera un booléen : 1 = tout s'est bien passé, 0 = il y a eu une erreur.

Voici le début de la fonction :

int piocherMot(char *motPioche)

{

    FILE* dico = NULL; // Le pointeur de fichier qui va contenir notre fichier

    int nombreMots = 0, numMotChoisi = 0, i = 0;

    int caractereLu = 0;


Je définis quelques variables qui me seront indispensables. Comme pour le main(), je n'ai pas pensé à mettre toutes ces variables dès le début, il y en a certaines que j'ai ajoutées par la suite lorsque je me suis rendu compte que j'en avais besoin.

Les noms des variables parlent d'eux-mêmes. On a notre pointeur sur fichier dico dont on va se servir pour lire le fichier dico.txt, des variables temporaires qui vont stocker les caractères, etc.
Notez que j'utilise ici un int pour stocker un caractère (caractereLu) car la fonction fgetc que je vais utiliser renvoie un int. Il est donc préférable de stocker le résultat dans un int.

Passons à la suite :

dico = fopen("dico.txt", "r"); // On ouvre le dictionnaire en lecture seule


// On vérifie si on a réussi à ouvrir le dictionnaire

if (dico == NULL) // Si on n'a PAS réussi à ouvrir le fichier

{

    printf("\nImpossible de charger le dictionnaire de mots");

    return 0; // On retourne 0 pour indiquer que la fonction a échoué

    // À la lecture du return, la fonction s'arrête immédiatement.

}


Je n'ai pas grand-chose à ajouter ici. J'ouvre le fichier dico.txt en lecture seule ("r") et je vérifie si j'ai réussi en testant si dico vaut NULL ou non. Si dico vaut NULL, le fichier n'a pas pu être ouvert (fichier introuvable ou utilisé par un autre programme). Dans ce cas, j'affiche une erreur et je fais un return 0.

Pourquoi un return là ? En fait, l'instruction return commande l'arrêt de la fonction. Si le dico n'a pas pu être ouvert, la fonction s'arrête là et l'ordinateur n'ira pas lire plus loin. On retourne 0 pour indiquer au main que la fonction a échoué.

Dans la suite de la fonction, on suppose donc que le fichier a bien été ouvert.

// On compte le nombre de mots dans le fichier (il suffit de compter les entrées \n

do

{

    caractereLu = fgetc(dico);

    if (caractereLu == '\n')

        nombreMots++;

} while(caractereLu != EOF);


Là, on parcourt tout le fichier à coups de fgetc (caractère par caractère). On compte le nombre de \n (entrées) qu'on détecte. À chaque fois qu'on tombe sur un \n, on incrémente la variable nombreMots.


Grâce à ce bout de code, on obtient dans nombreMots le nombre de mots dans le fichier. Rappelez-vous que le fichier contient un mot par ligne.

numMotChoisi = nombreAleatoire(nombreMots); // On pioche un mot au hasard


Ici, je fais appel à une fonction de mon cru qui va générer un nombre aléatoire entre 1 et nombreMots (le paramètre qu'on envoie à la fonction).


C'est une fonction toute simple que j'ai placée aussi dans dico.c (je vous la détaillerai tout à l'heure). Bref, elle renvoie un nombre (correspondant à un numéro de ligne du fichier) au hasard qu'on stocke dans numMotChoisi.

// On recommence à lire le fichier depuis le début. On s'arrête lorsqu'on est arrivé au bon mot

rewind(dico);

while (numMotChoisi > 0)

{

    caractereLu = fgetc(dico);

    if (caractereLu == '\n')

        numMotChoisi--;

}


Maintenant qu'on a le numéro du mot qu'on veut piocher, on repart au début grâce à un appel à rewind(). On parcourt là encore le fichier caractère par caractère en comptant les \n. Cette fois, on décrémente la variable numMotChoisi. Si par exemple on a choisi le mot numéro 5, à chaque entrée la variable va être décrémentée de 1.


Elle va donc valoir 5, puis 4, 3, 2, 1… et 0.


Lorsque la variable vaut 0, on sort du while, la condition numMotChoisi > 0 n'étant plus remplie.

Ce bout de code, que vous devez impérativement comprendre, vous montre donc comment on parcourt un fichier pour se placer à la position voulue. Ce n'est pas bien compliqué, mais ce n'est pas non plus « évident ». 


Assurez-vous donc de bien comprendre ce que je fais là.

Maintenant, on devrait avoir un curseur positionné juste devant le mot secret qu'on a choisi de piocher.


On va le stocker dans motPioche (le paramètre que la fonction reçoit) grâce à un simple fgets qui va lire le mot :

/* Le curseur du fichier est positionné au bon endroit.

On n'a plus qu'à faire un fgets qui lira la ligne */

fgets(motPioche, 100, dico);


// On vire le \n à la fin

motPioche[strlen(motPioche) - 1] = '\0';


On demande au fgets de ne pas lire plus de 100 caractères (c'est la taille du tableau motPioche, qu'on a défini dans le main). N'oubliez pas que fgets lit toute une ligne, y compris le \n.


Comme on ne veut pas garder ce \n dans le mot final, on le supprime en le remplaçant par un \0. Cela aura pour effet de couper la chaîne juste avant le \n.

Et… voilà qui est fait ! On a écrit le mot secret dans la mémoire à l'adresse de motPioche.

On n'a plus qu'à fermer le fichier, à retourner 1 pour que la fonction s'arrête et pour dire que tout s'est bien passé :

fclose(dico);


    return 1; // Tout s'est bien passé, on retourne 1

}


Pas besoin de plus pour la fonction piocherMot !

La fonction nombreAleatoire


C'est la fonction dont j'avais promis de vous parler tout à l'heure. On tire un nombre au hasard et on le renvoie :

int nombreAleatoire(int nombreMax)

{

    srand(time(NULL));

    return (rand() % nombreMax);

}


La première ligne initialise le générateur de nombres aléatoires, comme on a appris à le faire dans le premier TP « Plus ou Moins ».
La seconde ligne prend un nombre au hasard entre 0 et nombreMax et le renvoie. Notez que j'ai fait tout ça en une ligne, c'est tout à fait possible, bien que peut-être parfois moins lisible.

Le fichier dico.h


Il s'agit juste des prototypes des fonctions. Vous remarquerez qu'il y a la « protection » #ifndef que je vous avais demandé d'inclure dans tous vos fichiers .h (revoyez le chapitre sur le préprocesseur au besoin).

#ifndef DEF_DICO

#define DEF_DICO


int piocherMot(char *motPioche);

int nombreAleatoire(int nombreMax);


#endif


Le fichier dico.c


Voici le fichier dico.c en entier :

/*

Jeu du Pendu


dico.c

------


Ces fonctions piochent au hasard un mot dans un fichier dictionnaire

pour le jeu du Pendu

*/


#include <stdio.h>

#include <stdlib.h>

#include <time.h>

#include <string.h>


#include "dico.h"


int piocherMot(char *motPioche)

{

    FILE* dico = NULL; // Le pointeur de fichier qui va contenir notre fichier

    int nombreMots = 0, numMotChoisi = 0, i = 0;

    int caractereLu = 0;

    dico = fopen("dico.txt", "r"); // On ouvre le dictionnaire en lecture seule


    // On vérifie si on a réussi à ouvrir le dictionnaire

    if (dico == NULL) // Si on n'a PAS réussi à ouvrir le fichier

    {

        printf("\nImpossible de charger le dictionnaire de mots");

        return 0; // On retourne 0 pour indiquer que la fonction a échoué

        // À la lecture du return, la fonction s'arrête immédiatement.

    }


    // On compte le nombre de mots dans le fichier (il suffit de compter les

    // entrées \n

    do

    {

        caractereLu = fgetc(dico);

        if (caractereLu == '\n')

            nombreMots++;

    } while(caractereLu != EOF);


    numMotChoisi = nombreAleatoire(nombreMots); // On pioche un mot au hasard


    // On recommence à lire le fichier depuis le début. On s'arrête lorsqu'on est arrivé au bon mot

    rewind(dico);

    while (numMotChoisi > 0)

    {

        caractereLu = fgetc(dico);

        if (caractereLu == '\n')

            numMotChoisi--;

    }


    /* Le curseur du fichier est positionné au bon endroit.

    On n'a plus qu'à faire un fgets qui lira la ligne */

    fgets(motPioche, 100, dico);


    // On vire le \n à la fin

    motPioche[strlen(motPioche) - 1] = '\0';

    fclose(dico);


    return 1; // Tout s'est bien passé, on retourne 1

}


int nombreAleatoire(int nombreMax)

{

    srand(time(NULL));

    return (rand() % nombreMax);

}



Il va falloir modifier le main !


Maintenant que le fichier dico.c est prêt, on retourne dans le main() pour l'adapter un petit peu aux quelques changements qu'on vient de faire.

Déjà, on commence par inclure dico.h si on veut pouvoir faire appel aux fonctions de dico.c. De plus, on va aussi inclure string.h car on va devoir faire un strlen :

#include <string.h>

#include "dico.h"


Pour commencer, les définitions de variables vont un peu changer. Déjà, on n'initialise plus la chaîne motSecret, on crée juste un grand tableau de char (100 cases).

Quant au tableau lettreTrouvee… sa taille dépendra de la longueur du mot secret qu'on aura pioché. Comme on ne connaît pas encore cette taille, on crée un simple pointeur. Tout à l'heure, on fera un malloc et pointer ce pointeur vers la zone mémoire qu'on aura allouée.


Ceci est un exemple parfait de l'absolue nécessité de l'allocation dynamique : on ne connaît pas la taille du tableau avant la compilation, on est donc obligé de créer un pointeur et de faire un malloc.

Je ne dois pas oublier de libérer la mémoire ensuite quand je n'en ai plus besoin, d'où la présence d'un free() à la fin du main.

On va aussi avoir besoin d'une variable tailleMot qui va stocker… la taille du mot. En effet, si vous regardez le main() tel qu'il était dans la première partie, on supposait que le mot faisait 6 caractères partout (et c'était vrai car MARRON comporte 6 lettres). Mais maintenant que le mot peut changer de taille, il va falloir être capable de s'adapter à tous les mots !

Voici donc les définitions de variables du main en version finale :

int main(int argc, char* argv[])

{

    char lettre = 0; // Stocke la lettre proposée par l'utilisateur (retour du scanf)

    char motSecret[100] = {0}; // Ce sera le mot à trouver

    int *lettreTrouvee = NULL; // Un tableau de booléens. Chaque case correspond à une lettre du mot secret. 0 = lettre non trouvée, 1 = lettre trouvée

    int coupsRestants = 10; // Compteur de coups restants (0 = mort)

    int i = 0; // Une petite variable pour parcourir les tableaux

    int tailleMot = 0;


C'est principalement le début du main qui va changer, donc analysons-le de plus près :

if (!piocherMot(motSecret))

    exit(0);


On fait d'abord appel à piocherMot directement dans le if. piocherMot va placer dans motSecret le mot qu'elle aura pioché.

De plus, piocherMot va renvoyer un booléen pour nous dire si la fonction a réussi ou échoué. Le rôle du if est d'analyser ce booléen. Si ça n'a PAS marché (le ! permet d'exprimer la négation), alors on arrête tout (exit(0)).

tailleMot = strlen(motSecret);


On stocke la taille du motSecret dans tailleMot comme je vous l'ai dit tout à l'heure.

lettreTrouvee = malloc(tailleMot * sizeof(int)); // On alloue dynamiquement le tableau lettreTrouvee (dont on ne connaissait pas la taille au départ)

if (lettreTrouvee == NULL)

    exit(0);


Maintenant on doit allouer la mémoire pour le tableau lettreTrouvee. On lui donne la taille du mot (tailleMot).


On vérifie ensuite si le pointeur n'est pas NULL. Si c'est le cas, c'est que l'allocation a échoué. Dans ce cas, on arrête immédiatement le programme (on fait appel à exit()).

Si les lignes suivantes sont lues, c'est donc que tout s'est bien passé.

Voilà tous les préparatifs qu'il vous fallait faire ici. J'ai dû ensuite modifier le reste du fichier main.c pour remplacer tous les nombres 6 (l'ancienne longueur de MARRON qu'on avait fixée) par la variable tailleMot. Par exemple :

for (i = 0 ; i < tailleMot ; i++)

    lettreTrouvee[i] = 0;


Ce code met toutes les cases du tableau lettreTrouvee à 0, en s'arrêtant lorsqu'on a parcouru tailleMot cases.

J'ai dû aussi remanier le prototype de la fonction gagne pour ajouter la variable tailleMot. Sans cela, la fonction n'aurait pas su quand arrêter sa boucle.

Voici le fichier main.c final en entier :

/*

Jeu du Pendu


main.c

------


Fonctions principales de gestion du jeu

*/


#include <stdio.h>

#include <stdlib.h>

#include <ctype.h>

#include <string.h>


#include "dico.h"


int gagne(int lettreTrouvee[], long tailleMot);

int rechercheLettre(char lettre, char motSecret[], int lettreTrouvee[]);

char lireCaractere();


int main(int argc, char* argv[])

{

    char lettre = 0; // Stocke la lettre proposée par l'utilisateur (retour du scanf)

    char motSecret[100] = {0}; // Ce sera le mot à trouver

    int *lettreTrouvee = NULL; // Un tableau de booléens. Chaque case correspond à une lettre du mot secret. 0 = lettre non trouvée, 1 = lettre trouvée

    long coupsRestants = 10; // Compteur de coups restants (0 = mort)

    long i = 0; // Une petite variable pour parcourir les tableaux

    long tailleMot = 0;


    printf("Bienvenue dans le Pendu !\n\n");


    if (!piocherMot(motSecret))

        exit(0);


    tailleMot = strlen(motSecret);


    lettreTrouvee = malloc(tailleMot * sizeof(int)); // On alloue dynamiquement le tableau lettreTrouvee (dont on ne connaissait pas la taille au départ)

    if (lettreTrouvee == NULL)

        exit(0);


    for (i = 0 ; i < tailleMot ; i++)

        lettreTrouvee[i] = 0;


    /* On continue à jouer tant qu'il reste au moins un coup à jouer ou qu'on

     n'a pas gagné */

    while (coupsRestants > 0 && !gagne(lettreTrouvee, tailleMot))

    {

        printf("\n\nIl vous reste %ld coups a jouer", coupsRestants);

        printf("\nQuel est le mot secret ? ");


        /* On affiche le mot secret en masquant les lettres non trouvées

        Exemple : *A**ON */

        for (i = 0 ; i < tailleMot ; i++)

        {

            if (lettreTrouvee[i]) // Si on a trouvé la lettre n° i

                printf("%c", motSecret[i]); // On l'affiche

            else

                printf("*"); // Sinon, on affiche une étoile pour les lettres non trouvées

        }


        printf("\nProposez une lettre : ");

        lettre = lireCaractere();


        // Si ce n'était PAS la bonne lettre

        if (!rechercheLettre(lettre, motSecret, lettreTrouvee))

        {

            coupsRestants--; // On enlève un coup au joueur

        }

    }


    if (gagne(lettreTrouvee, tailleMot))

        printf("\n\nGagne ! Le mot secret etait bien : %s", motSecret);

    else

        printf("\n\nPerdu ! Le mot secret etait : %s", motSecret);


    free(lettreTrouvee); // On libère la mémoire allouée manuellement (par malloc)


        return 0;

}


char lireCaractere()

{

    char caractere = 0;


    caractere = getchar(); // On lit le premier caractère

    caractere = toupper(caractere); // On met la lettre en majuscule si elle ne l'est pas déjà


    // On lit les autres caractères mémorisés un à un jusqu'au \n

    while (getchar() != '\n') ;


    return caractere; // On retourne le premier caractère qu'on a lu

}


int gagne(int lettreTrouvee[], long tailleMot)

{

    long i = 0;

    int joueurGagne = 1;


    for (i = 0 ; i < tailleMot ; i++)

    {

        if (lettreTrouvee[i] == 0)

            joueurGagne = 0;

    }


    return joueurGagne;

}


int rechercheLettre(char lettre, char motSecret[], int lettreTrouvee[])

{

    long i = 0;

    int bonneLettre = 0;


    // On parcourt motSecret pour vérifier si la lettre proposée y est

    for (i = 0 ; motSecret[i] != '\0' ; i++)

    {

        if (lettre == motSecret[i]) // Si la lettre y est

        {

            bonneLettre = 1; // On mémorise que c'était une bonne lettre

            lettreTrouvee[i] = 1; // On met à 1 la case du tableau de booléens correspondant à la lettre actuelle

        }

    }


    return bonneLettre;

}

Créé avec HelpNDoc Personal Edition: Écrire des livres électroniques ePub pour l'iPad