Utiliser un fichier grâce à une fonction

Version imprimable

Bonjour!

J'apprends le C et j'aimerais lire un fichier ligne par ligne... grâce à une fonction.

Mon bout de code marche très bien quand je le laisse dans le main et pas du tout quand je le met dans une fonction que j'appelle dans le main.

La première partie du code écrit dans un fichier 10 chiffres par lignes jusqu'à N et ferme le fichier.

La 2eme partie (ma fonction qui marche pas) est censé lire les lignes du fichiers une par une et les afficher en retournant le nombre de ligne lues.

Voici le code raté:

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
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
 
#include <stdio.h>
 
unsigned int N ()
{
  unsigned int n;
  printf ("Veuillez saisir le nombre de chiffre a afficher:\n");
  scanf ("%u",&n);
  printf("Vous avez saisi %u\n",n);
  return n;
}
 
void Aff( unsigned int nb, FILE * fichierTemp)
{
  unsigned int i;
  int dec;
 
  // gère la largeur du tableau en adaptant le nombre de caracteres affichés grâce a la variable dec
  if (nb>10000) dec=5;
  else if (nb>1000) dec=4;
  else if (nb>100) dec=3;
  else if (nb>10) dec=2;
  else if (nb>1) dec=1;
  else dec=0;
 
  // boucle d'affichage
  for (i=0; i<nb;i++)
  {
    fprintf (fichierTemp,"%*u",dec,i+1);
    if ((i+1)%10==0) fprintf (fichierTemp,"\n");
    else fprintf (fichierTemp,"; ");
  }
}
 
// fonction qui affiche les lignes du fichier une par une et retourne le nombre de lignes
int afficheLignesParLignes(char ligne [], int nbCaracteres,char nomFichier[])
{
 int nbLignes=0;
 
  /*Ouverture du nouveau fichier en lecture*/
  FILE * FICHIER;
  FICHIER = fopen(nomFichier, "w");
 
 while (fgets(ligne,nbCaracteres,FICHIER) !=  NULL)
  {
    printf("%s\n",ligne);
    nbLignes++;
  }
 return nbLignes;
}
 
main()
 
{
 
   // Declaration
  char NomFichier[]= "nombre.txt", mode = 'r';
  char test[10000];
  int nb;
 
  // Pointeur de réf
  FILE * FICHIER;
 
  /*Ouverture du nouveau fichier en ecriture*/
  FICHIER = fopen(NomFichier, "w");
 
  //Programme
  Aff(N(),FICHIER);
 
  fclose (FICHIER);
 
  nb=afficheLignesParLignes(afficheLignesParLignes,9999,NomFichier);
  printf ("%d\n",nb);
 
}

Je suis débutant, merci de détailler un peu vos réponses, et d'être indulgeant devant cette erreur basique...

Merci par avance!

26/12/2013, 10h58
supersnail

Bonjour,

Pourquoi tu ouvres ton fichier en mode écriture ("w") pour lire le fichier ? :koi:

Ça devrait mieux marcher avec le mode lecture ("r") à mon avis :aie:
26/12/2013, 11h19
B65AcR

Bien vu! Une erreur en faisant un copié coller pour trouver une solution.

Mettre r ou w change rien a mon probleme c'est un ennuie pour dire quel fichier lire. Une histoire de pointeur:

Ligne 71
passing argument 1 of 'afficherLignesParLignes' from incompatibles pointeurs types [enable by default]

Ligne 35
note: exepted 'char *' but argument is of type 'int (*) (char *, int, char *)'
26/12/2013, 11h26
supersnail

En fait (j'avais pas vu) tu mets le nom de la fonction (qu'il considère du coup comme un pointeur de fonction) à la place d'un tableau de lignes qui est demandé en paramètre.

D'ailleurs t'as pas besoin de ce paramètre-là, t'as juste à déclarer ton tableau à l'intérieur de ta fonction affichageLignesParLignes :zen:
26/12/2013, 11h32
B65AcR

