Discussion :

[kerrons]

Bonsoir,
J'ai cet exercice à faire "Supposons qu’on a un fichier « nombre.txt » contenant des nombres (séparés par des espaces ou des sauts de ligne). Ecrire un programme permettant de lire ces nombres, de calculer et d’afficher leur moyenne." .J'ai écrit mon programme mais après exécution rien ne se passe

Je vous donne l'exemple du fichier sur le quel j'ai travaillé

et le code de mon programme

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
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
int x(FILE *f,int *a)//retourne la somme des nombres et met dans a le nombre des nombres.
{
 
    int n=0;
 
    int s=0;
    while (n!=EOF)
    {
        n=getc(f);
        (*a)++;
        int j=0;
        while ((n!=' ')&&(n!='\n'))
        {
           j++;
           n=getc(f);
        }
        if(j!=0)
        {
         fseek(f,-(j+1),SEEK_CUR);
           n=getc(f);
           for(int i=j;i>0;i--)
           {
               s=s+n*pow(10,i-1);
               n=getc(f);
           }
        }
 
 
    }
    return s;
}
int main()
{
   int r=0;
   int a=-1;
   FILE *f1=NULL;
   f1=fopen("nombre.txt","r");
   if (f1==NULL)
   {
       printf("probleme d'ouverture");
   }
   else
   {
 
           r=x(f1,&a);
           printf("la moyenen est %f",(float)r/a);
   }
   fclose(f1);
}

Pourriez vous m'aider à trouver le problème et merci.
ps: j'ai essayé d'exécuter l'algorithme sur papier avec des exemples et tout me semble correct .

[kerrons]

J'ai une question à propos de la ligne 26 en écrivant s=s+n*pow(10,i-1) est ce que n est considéré comme un entier ou comme le code ASCII de l'entier écrit dans le fichier si c'est le cas comment le transformer en entier.

[gerald3d]

Bonjour.

Tu utilises certaines techniques du C que tu as l’air de maîtriser" c’est un bon point .

Je trouve par contre que côté algorithmie, c’est un peu confus.

La lecture de ton fichier est bien compliqué !

Voilà ce que je ferais pour simplifier tout ce petit monde :

Code :

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

1
2
3
4
5
6
7
8
9
10
total égale zéro 
Compteur égale zéro 
Tant que la fin du fichier n’est pas atteint
  Lire un caractère c
  Si c est différent de espace et différent de retour à la ligne alors faire 
    Ajouter c à total 
    Incrémenter compteur de un
  Fin si
Fin tant que
Renvoyer c divisé par compteur

[Matt_Houston]

Pourquoi donc fseek ? Qu'est-ce qui justifie que tu ne désérialises pas les données séquentiellement ?

Ton fichier est formaté, c'est donc un job pour *scanf (comme scan formatted) ; probablement fscanf.

Même si tu tiens à lire le flux octet par octet, utilise autant que possible les fonctionnalités de la bibliothèque standard : isspace, isdigit, strtol, etc..

[kerrons]

Gerald3d l'algorithme que vous proposez ne fonctionne pas car le fichier peut contenir des nombres >à 9 et lire à partir d'un fichier lit les caractères 1 à 1.
Par exemple à la place d'ajouter 62 au total il va ajouter 6 puis il va ajouter 2.

Matt_houston je ne comprend pas le fonctionnement de fscanf est ce que c'est possible de lire tout les éléments d'un fichier en utilisant un fscanf et comment le faire.
J'ai utilisé fseek apres avoir calculé le nombres de digits dans les nombres pour revenir en arrière et ajouter le nombre qui peut être >9 à la somme avec la formule dans la ligne 26.

[Matt_Houston]

fscanf est la généralisation de scanf - qui lit depuis stdin - pour tous les flux. Outre la démonstration incluse en bas de la page de cppreference.com que j'ai précédemment mentionnée, tu devrais assez aisément trouver des exemples d'utilisation de scanf. L'idée est de réaliser en quelque sorte l'opération inverse d'un printf : plutôt que de produire un message formaté en sortie, on récupère les informations issues de la décomposition d'un message formaté en entrée.

Tu n'as donc pas besoin de fseek. Laisse la bibliothèque standard s'occuper des conversions chaîne -> nombre.

[gerald3d]

Gerald3d l'algorithme que vous proposez ne fonctionne pas car le fichier peut contenir des nombres >à 9 et lire à partir d'un fichier lit les caractères 1 à 1.
Par exemple à la place d'ajouter 62 au total il va ajouter 6 puis il va ajouter 2.

Oui tu as raison. Au passage le tutoiement est de rigueur .

[kerrons]

