Bonjour à tous,

Si vous avez manqué les cours précédents, commencez par ceux-ci et revenez ici ensuite :

Cours 0 : Pré-requis et premier programmeConsulter
Cours 1 : DialogueConsulter
Cours 2 : Types de données et appels de fonctionsConsulter
Cours 3 : Opérateur ternaire et masquageConsulter
Cours 4 : Switch et premiers tableauxConsulter
Cours 5 : Incrémentation, boucles et tri de tableauConsulter
Cours 6 : Les fichiersEn cours
Cours 7 : Tableaux et matricesConsulter
Cours 8 : Chaînes de caractèresConsulter
Cours 9 : Introduction à la programmation objetConsulter




Attention : Du fait des limitations actuelles la communauté, il n'est pas possible d'afficher un code correct, c'est pourquoi je vous fournis ce fichier ZIP contenant l'ensemble des codes de ce cours. Décompressez le dans votre dossier MinGW/code/.

Cours6.zip (3.77 KB, Downloads: 1)

Rappel : Pour pouvoir compiler les fichiers, utilisez l'instruction suivante dans votre Invite de commandes où vous remplacerez bien sûr les 2 ''nom de fichier''.

  1. gcc -ansi -Wall -pedantic -o nomdefichier.exe nomdefichier.c
Copy the Code


Lecture et écriture caractère par caractère

On attaque ce nouveau cours avec l'introduction de deux nouvelles fonctions appartenant à la librairie stdio :
  • getchar : qui va permettre la lecture caractère par caractère ;
  • putchar : qui va écrire le dernier caractère enregistré.


Voyons tout de suite un exemple pour comprendre leur utilisation :

cpc.c
  1. #include ˂stdio.h˃

  2. int main(void)
  3. {
  4.    int c;
  5.    while((c=getchar()) != '/n')
  6.       putchar(c);

  7.    return 0;
  8. }
Copy the Code


Ce programme va tout simplement lire caractère par caractère le texte que nous allons lui fournir sur l'entrée standard tant qu'il ne rencontre pas le caractère '\n' (retour à la ligne). Ainsi la copie s'arrêtera dès qu'on appuiera sur la touche entrée, le même texte est alors copié, vous devez obtenir quelque chose du style :



Avec ce programme, nous introduisons également un nouvel opérateur de comparaison : ''!='' qui signifie ''est différent de''. Vous connaissiez déjà la comparaison ''=='', son contraire est ''!=''. A chaque tour de boucle while, nous affectons le caractère suivant dans la variable c et, tant que c est différent de '\n' alors on écrit le caractère.

Lecture d'informations d'un fichier

Prenons l'exemple d'un programme qui aurait besoin d'afficher ou d'utiliser des informations récurrentes, vous n'allez pas à chaque exécution recopier ces informations. Donc nous allons stocker ces informations pour pouvoir les utiliser dès que nécessaire. Cela aura aussi l'intérêt de laisser de la clarté dans notre code en séparant justement ce code de ces données qui pourraient prendre beaucoup de place.

Le code va rester sensiblement le même. Si on l'utilise dans l'état alors le fichier va être lu mais dès le premier retour à la ligne cela va s'arrêter. Si on veut aller jusqu'à la fin du fichier, on va donc faire notre lecture caractère par caractère jusqu'à arriver à ''EOF''. EOF est l'acronyme de End Of File, en français fin de fichier.

lecturefichier.c
  1. #include ˂stdio.h˃

  2. int main(void)
  3. {
  4.    int c;
  5.    while((c=getchar()) != EOF)
  6.       putchar(c);

  7.    return 0;
  8. }
Copy the Code


Mais alors comment indiquer à notre programme quel fichier il doit lire ? Eh bien on va tout simplement lui indiquer lors de l'exécution. Ici j'ai tout simplement inséré dans un fichier ''xiaomi.txt'' une partie de la description Wikipedia de Xiaomi. Voici donc comment faire :

  1. gcc -ansi -Wall -pedantic -o lecturefichier.exe lecturefichier.c
  2. lecturefichier.exe ˂ xiaomi.txt
Copy the Code


Avez-vous appris des choses sur Xiaomi ? ;)

Ecriture dans un fichier

Et si l'on souhaite stocker toutes les informations dans un fichier plutôt que de l'afficher à l'écran ? L'instruction inverse existe ... On va exécuter notre programme de la manière suivante !

  1. ecriturefichier.exe ˃ secret.txt
Copy the Code


Mais il faut peut être que l'on écrive notre programme ecriturefichier.c d'abord ...

ecriturefichier.c
  1. #include ˂stdio.h˃

  2. int main(void)
  3. {
  4.    char texte[] = {'M','f','!','N','j','!','N','J','Y','!','5','!','b','s','s','j','w','f','!','m','f','!','/','/','/'};
  5.    int i;
  6.         
  7.    for(i=0;i25;i++)
  8.       putchar(texte[i]-1);

  9.    return 0;
  10. }
Copy the Code


Alors que contient désormais votre fichier secret.txt ?

Exercice - Mais que fait ce programme ?

Aujourd'hui l'exercice sera très simple, je vais vous donner un programme et il faudra me dire que représentent les variables x, y et z.