Je comprends de travers... un tableau de lignes??? Ou? Je voulais un tableau de caracteres pour y mettre la chaine du nom du fichier.

Oulà! j'ai trouvé une erreur!

Code:

nb=afficheLignesParLignes(afficheLignesParLignes,9999,NomFichier);

a remplacer par

Code:

nb=afficheLignesParLignes(test,9999,NomFichier);

Une erreur de segmentation à trouver maintenant. (j'ai supprimer le dernier parametre, et declaré:

Code:

char nomFichier[100];

dans ma fonction
26/12/2013, 11h37
supersnail

Euh, oui tableau de caractères, désolé :aie:

Sinon t'as pas besoin de le demander en paramètre, tu peux le déclarer à l'intérieur de ta fonction (vu que tu t'en sers pas dans le main, pas besoin de passer un tableau depuis le main ;))
26/12/2013, 11h43
B65AcR

Je comprends pas. dans le main, je recupere le nom du fichier, en .txt dans une variable.

Comment lma fonction va trouver quel fichier ouvrir si je ne lui passe pas en parametre d'une manière ou d'une autre?
26/12/2013, 11h55
supersnail

Actuellement tu as 3 paramètres dans ta fonction:

Code:

int afficheLignesParLignes(char ligne [], int nbCaracteres,char nomFichier[])

Le tableau de char "ligne", celui que je te dis de virer parce que tu peux le déclarer dans ta fonction.

Le nbCaracteres de type "int" qui lui est à garder
Et nomFichier qui est aussi un tableau de char, qui contient le nom du fichier, qu'il vaut mieux garder aussi :aie:

ça y est! j'ai compris! Merci pour ton aide!

Voici la fonction pour ceux que ça interesse:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
 
// fonction qui affiche les lignes du fichier une par une et retourne le nombre de lignes
int afficheLignesParLignes(char ligne [], int nbCaracteres)
{
 int nbLignes=0;
 char nomFichier[]= "nombre.txt";
 
  /*Ouverture du nouveau fichier en lecture*/
  FILE * FICHIER;
  FICHIER = fopen(nomFichier, "r");
 
 while (fgets(ligne,nbCaracteres,FICHIER) !=  NULL)
  {
    printf("%s\n",ligne);
    nbLignes++;
  }
 return nbLignes;
}

J'aurais plûtot pensé à quelque chose du genre personnellement:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 // fonction qui affiche les lignes du fichier une par une et retourne le nombre de lignes int afficheLignesParLignes(int nbCaracteres, char[] nomFichier) { int nbLignes=0; char ligne[4096]; // on alloue un tableau de ligne de 4096 octets /*Ouverture du nouveau fichier en lecture*/ FILE * FICHIER; FICHIER = fopen(nomFichier, "r"); while (fgets(ligne,nbCaracteres,FICHIER) != NULL) { printf("%s\n",ligne); nbLignes++; } return nbLignes; }
Note: si tu as vu les fonctions malloc et free, tu peux t'en servir pour allouer un tableau de nbCaracteres, ce qui évitera de déborder du tampon (et de faire planter le programme)

Citation:

Envoyé par supersnail

J'aurais plûtot pensé à quelque chose du genre personnellement:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
// fonction qui affiche les lignes du fichier une par une et retourne le nombre de lignes
int afficheLignesParLignes(int nbCaracteres, char[] nomFichier)
{
 int nbLignes=0;
 char ligne[4096]; // on alloue un tableau de ligne de 4096 octets
 
  /*Ouverture du nouveau fichier en lecture*/
  FILE * FICHIER;
  FICHIER = fopen(nomFichier, "r");
 
 while (fgets(ligne,nbCaracteres,FICHIER) !=  NULL)
  {
    printf("%s\n",ligne);
    nbLignes++;
  }
 return nbLignes;
}

Bonjour

A quoi sert concrètement ce paramètre "nbCaracteres" ??? Et t'as oublié de fermer le fichier. Et éventuellement penser qu'un nb de lignes est rarement négatif...

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
// fonction qui affiche les lignes du fichier une par une et retourne le nombre de lignes
unsigned long afficheLignesParLignes(char[] nomFichier)
{
 unsigned long nbLignes=0;
 char ligne[4096]; // on considère qu'une ligne ne peut pas dépasser 4095 octets
 
  /*Ouverture du nouveau fichier en lecture*/
  FILE * fp;
  fp=fopen(nomFichier, "r");
 
 while (fgets(ligne,4096,fp) !=  NULL)
  {
    printf("%s\n",ligne);
    nbLignes++;
  }
  fclose(fp);
 return nbLignes;
}

29/12/2013, 14h56
B65AcR

Je viens de voir ta réponse.

Citation:

Envoyé par supersnail

char ligne[4096]; // on alloue un tableau de ligne de 4096 octets

Pourquoi 4096 octets? ça corresponds à quoi? Je me rends compte en m'y remettant, qu'il faut prendre garde au dimensionnement du tableau lors de l'appel. Au début, la ligne aura peu de daractère, mais ça peut vraiment augmenter beaucoup et depasser la capacité du tableau initialisé au début.

C'est beaucoup un tableau de ligne de 4096 octets?

Citation:

Envoyé par supersnail

Note: si tu as vu les fonctions malloc et free, tu peux t'en servir pour allouer un tableau de nbCaracteres, ce qui évitera de déborder du tampon (et de faire planter le programme)

Je vais apprendre à m'en servir dans les heures qui viennent. Tout exemple est bon a prendre, montre moi à quoi tu penses!

Citation:

Envoyé par supersnail

En relisant, et avant de voir ta réponse, j'ai déclaré mon tableau comme ça:

Code:

char nomFichier[]

Pourquoi tu le déclares comme ça?

Citation:

Envoyé par supersnail

Code:

char[] nomFichier

C'est mieux???
29/12/2013, 15h05
B65AcR

Citation:

Envoyé par Sve@r

A quoi sert concrètement ce paramètre "nbCaracteres" ???

Uniquement a alimenter les parametres de fgets(). Malvenu à cet endroit?

Citation:

Envoyé par Sve@r

Et t'as oublié de fermer le fichier.

Bien vu! Merci.

Citation:

Envoyé par Sve@r

Et éventuellement penser qu'un nb de lignes est rarement négatif...

Bien vu aussi. Mais un type long? c'est pas un peu brutal pour si peu?

En fait la taille que tu donnes à ton tableau est la quantité de mémoire qui va être réservée par ton programme pour contenir les données du tableau (et éviter d'aller écrire des données qui sont derrière).

Sinon la taille 4096 est arbitraire (et d'ailleurs j'aurais dû la mettre dans fgets), sachant que tu ne peux pas allouer un tableau d'une taille stockée dans une variable "directement" (il faut passer par malloc pour ça).

Pour "éviter" le problème de l'entier négatif, tu peux déclarer ta variable comme étant "unsigned int" (unsigned == non signé), même si un entier "signé" pour le compilateur peut aussi être vu comme un nombre non signé, qui sera juste très grand, étant donné la convention utilisée pour représenter un entier négatif en mémoire (le complément à deux).

Bref voici ce que donnerait un code avec les malloc (je te laisserai fermer le fichier ;)):
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 // fonction qui affiche les lignes du fichier une par une et retourne le nombre de lignes int afficheLignesParLignes(unsigned int nbCaracteres, char[] nomFichier) { int nbLignes=0; char* ligne = 0; // On déclare un pointeur vers notre tableau de caractères // On alloue un tableau suffisament grand pour contenir nbCaracteres chars if (!(ligne = malloc(nbCaracteres * sizeof(char))) { // Ici, malloc a renvoyé 0 (notre tableau n'a pas pu être créé), donc on arrête le programme pour éviter un plantage. printf ("Impossible d'allouer de la mémoire"); exit(1); } memset(ligne, 0, nbCaracteres * sizeof(char)); // on remplit de zéros notre tableau /*Ouverture du nouveau fichier en lecture*/ FILE * FICHIER; FICHIER = fopen(nomFichier, "r"); while (fgets(ligne,nbCaracteres,FICHIER) != NULL) { printf("%s\n",ligne); nbLignes++; } return nbLignes; }
Bref si tu as des questions, n'hésite pas à poser ;)

Citation:

Envoyé par B65AcR

Uniquement a alimenter les parametres de fgets(). Malvenu à cet endroit?

Ben étant donné que la ligne récupérée depuis le fichier sera stockée dans un tableau de 4096 octets, ce paramètre n'est pas "malvenu" mais plutôt inutile. Autant demander à fgets() de récupérer directement 4096 octets. De toute façon si la ligne en fait moins il s'arrête alors à la taille réelle...

Citation:

Envoyé par B65AcR

Bien vu aussi. Mais un type long? c'est pas un peu brutal pour si peu?

Je parlais surtout de l'unsigned qui supprime la plage des négatifs et qui reporte les valeurs récupérées dans la plage des positifs te faisant gagner immédiatement (sans modifier la grandeur de la variable) le double de possibilités dans la plage de positifs. Très pratique quand on n'a pas besoin d'utiliser les négatifs...
Mais sinon tu touches effectivement du doigt le problème de l'estimation qui se pose à tous un jour ou l'autre et là, tu es seul juge. Si tu es certain que ton fichier fait moins de 65535 lignes tu peux laisser "unsigned short" mais si tu as un doute ou si tu ne veux pas avoir à te poser de questions alors le "unsigned long" n'est pas pénalisant.
En fait, à ce niveau, le problème de la taille d'une simple variable est assez négligeable. Là où il faudra vraiment y réfléchir, c'est quand tu commenceras à utiliser des structures et à les mettre en tableaux
Code:

1 2 3 4 5 6 7 typedef struct { <entier> nb; ... ... } t_mytype t_mytype tab[1000];
Là, mettre un "short" ou un "long" pour "nb" aura un impact beaucoup plus important dans ton code...
Citation:
Envoyé par supersnail
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 // fonction qui affiche les lignes du fichier une par une et retourne le nombre de lignes int afficheLignesParLignes(unsigned int nbCaracteres, char[] nomFichier) { int nbLignes=0; char* ligne = 0; // On déclare un pointeur vers notre tableau de caractères // On alloue un tableau suffisament grand pour contenir nbCaracteres chars if (!(ligne = malloc(nbCaracteres * sizeof(char))) { // Ici, malloc a renvoyé 0 (notre tableau n'a pas pu être créé), donc on arrête le programme pour éviter un plantage. printf ("Impossible d'allouer de la mémoire"); exit(1); } ... return nbLignes; }
Non. On ne met jamais de exit() dans une fonction. Si une fonction ne peut pas réaliser son travail alors on l'arrête effectivement mais on renvoie le pb à l'appelant qui se chargera alors de prendre une décision (trouver une solution de contournement ou généralement qui renverra lui-même le problème à son appelant et ainsi etc etc etc jusqu'au main).
Tu imagines si malloc() ou fopen() faisaient un exit() quand elles n'arrivent pas à effectuer la tâche demandée ???

29/12/2013, 17h49
supersnail

Yep, c'est vrai qu'en situation réelle vaut mieux éviter, m'enfin là c'était juste pour "illustrer" malloc (même si c'est pas bien malin de ma part de montrer ce qu'il ne faut pas faire dans un code d'exemple :aie:).

Mea culpa :oops:
01/01/2014, 19h00
B65AcR

Merci pour vos réponses, j'ai appris pas mal de choses grâce à vous.