fscanf est la généralisation de scanf - qui lit depuis stdin - pour tous les flux. Outre la démonstration incluse en bas de la page de cppreference.com que j'ai précédemment mentionnée, tu devrais assez aisément trouver des exemples d'utilisation de scanf. L'idée est de réaliser en quelque sorte l'opération inverse d'un printf : plutôt que de produire un message formaté en sortie, on récupère les informations issues de la décomposition d'un message formaté en entrée.

Tu n'as donc pas besoin de fseek. Laisse la bibliothèque standard s'occuper des conversions chaîne -> nombre.

J'ai réécrit la fonction qui cherche la somme en utilisant fscanf après documentation bien sur mais le code ne fonctionne toujours pas par contre ici le fichier exécutable cesse de fonctionner.

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
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
int x(FILE *f,int *a)//retourne la somme des nombres et met dans a le nombre des nombres.
{
 
    int n=0;
 
    int s=0;
    while (n!=EOF)
    {
        fscanf(f,"%d",n) ;
        if ((n!=' ')&&(n!='\n'))
        {
           s=s+n;
           (*a)++;
        }
    }
    return s;
}
int main()
{
   int r=0;
   int a=0;
   FILE *f1=NULL;
   f1=fopen("nombre.txt","r");
   if (f1==NULL)
   {
       printf("probleme d'ouverture");
   }
   else
   {
 
           r=x(f1,&a);
           printf("la moyenen est %f",(float)r/a);
   }
   fclose(f1);
}

ou bien cette alternative je ne suis pas vraiment certain de la valeur de retour de fscanf

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
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
int x(FILE *f,int *a)//retourne la somme des nombres et met dans a le nombre des nombres.
{
 
    int n=0;
    int b=0;
    int s=0;
    while (b!=EOF)
    {
        b=fscanf(f,"%d",n) ;
 
         if ((n!=' ')&&(n!='\n'))
        {
           s=s+n;
           (*a)++;
        }
    }
    return s;
}
int main()
{
   int r=0;
   int a=0;
   FILE *f1=NULL;
   f1=fopen("nombre.txt","r");
   if (f1==NULL)
   {
       printf("probleme d'ouverture");
   }
   else
   {
 
           r=x(f1,&a);
           printf("la moyenen est %f",(float)r/a);
   }
   fclose(f1);
}

[Sve@r]

J'ai réécrit la fonction qui cherche la somme en utilisant fscanf après documentation bien sur mais le code ne fonctionne toujours pas par contre ici le fichier exécutable cesse de fonctionner.
fscanf(f,"%d",n)

Bonjour

fscanf (tout comme scanf) doit recevoir l'adresse de la variable à remplir. C'est pourtant un truc sensé être acquis vu ton niveau qu'on devine à travers tes codes !!!

je ne suis pas vraiment certain de la valeur de retour de fscanf

Elle retourne le nombre de valeurs qu'elle a pu stocker.

[kerrons]

J'ai oublié de mettre l'adresse de l'entier. Merci bien pour vos remarques le programme fonctionne parfaitement.

[Matt_Houston]

C'est pas mal. Tu aurais vu l'erreur si tu avais compilé avec les warnings, par exemple : -std=c11 -pedantic -Wall -Wextra -Wconversion.

Je te fais un petit retour ligne par ligne sur ton programme :

• #include <stdio.h> Évidemment, c'est nécessaire : on fait de l'I/O.
• #include <stdlib.h> Bof, là non. Pourquoi ?
• #include <math.h> Non plus : tu n'utilises aucune fonction de la libmath.
• int x(FILE *f,int *a)//retourne la somme des nombres et met dans a le nombre des nombres. Passe encore pour f, il est assez clair qu'il s'agit du flux entrant, mais x et a, franchement ? L'ironie est que tu n'aurais sans doute pas eu besoin d'écrire le commentaire si tes variables et fonctions étaient judicieusement nommées.

• Code :

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

  1
  2
  3
  4
  5
  {
   
      int n=0;
      int b=0;
      int s=0;

  Même remarque : vu le niveau général du programme, là tu abuses !

• Code :

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

  1
  2
  3
      while (b!=EOF)
      {
          b=fscanf(f,"%d",n) ;

  Erreur déjà traitée par Sve@r, je ne m'attarde pas.
• if ((n!=' ')&&(n!='\n')) Oui, alors non : n n'est sensé contenir que des entiers convertis avec succès, on ne peut pas s'en servir pour traiter le whitespace et d'ailleurs on n'en a pas besoin. Lis bien la section Notes de la documentation de *scanf : [...] most conversion specifiers first consume all consecutive whitespace [...]. Bien entendu tout cela fonctionne car tu as choisi du whitespace comme séparateur.

• Code :

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

  1
  2
  3
  4
  5
  6
  7
          {
             s=s+n;
             (*a)++;
          }
      }
      return s;
  }

  RAS, mis à part que tu devrais initialiser *a dans la fonction et pas faire confiance à l'appelant pour la mettre à zéro.
