Skip to content
GitLab
Explore
Sign in
Primary navigation
Search or go to…
Project
C
cours_prog
Manage
Activity
Members
Labels
Plan
Issues
Issue boards
Milestones
Wiki
Code
Merge requests
Repository
Branches
Commits
Tags
Repository graph
Compare revisions
Snippets
Build
Pipelines
Jobs
Pipeline schedules
Artifacts
Deploy
Releases
Package Registry
Model registry
Operate
Environments
Terraform modules
Monitor
Incidents
Analyze
Value stream analytics
Contributor analytics
CI/CD analytics
Repository analytics
Model experiments
Help
Help
Support
GitLab documentation
Compare GitLab plans
Community forum
Contribute to GitLab
Provide feedback
Keyboard shortcuts
?
Snippets
Groups
Projects
Show more breadcrumbs
yassin.elhakoun
cours_prog
Commits
1e3e45a0
Verified
Commit
1e3e45a0
authored
1 year ago
by
orestis.malaspin
Browse files
Options
Downloads
Patches
Plain Diff
maj 2023
parent
443b5903
No related branches found
Branches containing commit
No related tags found
No related merge requests found
Changes
1
Hide whitespace changes
Inline
Side-by-side
Showing
1 changed file
slides/fichiers.md
+153
-0
153 additions, 0 deletions
slides/fichiers.md
with
153 additions
and
0 deletions
slides/fichiers.md
0 → 100644
+
153
−
0
View file @
1e3e45a0
---
title
:
"
Lecture/écriture
de
fichiers"
date
:
"
2023-12-14"
---
# Les fichier en C
*
Un fichier en C est représenté par un pointeur de fichier.
```C
#include <stdio.h>
FILE *fp;
```
*
`FILE *`
{.C} est une structure de donnée
*opaque*
contenant les informations sur l'état du fichier.
*
Il est manipulé à l'aide de fonctions dédiées.
*
Le pointeur de fichier est toujours passé
*par copie*
.
# Manipulations de fichier
*
Pour lire/écrire dans un fichier il faut toujours effectuer trois étapes:
1.
Ouvrir le fichier (
`fopen()`
{.C}).
2.
Écrire/lire dans le fichier (
`fgets()`
{.C},
`fputs()`
{.C},
`fread()`
{.C},
`fwrite()`
{.C}, ...).
3.
Fermer le fichier (
`fclose()`
{.C}).
*
Nous allons voir brièvement ces trois étapes.
# Ouverture d'un fichier
*
L'ouverture d'un fichier se fait avec la fonction
`fopen()`
{.C}
```C
FILE *fp = fopen(filename, mode);
```
*
`filename`
{.C} est une chaîne de caractères (incluant le chemin).
*
`mode`
{.C} est le mode d'ouverture (
`"r"`
{.C},
`"w"`
{.C}, ... voir
`man 3 fopen`
{.bash}) qui est une chaîne de caractères.
*
Si l'ouverture échoue (pas la bonne permission, ou n'existe pas)
`fopen()`
{.C} retourne
`0`
.
*
**Toujours**
tester le retour de
`fopen()`
{.C}
```C
if (NULL == fp) {
fprintf(stderr, "Can't open output file %s!\n",
filename); // affiche dans le canal d'erreur
exit(EXIT_FAILURE);
}
```
# Fermeture d'un fichier
*
Il faut
**toujours**
fermer un fichier à l'aide de
`fclose()`
{.C}
```C
FILE *fp = fopen("mon_fichier", "w");
// écritures diverses
fclose(fp);
```
*
Les données sont transférées dans une mémoire tampon, puis dans le disques.
*
Si la mémoire tampon est pleine, le fichier est fermé, ... les données sont écrites sur le disque.
*
Si la mémoire tampon contient encore des données à la fin du programme les données sont
**perdues**
.
# Lecture d'un fichier (1/2)
```
C
char *fgets(char *s, int size, FILE *stream)
```
*
Lit une ligne de taille d'au plus
`size-1`
et la stocke dans
`s`
, depuis
`stream`
.
*
Retourne
`s`
ou
`NULL`
si échoue.
```
C
FILE *fp = fopen("text.txt", "r");
char buffer[100];
fgets(buffer, 37, fp);
// lit 36 caractères au plus et les écrit dans buffer
// s'arrête si rencontre EOF, ou "\n".
// ajoute un "\0" terminal
fclose(fp);
```
# Lecture d'un fichier (2/2)
```
C
size_t fread(void *ptr, size_t size, size_t nmemb,
FILE *stream)
```
*
Lit
`nmemb`
éléments de taille
`size`
octets et les écrit à l'adresse
`ptr`
dans le fichier
`stream`
.
*
Retourne le nombre d'éléments lus.
```C
FILE *fp = fopen("doubles.bin", "rb");
double buffer[100];
size_t num = fread(buffer, sizeof(double), 4, fp);
// lit 4 double, se trouvant dans le fichier fp au
// format binaire et les écrit dans buffer, puis
// retourne 4
fclose(fp);
```
# Écriture dans un fichier (1/2)
```
C
int fprintf(FILE *stream, const char *format, ...)
```
*
Écrit la chaîne de caractères
`format`
dans le fichier stream.
*
`format`
a la même syntaxe que pour
`printf()`
.
*
Retourne le nombre de caractères écrit sans le
`\0`
terminal(si réussite).
```C
FILE *fp = fopen("text.txt", "w");
fprintf(fp, "Hello world! We are in %d\n", 2020);
// Écrit "Hello world! We are in 2020"
// dans le fichier fp
fclose(fp);
```
# Écriture dans un fichier (2/2)
```
C
size_t fwrite(const void *ptr, size_t size,
size_t nmemb, FILE *stream)
```
*
Écrit
`nmemb`
éléments de taille
`size`
octets se trouvant à l'adresse
`ptr`
dans le fichier
`stream`
.
*
Retourne le nombre d'éléments écrits.
```C
FILE *fp = fopen("doubles.bin", "wb");
double buffer[] = {1.0, 2.0, 3.0, 7.0};
size_t num = fwrite(buffer, sizeof(double), 4, fp);
// écrit 4 double, se trouvant à l'adresse
// buffer dans le fichier fp au format binaire
// retourne 4
fclose(fp);
```
# Les pointeurs de fichiers spéciaux
*
Il existe trois
`FILE *`
{.C} qui existent pour tout programme:
*
`stdin`
{.C}: l'entrée standard.
*
`stdout`
{.C}: la sortie standard.
*
`stderr`
{.C}: l'erreur standard.
*
Lors d'un fonctionnement dans le terminal:
*
l'entrée standard est le
*clavier*
*
la sortie et erreur standard sont affichés dans le
*terminal*
.
*
Ainsi on a
```
C
fprintf(stdout, "texte\n"); // == printf("texte\n");
int a;
fscanf(stdin, "%d", &a); // == scanf("%d", &a);
```
This diff is collapsed.
Click to expand it.
Preview
0%
Loading
Try again
or
attach a new file
.
Cancel
You are about to add
0
people
to the discussion. Proceed with caution.
Finish editing this message first!
Save comment
Cancel
Please
register
or
sign in
to comment