Pendu

Le problème exposé dans ce sujet a été résolu.

Bonjour je suis en train de faire un pendu en C et j'ai déjà réalisé la première partie du code, ou une variable est une chaîne qui est le mot à trouver mais j'aimerais pouvoir le faire avec un fichier avec plusieurs mots.

Voici la première partie du code : 

 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
#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
#include <string.h>



char lireCaractere()
{
    char caractere=0;
    caractere = getchar();
    caractere = toupper(caractere);

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

    return caractere;

}

int main()
{
    int NB_COUP_MAX = 10;
    char const motSecre[]="BONJOUR";
    char motActuel[128]="*******";
    char maLettre=0;
    int lettreTrouvee = 0; // booléen 
    int j = 0;
    int longueur= strlen(motSecre);
    printf("Bienvenue sur le jeu du pendu ! \n ");



    while(strcmp(motSecre, motActuel) != 0 && NB_COUP_MAX > 0)
    {
        printf("Voici le mot actuel: %s, il vous reste %d \n", motActuel, NB_COUP_MAX);
        printf("Saisir une lettre: ");
        maLettre=lireCaractere();
        for(j=0 ; j<longueur ; j++){
            if(motSecre[j] == maLettre){
                motActuel[j] = maLettre;
                lettreTrouvee = 1;
            }


        }

        if(lettreTrouvee == 0){
            NB_COUP_MAX -= 1;   
        }

    }
    if(strcmp(motSecre, motActuel) == 0)
        printf("Félicitation vous avez trouvé le bon mot: %s ! \n", motSecre);
    else
        printf("Vous avez perdu, le nombre de tentatives a été atteint ! \n");

    return 0;

J'ai ensuite fait une deuxième partie qui consiste à compter le nombre de lignes du fichier et à stocker cette valeur dans une variable compteur.

 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
#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
#include <string.h>

int main(void)
{   
    int caractere = 0;
    int compteur = 0;
    FILE *fichier = fopen("test", "r");

    if(fichier != NULL)
    {

    do
    {
        caractere=fgetc(fichier);
        if(caractere == '\n')
            compteur++;

    }while(caractere != EOF);
    printf("Compteur : %d\n",compteur );
    rewind(fichier);

    fclose(fichier);

}


    return 0;
}

J'utilise rewind pour revenir à la position de départ du fichier, le soucis c'est que j'aimerais donc ensuite pouvoir saisir aléatoirement un nombre entre 1 et le compteur et ensuite me déplacer dans mon fichier par LIGNE et stocker ce mot dans une chaîne mais je vois pas comment me déplacer par ligne.

J'ai vu qu'il y avait la fonction fseek mais elle permet de se déplacer par caractère. Ou faut-il utiliser la fonction fgets ? mais comment l'utiliser avec le compteur ?

Enfin pour générer un nombre aléatoire on utilise la fonction rand du coup ? 

1
2
int nombreAleatoire;
nombreAleatoire = rand(1, compteur);

ça donnerait ça ?

+0 -0

Salut,

Pour tirer un nombre aléatoire, tu utilises bien rand, mais rand ne prend pas de paramètre. rand renvoie un nombre entre 0 et RAND_MAX. Pour avoir un nombre entre a et b, tu peux faire ceci.

 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
/**
 * \fn double random(void)
 * \brief Tire au hasard un nombre entre 0 et 1.
 * \return Un flottant entre 0 et 1.
 */
double random(void)
{
    return (double) rand() / RAND_MAX;
}

/**
 * \fn int randint(const int a, const int b)
 * \brief Tire au hasard un entier entre a et b.
 * \param a Borne inférieure.
 * \param b Borne supérieure.
 * \return Un entier entre a et b.
 */
int randint(const int a, const int b)
{
    return (int)(a + (b - a) * random());
}


int main(void)
{
    srand((unsigned int) time(NULL));
    printf("%d", randint(1, 100));
    return 0; 
}

EDIT : pour le dictionnaire, je te conseille de charger tout tes mots dans un tableau au début de ton programme, pour ne pas voir à relire le fichier à chaque fois. Et je te conseille de faire plus de fonctions. :)