• int main() Quitte à ouvrir un fichier et en lire le contenu, pourquoi ne pas en récupérer le chemin depuis la ligne de commande et ainsi rendre ton programme bien plus utilisable flexible ? Présentement il faut tout recompiler pour ouvrir un fichier depuis un autre emplacement.

• Code :

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

  1
  2
  3
  4
  {
     int r=0;
     int a=0;
     FILE *f1=NULL;

  Réécris-moi ces putains de noms de variables. C'est bien de les initialiser mais c'est inutile dans les trois cas ici, même si ça peut rarement faire de mal on est d'accord.

• Code :

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

  1
  2
  3
  4
     f1=fopen("nombre.txt","r");
     if (f1==NULL)
     {
         printf("probleme d'ouverture");

  RAS, bien qu'il soit préférable d'envoyer les messages d'erreur dans le flux dédié : stderr.

• Code :

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

  1
  2
  3
  4
  5
  6
  7
     }
     else
     {
   
             r=x(f1,&a);
             printf("la moyenen est %f",(float)r/a);
     }

  RAS.
• fclose(f1); Il est inutile de fermer un flux qui n'as pas été ouvert : remonte cet appel d'un cran devant l'accolade.
• } La fonction main doit retourner une valeur de type int. Envoie 0 ou EXIT_SUCCESS.

Voici comment je transformerais ton programme :

Code avg.c :

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
#include <stdio.h>
 
 
size_t accumulate(FILE *input, int *sum) {
    size_t count = 0u;
    *sum = 0;
 
    int value, ret;
    while ((ret = fscanf(input, "%d", &value)) != EOF) {
        if (ret > 0) {
            *sum += value;
            ++count;
        }
    }
 
    return count;
}
 
int main(int argc, char *argv[]) {
    int ret = 1;
 
    FILE *input = stdin;
    if (argc > 1) {
        if (argc > 2) {
            fprintf(stderr, "fatal: too many arguments\n");
            printf("usage: avg [filename]\n");
            return 2;
        }
 
        input = fopen(argv[1], "rb");
        if (!input) {
            fprintf(stderr, "fatal: could not open %s\n", argv[1]);
            goto end_close;
        }
    }
 
    double average = 0.;
 
    int sum;
    size_t count;
    if ((count = accumulate(input, &sum)) > 0u)
        average = sum / (double)count;
    else if (ferror(input)) {
        fprintf(stderr, "fatal: I/O error occurred\n");
        goto end_close;
    }
 
    printf("%lf\n", average);
 
    ret = 0;
end_close:
    if (input != stdin)
        fclose(input);
 
    return ret;
}

Note qu'il accepte désormais un paramètre optionnel depuis la ligne de commande, qui correspond au chemin du fichier à ouvrir. Si ce paramètre n'est pas fourni alors le programme tentera de récupérer les données depuis l'entrée standard, stdin. On pourra donc choisir de l'exécuter comme ceci : $ ./avg values.txt ou bien comme cela : $ ./avg < values.txt / $ cat values.txt | ./avg.

[Sve@r]

Note qu'il accepte désormais un paramètre optionnel depuis la ligne de commande, qui correspond au chemin du fichier à ouvrir. Si ce paramètre n'est pas fourni alors le programme tentera de récupérer les données depuis l'entrée standard, stdin. On pourra donc choisir de l'exécuter comme ceci : $ ./avg values.txt ou bien comme cela : $ ./avg < values.txt / $ cat values.txt | ./avg.

C'est bien vu

J'ai toutefois un petit doute sur une partie du code (voir ci-dessous)...

Code c :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
        input = fopen(argv[1], "rb");
        if (!input /* donc ici input est NULL... */) {
            fprintf(stderr, "fatal: could not open %s\n", argv[1]);
            goto end_close;
        }
    }

end_close:
    if (input != stdin)
        fclose(input);  // fclose(NULL) ???

    return ret;
}

J'ai un trou sur le comportement de fclose(NULL). Autre chose: ouverture d'un fichier texte en mode binaire ? Sur Unix ça le fera mais sous zintruc...

PS: as-tu remarqué ma tournure de phrase ? "sur" Unix (sous-entendu "Unix est en dessous, au service des utilisateurs") et "sous zintruc" (sous-entendu "ce terminator se veut au dessus de tout pour contrôler tout ce qu'on fait")...

[Matt_Houston]

Non, je ne me suis pas relu et tu as parfaitement raison : fclose(NULL) est totalement UB, il s'agit d'une erreur. En tout cas avec la glibc je pense que ça fait boum. À la place il faudrait donc faire goto end; et modifier les dernières lignes comme suit :

Code :

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

