Pour qu'on puisse faire des tests, la première chose à faire c'est de créer ce fameux dictionnaire de mots. Même s'il est court, c'est pas grave c'est pour les tests.
Je vais donc créer un fichier dico.txt
dans le même répertoire que mon projet. Pour le moment, je mets les mots suivants :
Code : Autre1
2
3
4
5
6
7
8
9
| 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 des tooonnes de mots tordus à 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 codes (du moins je le pressens
). 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 de 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, donc je vais inclure time.h comme on l'avait fait pour notre premier projet "Plus ou Moins"
Je vais aussi avoir besoin de string.h pour faire un strlen vers la fin de la fonction :
Code : C | #include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <string.h>
#include "dico.h"
|
La fonction piocherMot
Maintenant, attaquons la fonction qui va être chargée de piocher un mot au hasard dans le dictionnaire.
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 :
Code : C | int piocherMot(char *motPioche)
{
FILE* dico = NULL; // Le pointeur de fichier qui va contenir notre fichier
int nombreMots = 0, numMotChoisi = 0;
int caractereLu = 0;
|
Je définis quelques variables dont je vais avoir besoin. 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 rajoutées par la suite lorsque je me suis rendu compte que j'en avais besoin
Grosso modo, 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 :
Code : C | 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é
// A la lecture du return, la fonction s'arrête immédiatement.
}
|
Je n'ai pas grand chose à rajouter là. 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 pas. Si dico vaut NULL, le fichier n'a pas pu être ouvert (fichier introuvable ou occupé 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 été bien ouvert.
Code : C | // 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 d'\n (entrées) qu'on détecte. A 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).
Code : C | numMotChoisi = nombreAleatoire(nombreMots); // On pioche un mot au hasard
|
Là, je fais appel à une fonction de mon crû 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 numéro au hasard qu'on stocke dans numMotChoisi.
Code : C | // On recommence à lire le fichier depuis le début. On s'arrête lorsqu'on est arrivés 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 du while
numMotChoisi > 0 n'est 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 "super é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 :
Code : C | /* 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 l'\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 l'\n.
Comme on ne veut pas garder cet \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 l'\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 et à retourner 1 pour que la fonction s'arrête et pour dire que tout s'est bien passé :
Code : C | fclose(dico);
return 1; // Tout s'est bien passé, on retourne 1
}
|
Yahou
C'est tout 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 :
Code : C | 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 renvoie ça (j'ai tout mis dans le return comme un gros bourrin que je suis
)
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
)
Code : C | #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 :
Code : C 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
71 | /*
Jeu du pendu
Par M@teo21, pour le Site du Zér0
www.siteduzero.com
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;
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é
// A 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és 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 l'\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
Ensuite, on va inclure string.h en plus là aussi car on va devoir faire un strlen :
Code : C | #include <string.h>
#include "dico.h"
|
Pour commencer, les définitions de variables vont un peu changer. Déjà, on n'initialise plus la chaine 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 on fera pointer ce pointeur vers la zone mémoire qu'on aura allouée.
Ceci est un exemple parfait où l'allocation dynamique est indispensable : on ne connaît pas la taille du tableau avant la compilation, on est donc obligés 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 fait 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 :
Code : C | 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 :
Code : C | 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)).
Code : C | tailleMot = strlen(motSecret);
|
On stocke la taille du motSecret dans tailleMot comme je vous l'ai dit tout à l'heure.
Code : C | 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 comme je vous l'ai dit. 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 que tout s'est bien passé.
Voilà, grosso modo ce sont 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 :
Code : C | 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 modifier 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 :
Code : C 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
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129 | /*
Jeu du pendu
Par M@teo21, pour le Site du Zér0
www.siteduzero.com
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'à l'\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 le case du tableau de booléens correspondant à la lettre actuelle
}
}
return bonneLettre;
}
|
TP : Réalisation d'un pendu
torpix
forsanta
:
Trouvez une formation
Suggestions
Flux RSS News
Twitter
Facebook![http://pro.photomania.com/photoview3.a [...] 4.png&album=1](http://pro.photomania.com/photoview3.asp?login=x_x20012012_VQU2S&photo=radE1E94.png&album=1){kind=link}