+0 -0

Re!

J'ai essayé de regarder mon algo, pour stocker les valeurs du fichier dans un tableau mais sans succès.

La fonction fgets ne permet-elle pas de stocker ces mots dans un tableau de chaîne ? 

 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
#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
#include <string.h>

#define MAX_SIZE 4096
int main(void)
{
    FILE *fichier = fopen("test", "r");
    char word[MAX_SIZE];
    int compteur = 0;
    int i = 0;



    if(fichier != NULL)
    {
        while(fgets(word, MAX_SIZE, fichier) != NULL)
        {
            printf("%s \n",word );
            compteur++;
            i++;

        }



        printf("%d\n",compteur);
        printf("%s \n",word);



        fclose(fichier);



    }
    return 0;
}

Au vu de la compilation de mon code je dirai que ça stocke un mot par mot.

Le pb étant j'ai l'impression que mon tableau est un tableau de char du coup mais pas de chaîne.

Mais du coup je sais pas trop comment faire :/

+0 -0

C’est normal, une chaîne de caractères est un tableau de char, donc un tableau de chaînes est un tableau de tableaux de char.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
#include <stdio.h>
#include <stdlib.h>
#define MAX_SIZE 4096

int main(void)
{
    FILE *fichier = fopen("test", "r");
    char word[100][MAX_SIZE + 1]; /* 100 chaines de caracteres de taille MAX_SIZE*/
    int i = 0, nb_mots = 0;

    if(fichier != NULL)
    {
        for(nb_mots = 0; nb_mots < 100; nb_mots++)
            if(fgets(word[nb>_mots], MAX_SIZE, fichier) == NULL)
                break;
        for(i = 0; i < nb_mots; i++)
            printf("Mot %d : %s.\n", i, word[i]);
        fclose(fichier);
    }
    return 0;
}

Voilà, j’ai pas testé le code, donc il y a peut-être des erreurs, mais l’idée est là.

Pour ton dictionnaire, ce que tu peux faire, c’est écrire le nombre de mots du fichier au début du fichier, comme ça tu lis le nombre de mots, puis tu alloues dynamiquement un tableau de chaînes de caractères de la bonne taille.

Il te faudra alors utiliser un pointeur sur un tableau de char, ce qui se déclare avec le code char (*words)[SIZE_MAX + 1];.

En fait, moi j’utilise une structure qui contient le nombre de mots et le tableau de chaînes de caractères.

1
2
3
4
5
struct s_book
{
    unsigned int size;
    char (*words)[SIZE_MAX + 1];
};
+0 -0

Je mélange un peu, justement le fait de compter permet de se passer de l'option de mettre le nombre dans le fichier non ?

Et du coup ça serait pas un tableau de char plutôt qu'un tableau de chaîne ? Parce que tu veux dire allouer un tableau de chaîne tu parles de tous les mots ou du mot en question qui a été sélectionné ?

+0 -0

Je mélange un peu, justement le fait de compter permet de se passer de l'option de mettre le nombre dans le fichier non ?

Oui, mais cela signifie qu’il faut faire deux lectures.

Et du coup ça serait pas un tableau de char plutôt qu'un tableau de chaîne ? Parce que tu veux dire allouer un tableau de chaîne tu parles de tous les mots ou du mot en question qui a été sélectionné ?

Selon moi, il vaut mieux charger tout les mots au début du jeu, d’où le tableau de chaînes Ensuite, pour sélectionner un mot, il suffira de tirer un nombre n au hasard entre 0 et book->size - 1 et le mot à deviner sera book->words[n].

+0 -0

J'ai cette erreur quand j'ai essayé de compiler ton code : 

1
2
3
4
5
6
7
8
testFichier2.c: In function ‘main’:
testFichier2.c:19:13: warning: passing argument 1 of ‘fgets’ from incompatible pointer type [-Wincompatible-pointer-types]
    if(fgets(word, MAX_SIZE, fichier)== NULL)
             ^