1
2
3
4
5
6
end_close:
    if (input != stdin)
        fclose(input);
end:
    return ret;
}

Autre chose: ouverture d'un fichier texte en mode binaire ? Sur Unix ça le fera mais sous zintruc...

Un retour à la ligne, a priori c'est du whitespace quelque soit la manière dont il est encodé. Je pars du principe que fscanf le considèrera comme tel. Maintenant j'avoue ne pas faire beaucoup d'efforts pour gérer autre chose que '\n', ce qui est trop éloigné de POSIX m'intéresse peu.

PS: as-tu remarqué ma tournure de phrase ? "sur" Unix (sous-entendu "Unix est en dessous, au service des utilisateurs") et "sous zintruc" (sous-entendu "ce terminator se veut au dessus de tout pour contrôler tout ce qu'on fait")...

Argumentaire intéressant, j'avoue toujours hésiter entre les deux prépositions dans ce contexte.

[Sve@r]

À la place il faudrait donc faire goto end; et modifier les dernières lignes comme suit :

Code :

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

1
2
3
4
5
6
end_close:
    if (input != stdin)
        fclose(input);
end:
    return ret;
}

Ouais bien sûr. En effet, pourquoi faire simple...

Code c :

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

1
2
3
4
5
end_close:
    if (input != stdin && input != NULL)
        fclose(input);
    return ret;
}

[Matt_Houston]

Parce que les labels correspondent à des chemins de traitement bien précis : « termine », « flush, puis termine », etc.. Et sont potentiellement partagés par plusieurs goto. On devrait d'ailleurs probablement sauter à end dans le premier cas d'erreur testé (trop grand nombre de paramètres).

[kerrons]

...

Bonsoir ,Vous avez raison j'ai des instructions qui ne servent à rien (enfaîte ce sont des instruction restantes de l'ancien algorithme que j'ai modifié ) par contre en ce qui concerne votre alternative il y a plusieurs termes que je connais pas dans c comme argc ,stdin,stderr,goto end_close etc..
ps: je débute en c .

[Matt_Houston]

J'ai seulement adapté ton programme afin d'illustrer mes remarques précédentes, c'est ce que j'aurais pu écrire pour répondre au problème posé. Il ne s'agit nullement d'un parangon à atteindre.

Pour le moment tu n'as pas besoin de comprendre en détail ce que fait chaque ligne, le cœur du traitement est accumulate. Tu es en revanche libre de nous demander des précisions ou de te renseigner seul sur des points qui t'échappent.

[Sve@r]

par contre en ce qui concerne votre alternative il y a plusieurs termes que je connais pas dans c comme argc ,stdin,stderr,goto end_close etc..

• argc: il s'agit d'une variable placée comme paramètre de main() (qui est une fonction donc qui peut recevoir des paramètres). Son nom n'a donc que peut d'importance (argc, toto, truc) toutefois correspond à un consensus universel des dev C. il signifie "arg count" et contient le nombre d'arguments passés au programme lors de son appel (nombre de mots situés entre le nom du programme et l'appui sur <return> quand tu l'appelles). Matt_Houston s'en sert pour détecter si ton programme est appelé avec un nom derrière (nom qui sera alors vu comme celui du fichier à lire) ou bien sans rien (et dans ce cas il ira lire ton clavier à la place)
• stdin: flux entrand (standard input). Ca correspond généralement au clavier (clavier pouvant être remplacé par un autre flux lors de commandes pipées). L'avantage de cet élément est qu'il se comporte comme un FILE *. Donc tu peux y demander du fgetc() et autres fonctions de lecture. Evite juste d'y faire des trucs à priori pas prévus pour un clavier (fseek(), fflush(), fclose()) car ça peut te le cramer.
• stderr: flux dédié aux messages d'erreur (standard error). Un message passant par ce flux arrivera lui aussi à l'écran (comme un message standard donc) mais on peut lui aussi le détourner vers autre chose (pour celui qui veut lancer un programme en mode "silence" et ne pas avoir son écran pollué par des messages qu'il sait mais qu'il peut gérer à sa façon)
• goto: instruction de déplacement à un certain point du code (assez décriée car elle romp le modèle élégant et structuré du C donc c'est comme pour tout => on peut en user mais pas en abuser)
• end_close: étiquette de branchement du goto. Pour aller quelque part, il faut savoir où c'est donc il faut un nom à ce "quelque part". Ce nom est libre et (comme dans le second exemple de Matt_Houston) il peut en y avoir plusieurs. Tu noteras les "deux-points" placés à la fin de l'étiquette car t'as le même modèle dans le switch... case. C'est normal car un switch...case est en fait un goto déguisé.

ps: je débute en c .

C'est pas grave. L'ignorance est de courte durée et la connaissance reste à vie.