Discussion :

[mlaiti]

Bonjour,
Je sais que c'est très simple pour les pro.
Mais, je suis débutante.

Je cherche à développer un porgramme C qui lit un fichier mot par mot.
Les séparateurs des mots étant les séparateurs "classiques" ( ,:; espace tabulation ...etc).

Voilà où j'en suis :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
#include <stdio.h>
main()
{
  FILE *P_FICHIER;      /* pointeur sur FILE */
  char NOM_FICHIER[30]; /* nom du fichier */
        strcpy(NOM_FICHIER,"toto.txt");
     P_FICHIER = fopen(NOM_FICHIER, "r");
if (!P_FICHIER)
printf("\aERREUR: Impossible d'ouvrir le fichier: %s.\n", NOM_FICHIER);
        fclose(P_FICHIER);
 
}

Merci beaucoup d'avance.

[Médinoc]

Mon conseil: Lis le fichier ligne par ligne (renseigne-toi sur des fonctions comme fgets() et fclean() sur le forum), il te sera ensuite pus facile de séparer chaque ligne en mots.

PS: N'utilise pas de noms de variables tout en majuscules. Traditionnellement, on réserve les majuscules pour les constantes.

[darrylsite]

Tu peux aussi, si tu veux tout programmer, lire le fichier caractere par caractere et ensuite former les mots (par concatenation) selon les regles que tu as definies.

[Scoaz]

Le mieux reste de coder un "get_next_word" un peu comme un get_next_line (fgets) c'est juste le délimiteur qui change. A la limite tu choppe les sources du fgets et du modifie juste ce qu'il faut, sinon tu risque de te prendre un peu la tête. Parce que lire lettre par lettre c'est HYPER moche et lire ligne par ligne ça passe mais c'est pas joyeux non plus.

[Thierry Chappuis]

Parce que lire lettre par lettre c'est HYPER moche et lire ligne par ligne ça passe mais c'est pas joyeux non plus.

Pourquoi? Les opérations de saisie sur les fichiers utilisent un mécanisme de tampon. Ainsi, il n'est pas pénalisant de lire un fichier caractère par caractère.

Voici ma version d'une fonction permettant de lire un fichier mot par mot (deux mots étant séparés par un caractère d'espacement reconnu comme tel par isspace()):

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
67
68
69
70
71
72
#include <stdio.h>
#include <ctype.h>
 
enum M_IOErrors {
    M_IO_OK,                /* OK */
    M_IO_EOF,               /* La fin de fichier a ete rencontree */
    M_IO_EOL,               /* Un caractre de fin de ligne a ete rencontre */
    M_IO_INVALID_ARG_ERR,   /* Argument invaide passe a la fonction */
    M_IO_LENGTH_ERR         /* La saisie a ete tronquee */
};
 
int
fget_word(char *buffer, size_t size, FILE *fp)
{
    int err = M_IO_OK;
 
    /* -tc- On teste la validite des arguments */
    if (buffer != NULL && size > (size_t) 1 && fp != NULL)
    {
        size_t i = 0;
        int c = 0;
 
        while (i < size - 1 && (c = fgetc(fp)) != EOF && isspace(c) == 0)
        {
            buffer[i] = c;
            i++;
        }
        buffer[i] = 0;
 
        if (i == size - 1 && isspace(c) == 0 && c != EOF)
        {
            err = M_IO_LENGTH_ERR;
 
            while ((c = fgetc(fp)) != EOF && isspace(c) == 0)
            {
            }
        }
        else if (c == EOF && i == 0)
        {
            err = M_IO_EOF;
        }
        else if (c == '\n')
        {
            err = M_IO_EOL;
        }
    }
    else
    {
        /* -tc- Erreur: argument invalide */
        err = M_IO_INVALID_ARG_ERR;
    }
 
    return err;
}
 
int
main(void)
{
    char mot[20] = "";
    int err = M_IO_OK;
 
    printf("Saisir une phrase: ");
    fflush(stdout);
    do
    {
        err = fget_word(mot, sizeof mot, stdin);
        printf("%s\n", mot);
    }
    while (err != M_IO_EOL);
 
    return 0;
}

J'ai pas testé à fond, mais je le ferai dès que j'aurai un moment.

Thierry

[corentin59]

Dans ton code, Thierry, il y a plusieurs choses que je ne comprend pas :
1) pourquoi, quand il y a un dépassement de la capacité du buffer, M_IO_LENGTH_ERR, tu ne vides le flux d'entrée que jusqu'au prochain caractère d'espace, alors que le do {} while du main est arrêté ?
2) pourquoi lorsque la fonction fget_word() renvoie M_IO_INVALID_ARG_ERR ou M_IO_EOF, ne stoppes-tu pas le do {} while du main ?
3) pourquoi faut-il que i soit égale à 0 pour que la fonction fget_word() renvoie M_IO_EOF ?

[Thierry Chappuis]

Dans ton code, Thierry, il y a plusieurs choses que je ne comprend pas :
1) pourquoi, quand il y a un dépassement de la capacité du buffer, M_IO_LENGTH_ERR, tu ne vides le flux d'entrée que jusqu'au prochain caractère d'espace, alors que le do {} while du main est arrêté ?
2) pourquoi lorsque la fonction fget_word() renvoie M_IO_INVALID_ARG_ERR ou M_IO_EOF, ne stoppes-tu pas le do {} while du main ?
3) pourquoi faut-il que i soit égale à 0 pour que la fonction fget_word() renvoie M_IO_EOF ?

1. Parce que j'ai prévu cette fonction pour réaliser une saisie mot par mot à sur tout un fichier ou sur une entree utilisateur complete. Effectivement, si je décide de quitter la boucle sur un M_IO_LENGTH_ERR et que je travaille aec stdin, il est judicieux de vider le tampon de ce flux manuellement. J'ai édité mon code.
2. Parce que pour la simplicite de l'exemple, je réalise une saisie utilisateur à partir du flux d'entrée standard et qu'il est rare que l'utilisateur saisisse le caractère EOF. Il est fort possible que l'utilisateur redirige un fichier sur stdin, mais je n'ai pas pris le temps de gérer ce cas.
3. Pour la même raison que fgets() renvoie NULL seulement si la fin de fichier est atteinte avant d'avoir pu lire au moins un caractère (ou en cas d'erreur de lecture).

Thierry