In file included from testFichier2.c:1:0:
/usr/include/stdio.h:622:14: note: expected ‘char * restrict’ but argument is of type ‘char (*)[4097]’
 extern char *fgets (char *__restrict __s, int __n, FILE *__restrict __stream)
              ^

J'ai eu la même lorsque j'avais essayé de déclarer mon tableau comme ça :

1
char *word[4096];
+0 -0

Oups, je corrige, c’est fgets(word[nb_mots], MAX_SIZE, fichier).

+0 -0

Justement, avec char word[100][MAX_SIZE + 1], je crée un tableau de chaînes, donc word n’est pas une chaîne, contrairement à word[nb_mots]. D’ailleurs le message « xpected ‘char * restrict’ but argument is of type ‘char (*)[4097] » est assez explicite, un argument de type char * est attendu et on fournit un argument du type char (*)[4097].

+0 -0

D'accord merci et dans un de tes précédents message tu avais mis 

1
2
3
 Pour ton dictionnaire, ce que tu peux faire, c’est écrire le nombre de mots du fichier au début du fichier, comme ça tu lis le nombre de mots, puis tu alloues dynamiquement un tableau de chaînes de caractères de la bonne taille.

Il te faudra alors utiliser un pointeur sur un tableau de char, ce qui se déclare avec le code char (*words)[SIZE_MAX + 1];.

mais ça on est pas obligé de le faire vu que ya ton code non ?

D'ailleurs j'ai encore une petite question : un tableau de tableau de char c'est la même chose qu'un pointeur sur un tableau de char ?

+0 -0

Le code que j’ai posté ne peut lire que 100 mots dans le dictionnaire. S’il y en a plus, il ne seront pas lus. Alors qu’avec le nombre de mots, on n’a pas ce problème. En fait, il faut juste faire une fonction de chargement des mots. 

1
2
3
4
5
6
7
/* Retourne par exemple 0 en cas de succès et -1 si erreur. */
int chargerMots(struct s_book *const book, FILE *const file)
{
    /* Lire le nombre de mots dans file. */
    /* Allouer la mémoire pour book->words. */
    /* Lire book->size mots dans file. */
}
+0 -0

D'ac merci et du coup pour ma petite question :un tableau de tableau de char c'est la même chose qu'un pointeur sur un tableau de char ?

Faut que je revoie un peu les pointeurs parce que la notion de base ça va j'ai bien compris mais quand ça part sur des pointeur sur tableau, tableau de tableau, pointeur sur pointeur etc je m'y perds ! :p

+0 -0

Non, non, un tableau et un pointeur ce n’est pas la même chose, donc un tableau de tableau de char n’est pas la même chose qu’un pointeur sur un tableau de char. Lis ce chapitre.

En gros, un tableau est la plupart du temps converti en pointeur constant sur son premier élément, mais pas avec sizeof par exemple. Et donc, lorsqu’un tableau est envoyé à une fonction, c’est un pointeur sur son premier élément que l’on récupère.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
#include <stdio.h>

void func(int tab[])
{
    int *ptr = &(tab[0]);
    printf("tab : %p - ptr : %p.\n", tab, ptr);
    printf("sizeof(tab) : %d - sizeof(ptr) : %d.\n", sizeof(tab), sizeof(ptr)); /* Pareil. */ 
}