exercice.c
  1. #include ˂stdio.h˃
  2. #include ˂ctype.h˃

  3. int main(void)
  4. {
  5.    char c;
  6.    int x=0,y=0,z=1,wasspace=1;
  7.         
  8.    while((c=getchar()) != EOF)
  9.    {
  10.       x++;
  11.                
  12.       if(isspace(c) && !wasspace)
  13.       {
  14.          y++;
  15.          wasspace = 1;
  16.       }

  17.       else if(c == '\n')
  18.          z++;

  19.       else
  20.          wasspace = 0;
  21.    }

  22.    printf(ʺA vous de compléter !ʺ);

  23.    return 0;
  24. }
Copy the Code


Petite explication supplémentaire : la fonction isspace() sert à savoir si le caractère transmis en paramètres est un espace. Elle retournera donc 0 si ce n'est pas un espace. Il se pourrait que ce programme contienne encore d'autres notions non connues avec nos cours donc faites des tests et/ou n'hésitez pas à poser des questions :)

Il faut bien sûr exécuter le programme en joignant un fichier texte :

  1. gcc -ansi -Wall -pedantic -o exercice.exe exercice.c
  2. exercice.exe ˂ xiaomi.txt
Copy the Code


Vous devez compléter le programme avec des lignes permettant d'afficher nos valeurs x, y et z avec leur explication. Envoyez alors vos captures d'écran pour obtenir votre médaille.

Plusieurs fichiers ?

Tout ce que nous avons vu est bien pratique mais qu'arrive-t-il si l'on doit manipuler plusieurs fichiers ? Eh bien on va devoir programmer pour pouvoir manipuler chaque fichier ... Les fonctions de manipulation se trouvent dans la librairie stdlib.h.

manipulationfichier.c
  1. #include ˂stdio.h˃
  2. #include ˂stdlib.h˃

  3. int main(void)
  4. {
  5.    FILE *fp = fopen(ʺlipsum.txtʺ,ʺrʺ);
  6.         
  7.    if(fp != NULL)
  8.    {
  9.       int i=0;
  10.       char ligne[256];
  11.       while(fgets(ligne,sizeof ligne,fp))
  12.          printf(ʺ%d : %sʺ,i++,ligne);

  13.       fclose(fp);
  14.    }
  15.    else
  16.       printf(ʺCe fichier n'existe pas.ʺ);

  17.    printf(ʺ\nʺ);
  18.    return 0;
  19. }
Copy the Code


Décomposons maintenant chacune de ces instructions pour comprendre le fonctionnement.

  1. FILE *fp = fopen(ʺlipsum.txtʺ,ʺrʺ);
Copy the Code


fopen() est la fonction qui va nous permettre d'ouvrir notre fichier, elle a deux paramètres : le nom du fichier et l'autorisation d'ouverture. Ici nous utilisons le paramètre ''r'' qui signifie ''read'' (lire), on se donne donc l'autorisation de manipuler le fichier en lecture. Si on avait voulu écrire dans notre fichier, on aurait utilisé le type ''w'' pour ''write'' (écrire).

Une fois ouvert, le fichier va se charger en mémoire et nous allons donc stocker dans la variable fp l'adresse mémoire du début de ce stockage c'est pourquoi il y a une petite étoile (*) avant le nom de la variable. Le type de notre variable sera FILE pour tout simplement ''fichier''.

  1. if(fp != NULL)
  2. {

  3. }
  4. else
  5.       printf(ʺCe fichier n'existe pas.ʺ);
Copy the Code


Lorsqu'une adresse mémoire n'est pas attribuée alors notre variable ne contiendra rien, en langage informatique ''NULL''. Donc on va commencer par tester si l'ouverture s'est correctement déroulée.

  1. int i=0;
  2. char ligne[256];
  3. while(fgets(ligne,sizeof ligne,fp))
  4.    printf(ʺ%d : %sʺ,i++,ligne);
Copy the Code


Notre fichier étant ouvert, nous pouvons maintenant le lire et la fonction fgets() va nous permettre de lire ligne par ligne par notre fichier. Celle-ci a 3 paramètres : un tableau de caractères, la longueur de notre tableau (sizeof va permettre de retourner la taille, ici 256) et l'adresse de notre fichier contenu dans fp.

On doit alors commencer par déclarer un tableau de caractère que j'appelle ligne qui va stocker la ligne de notre fichier. A noter que nous devons définir une taille maximale à ce tableau, j'ai donc défini une longueur maximale de 256 caractères, si la ligne dans mon fichier est plus longue alors l'information sera tronquée.

On utilise alors une boucle while qui va parcourir chaque ligne. Lorsque fgets() est arrivé au bout du fichier alors la boucle while s'arrête. On affiche alors chaque ligne avec au début, le numéro de ligne. La variable i sert à compter les lignes.

  1. fclose(fp);
Copy the Code


On n'oublie pas de fermer le fichier avec la fonction fclose pour correctement terminer notre lecture !

Et voilà vous savez tout !




Si vous n'avez pas compris quelque chose n'hésitez pas à poser vos questions en commentaires, entraidez-vous ... et toutes les réponses correctes et originales à l'exercice recevront une médaille !




Note : pour partager vos codes, utilisez des captures d'écran car malheureusement la communauté n'est pas encore totalement apte à partager facilement du code !