int main(void)
{
    int tab[4] = {1, 2, 3, 4};
    int *ptr = &(tab[0]); /* Égal à &tab. */
    printf("tab : %p - ptr : %p.\n", tab, ptr);
    printf("sizeof(tab) : %d - sizeof(ptr) : %d.\n", sizeof(tab), sizeof(ptr)); /* Différent. */
    ptr++; /* Fonctionne, tab++ donne une erreur. */ 
    printf("ptr : %p, ptr);
    return 0;
}
+0 -0

Salut donc j'ai essayé de après avoir compter le nombre de mots, de générer un nombre aléatoire, de me re-déplacer dans le fichier puis de construire une nouvelle chaîne avec le mot correspondant au nombre.Mais j'ai un soucis, j'ai essayé avec ça :

 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
#include <stdio.h>
#include <time.h>
#include <stdlib.h>
#define MAX_SIZE 4096



int randint(int min, int max)
{

    int rand_is_seeded = 0;
    if(!rand_is_seeded)
    {
        srand(time(NULL));
        rand_is_seeded = 1;

    }
    return rand()%(max-min+1) + min;

}

int main(void)
{
    FILE *fichier = fopen("test", "r");
    char word[100][MAX_SIZE + 1]; /* 100 chaines de caracteres de taille MAX_SIZE*/
    char motSecret[MAX_SIZE];
    int i = 0, nb_mots = 0;
    int n;
    int j = 0;
    int caractere = 0;
    srand( time(NULL));

    if(fichier != NULL)
    {
        for(nb_mots = 0; nb_mots < 100; nb_mots++)
            if(fgets(word[nb_mots], MAX_SIZE, fichier) == NULL)
                break;

        n = randint(0, nb_mots-1);

        printf("%d\n",n );

        rewind(fichier);

        for(j = 0; j < nb_mots; j++)
        {
            printf("Mot %d : %s\n", j, word[j]);
            printf("n : %d | j : %d \n", n, j);
            while(j != n)
            {   
                if(fichier != NULL)
                    fgets(motSecret, MAX_SIZE, fichier);
                printf("%s **\n",motSecret);


            }       
        }           
        printf("%s\n",motSecret);

        fclose(fichier);

    }
    return 0;
}

Mais ça me donne une boucle infinie : 

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
3
Mot 0 : Maxime

n : 3 | j : 0 
Maxime
 **
DEUX
 **
MAISON
 **
INFLATION
 **
IMMEUBLE
 **
IMMEUBLE
 **
..

J'ai essayé avec ça aussi : 

 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
#include <stdio.h>
#include <time.h>
#include <stdlib.h>
#define MAX_SIZE 4096



int randint(int min, int max)
{

    int rand_is_seeded = 0;
    if(!rand_is_seeded)
    {
        srand(time(NULL));
        rand_is_seeded = 1;

    }
    return rand()%(max-min+1) + min;

}

int main(void)
{
    FILE *fichier = fopen("test", "r");
    char word[100][MAX_SIZE + 1]; /* 100 chaines de caracteres de taille MAX_SIZE*/
    char motSecret[MAX_SIZE];
    int i = 0, nb_mots = 0;
    int n;
    int j = 0;
    int caractere = 0;
    srand( time(NULL));

    if(fichier != NULL)
    {
        for(nb_mots = 0; nb_mots < 100; nb_mots++)
            if(fgets(word[nb_mots], MAX_SIZE, fichier) == NULL)
                break;

        n = randint(0, nb_mots-1);

        printf("%d\n",n );

        rewind(fichier);

        for(j = 0; j < nb_mots; j++)
        {
            printf("Mot %d : %s\n", j, word[j]);
            printf("n : %d | j : %d \n", n, j);
            while(fgets(motSecret, MAX_SIZE, fichier) != NULL)
            {   
                printf("%s **\n",motSecret);
                if(n == j)
                    break;



            }       
        }           
        printf("%s\n",motSecret);

        fclose(fichier);

    }
    return 0;
}

 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
2
Mot 0 : Maxime

n : 2 | j : 0 
Maxime
 **
DEUX
 **
MAISON
 **
INFLATION
 **
IMMEUBLE
 **
Mot 1 : DEUX

n : 2 | j : 1 
Mot 2 : MAISON

n : 2 | j : 2 
Mot 3 : INFLATION

n : 2 | j : 3 
Mot 4 : IMMEUBLE

n : 2 | j : 4 
IMMEUBLE

Le problème est que ça exécute le while(fgets(motSecret, MAX_SIZE, fichier) != NULL) jusqu'à la fin et ensuite ça prend un nouveau tour de boucle for puis ça rentre dans le if en tout cas j'ai l'impression.

J'ai essayé aussi avec les chaînes de caractères, c'est mieux car j'ai le bon mot mais pas le mot complet :

 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
#include <stdio.h>
#include <time.h>
#include <stdlib.h>
#define MAX_SIZE 4096



int randint(int min, int max)
{

    int rand_is_seeded = 0;
    if(!rand_is_seeded)
    {
        srand(time(NULL));
        rand_is_seeded = 1;

    }
    return rand()%(max-min+1) + min;

}

int main(void)
{
    FILE *fichier = fopen("test", "r");
    char word[100][MAX_SIZE + 1]; /* 100 chaines de caracteres de taille MAX_SIZE*/
    char motSecret[MAX_SIZE];
    int i = 0, nb_mots = 0;
    int n;
    int j = 0;
    int caractere = 0;
    int compteur = 0;

    srand( time(NULL));

    if(fichier != NULL)
    {
        for(nb_mots = 0; nb_mots < 100; nb_mots++)
            if(fgets(word[nb_mots], MAX_SIZE, fichier) == NULL)
                break;

        n = randint(0, nb_mots-1);

        printf("%d\n",n );

        rewind(fichier);

        for(j = 0; j < nb_mots; j++)
        {
            printf("Mot %d : %s\n", j, word[j]);
            printf("n : %d | j : %d \n", n, j);

            while(caractere != EOF)
                {
                    caractere = getc(fichier);
                    motSecret[j] = caractere;
                    printf("%s \n", motSecret);
                    if(caractere == '\n')
                        compteur++;
                        printf("compteur : %d | n : %d \n", compteur,n);
                    if(compteur == n )
                        break;

                }



        }           
        printf("%s\n",motSecret);

        fclose(fichier);

    }
    return 0;
}

 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
3
n : 3 | j : 0 
M 
compteur : 0 | n : 3 
a 
compteur : 0 | n : 3 
x 
compteur : 0 | n : 3 
i 
compteur : 0 | n : 3 
m 
compteur : 0 | n : 3 
e 
compteur : 0 | n : 3 


compteur : 1 | n : 3 
D 
compteur : 1 | n : 3 
E 
compteur : 1 | n : 3 
U 
compteur : 1 | n : 3 
X 
compteur : 1 | n : 3 


compteur : 2 | n : 3 
M 
compteur : 2 | n : 3 
A 
compteur : 2 | n : 3 
I 
compteur : 2 | n : 3 
S 
compteur : 2 | n : 3 
O 
compteur : 2 | n : 3 
N 
compteur : 2 | n : 3 


compteur : 3 | n : 3 
n : 3 | j : 1 

I 
compteur : 3 | n : 3 
n : 3 | j : 2 

IN 
compteur : 3 | n : 3 
n : 3 | j : 3 

INF 
compteur : 3 | n : 3 
n : 3 | j : 4 

INFL 
compteur : 3 | n : 3 

INFL

Je pense que le problème vient de ma boucle for mais je sais pas quoi mettre dans la condition comme je n'ai pas la longueur du mot :p

J'ai essayé avec i<10 pour tester, ça marche mais j'ai quelque chose de bizarre : 

  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
4
n : 4 | j : 0 
M 
compteur : 0 | n : 4 
a 
compteur : 0 | n : 4 
x 
compteur : 0 | n : 4 
i 
compteur : 0 | n : 4 
m 
compteur : 0 | n : 4 
e 
compteur : 0 | n : 4 


compteur : 1 | n : 4 
D 
compteur : 1 | n : 4 
E 
compteur : 1 | n : 4 
U 
compteur : 1 | n : 4 
X 
compteur : 1 | n : 4 


compteur : 2 | n : 4 
M 
compteur : 2 | n : 4 
A 
compteur : 2 | n : 4 
I 
compteur : 2 | n : 4 
S 
compteur : 2 | n : 4 
O 
compteur : 2 | n : 4 
N 
compteur : 2 | n : 4 


compteur : 3 | n : 4 
I 
compteur : 3 | n : 4 
N 
compteur : 3 | n : 4 
F 
compteur : 3 | n : 4 
L 
compteur : 3 | n : 4 
A 
compteur : 3 | n : 4 
T 
compteur : 3 | n : 4 
I 
compteur : 3 | n : 4 
O 
compteur : 3 | n : 4 
N 
compteur : 3 | n : 4 


compteur : 4 | n : 4 
n : 4 | j : 1 

I 
compteur : 4 | n : 4 
n : 4 | j : 2 

IM 
compteur : 4 | n : 4 
n : 4 | j : 3 

IMM 
compteur : 4 | n : 4 
n : 4 | j : 4 

IMME 
compteur : 4 | n : 4 
n : 4 | j : 5 

IMMEU 
compteur : 4 | n : 4 
n : 4 | j : 6 

IMMEUB 
compteur : 4 | n : 4 
n : 4 | j : 7 

IMMEUBL 
compteur : 4 | n : 4 
n : 4 | j : 8 

IMMEUBLE 
compteur : 4 | n : 4 
n : 4 | j : 9 

IMMEUBLE

compteur : 5 | n : 4 

IMMEUBLE� 
compteur : 5 | n : 4 

IMMEUBLE�

J'ai un '?' à la fin du mot.

Désolé pour le pavé :p

+0 -0

Salut,

Déjà, ta fonction randint réutilise srand à chaque fois. Si tu veux que rand_is_seeded garde son ancienne valeur, déclare la en statique.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
int randint(const int a, const int b)
{
    static int rand_is_seeded = 0;
    if(!rand_is_seeded)
    {
        srand((unsigned int) time(NULL));
        rand_is_seeded = 1;
    }
    return (int)(a + (b - a) * (double) rand() / RAND_MAX);
}

En fait, puisque tu utilises srand au début de ton main, retire le de ta fonction randint.

Pour le tirage au hasard, ce n’est pas la peine de relire dans le fichier, puisque tu as déjà mis tous les fichiers dans le tableau.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
int main(void)
{
    FILE *fichier = fopen("test", "r");
    char word[100][MAX_SIZE + 1]; /* 100 chaines de caracteres de taille MAX_SIZE*/
    char *motSecret;
    int i = 0, nb_mots = 0;
    srand((unsigned int) time(NULL));

    if(fichier != NULL)
    {
        /* Chargement des mots */
        for(nb_mots = 0; nb_mots < 100; nb_mots++)
            if(fgets(word[nb_mots], MAX_SIZE, fichier) == NULL)
                break;
        fclose(fichier) /* On n’a plus besoin du fichier */

        n = randint(0, nb_mots - 1); /* On tire un nombre au hasard */
        const char *const motSecret = word[n];       
        printf("%s\n",motSecret);
    }
    return 0;
}

Mais fais plus de fonctions. Même si c’est une action de deux lignes, fais une fonction. Par exemple, une fonction getWord qui tire un nombre au hasard et retourne le mot associé à ce nombre.

+0 -0

En tout cas, il faut vraiment réfléchir en terme de fonctions. Des fonctions doivent être courtes et faire quelque chose de précis. Dans un pendu que j’ai fait, j’ai une dizaine de fonctions courtes, ce qui me permet d’avoir ce main qui, selon moi, se lit bien.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
int main(void)
{
    struct s_book *book = loadBook();
    srand((unsigned int)(time(NULL)));
    if(NULL != book)
    {
        do
        {
            const char *const word = getWord(book);
            play(word);
        }while(replay());
        book = freeBook(book);
    }
    return 0;
}
+0 -0
Connectez-vous pour pouvoir poster un message.
Connexion

Pas encore membre ?

Créez un compte en une minute pour profiter pleinement de toutes les fonctionnalités de Zeste de Savoir. Ici, tout est gratuit et sans publicité.
Créer un compte