Bonjour et bienvenue.
Nous sommes dans une nouvelle section.
Cette section traite de l'écriture et de la lecture de fichiers en entrée et en sortie.
Nous allons nous concentrer sur les fichiers texte, mais nous parlerons aussi un peu des fichiers binaires.
Dans cette conférence, je veux juste fournir une vue d'ensemble, vous dire ce qu'est un fichier, et vous dire comment il est
bien utilisé pour stocker des données persistantes.
Donc jusqu'à ce point, toutes les données auxquelles notre programme accède sont en mémoire.
Nous sommes familiers avec ce concept de variables, de structures, peu importe ce que c'est.
Effacer toutes les données que votre programme utilise est en mémoire.
Et la raison pour laquelle il est stocké en mémoire est que les mémoires sont très rapides et que vous pouvez y accéder
rapidement pour effectuer des calculs.
Tu fais le cycle recherche, exécution, tout ça.
Le champ d'application est donc limité, mais il l'est aussi parce que l'étendue et la variété de nos applications,
si elles n'utilisent que la mémoire, seront quelque peu limitées.
Nous savons que la mémoire disparaît lorsque le programme disparaît, et cela peut donc être très limitatif.
Toutes les applications professionnelles sérieuses nécessitent plus de données que ce qui pourrait tenir dans la mémoire principale.
La mémoire principale est également très petite, juste en haut.
Et de nos jours, vous pouvez obtenir beaucoup de mémoire, de 1630 à 32 gigaoctets.
Mais par le passé, et notamment sur les appareils embarqués, vous ne disposez pas d'autant de RAM et, par conséquent, vos applications sont
très limitées en raison de l'espace et de la taille.
Vous ne voulez vraiment stocker les variables et les choses de ce genre que dans la mémoire principale.
C'est aussi parce que la mémoire principale disparaît lorsque le programme disparaît.
Les données stockées ne peuvent pas être persistantes à travers les redémarrages.
Tout dépend donc de la capacité à traiter des données qui sont persistantes et stockées sur un dispositif externe
tel qu'un disque dur ces gros programmes.
Vous voulez donc avoir cette possibilité de stocker sur le disque dur.
C'est un peu plus lent, mais vous pouvez y stocker beaucoup de données et les gros programmes ont besoin de stocker beaucoup
de données.
C fournit de nombreuses fonctions dans le fichier d'en-tête standard pour l'écriture et la lecture de périphériques externes.
Vous n'avez pas besoin d'écrire votre propre code pour lire et écrire les fichiers, mais vous pouvez voir l'avantage
qu'offrent les applications qui ont la capacité de stocker des données pendant une plus longue période.
Beaucoup d'avantages.
Le périphérique externe que vous utilisez pour stocker et récupérer des données est généralement le disque dur ou le lecteur
de disque.
Cependant, les fonctions du fichier d'en-tête dont nous allons parler peuvent être utilisées sur n'importe quel périphérique de stockage externe.
Vous pouvez donc l'utiliser sur une clé USB, sur n'importe quel périphérique externe qui stocke des données et sur n'importe quel lecteur
SSD avec tous les exemples.
Jusqu'à présent, toutes les données que l'utilisateur saisit sont perdues.
Une fois la fin du programme terminée, on parle de mémoire volatile.
Chaque fois que vous entendez ce terme de mémoire de temps de vol, cela signifie que la mémoire n'est pas persistante ou que les données ne sont
pas persistantes.
Il disparaît lorsque le programme se termine ou si la machine redémarre.
Ainsi, si l'utilisateur veut exécuter le programme avec les mêmes données, il doit les saisir à nouveau à chaque fois pour qu'elles
soient restaurées.
C'est très gênant.
Cela limite la programmation.
Et encore une fois, c'est une mémoire volatile.
Lorsque vous stockez des données dans des fichiers et que vous les conservez sur le disque dur, il s'agit d'un stockage permanent.
C'est toujours là.
Même lorsque vous avez redémarré la machine ou lorsque votre programme n'est pas en cours d'exécution.
On parle de mémoire non volatile parce qu'elle reste autour d'un fichier, qu'elle peut stocker des données non volatiles et qu'elle est généralement
stockée sur le disque ou, de nos jours, sur un lecteur à état solide ou SSD.
Il s'agit d'une section nommée du stockage et le goujon standard IO est un fichier contenant l'utilisation d'informations
afin de pouvoir lire et écrire dans ces fichiers.
Mais nous allons utiliser ce concept d'écriture et de lecture de données à partir d'un fichier pour un stockage
permanent, et vous allez remarquer que vos applications deviennent beaucoup plus utiles, beaucoup plus robustes, beaucoup plus évolutives,
parce que nous avons maintenant la possibilité de stocker de grandes quantités de données et que nous n'avons pas à nous soucier de la disparition
de ces données lorsque le programme se termine ou que l'ordinateur redémarre.
Il sera donc très, très avantageux d'utiliser des fichiers.
Un fichier à l'intérieur du système d'exploitation Linux ou du système d'exploitation Windows est stocké d'une certaine manière.
Mais en ce qui concerne le C, le langage de programmation, il s'agit juste d'une séquence d'octets, chaque octet pouvant être
lu individuellement.
Cela correspond à la structure des fichiers dans Unix, mais ce n'est pas nécessairement le cas.
Cela ne fait une différence que lorsque vous lisez des fichiers texte et des fenêtres, parce que vous pouvez avoir des
caractères supplémentaires dont vous devez vous soucier concernant la taille, mais il s'agit juste d'une séquence d'octets.
Ainsi, si vous avez un fichier texte et qu'il contient plus d'octets, vous pouvez toujours lire ces octets.
Vous devez juste comprendre ce que ces octets représentent.
Voici donc à quoi ressemble un fichier et comment nous allons le lire et y écrire en utilisant le langage de programmation
C.
C'est juste une série d'octets avec différents décalages.
Le début du fichier serait par zéro, et ensuite vous pouvez toujours trouver différentes positions
dans le fichier.
Ça pourrait être quatre, ça pourrait être quatre par dix deux, ça pourrait être 100 octets dedans.
Et puis vous avez la fin du fichier et la fin du fichier généralement marquée avec un marqueur spécial appelé EOF
et un fichier.
Un fichier a donc un début et une fin et une position actuelle.
La position actuelle est définie par tant d'octets au début.
La position actuelle est l'endroit où toute action du fichier aura lieu.
Vous allez écrire ou vous allez lire à cette position.
Nous allons également parler de certaines fonctions qui permettent de déplacer la position actuelle où vous le souhaitez
dans un fichier.
Même à la fin, si vous voulez lire à la fin ou jusqu'à la fin.
Il existe deux types de fichiers.
Il existe des fichiers texte et des fichiers binaires.
Un fichier texte est une donnée écrite sous la forme d'une séquence de caractères organisée en lignes.
Chaque ligne se termine par une nouvelle ligne, et les données du texte peuvent varier d'un système à l'autre en fonction de la façon dont les caractères
sont interprétés.
Ainsi, par exemple, sur Windows sous DOS, chaque ligne comporte un retour chariot et un saut de ligne, donc une barre oblique inverse R et une barre
oblique inverse N.
Ainsi, lorsque vous lisez ou écrivez les données, vous devez comprendre que le format est un peu
différent.
Mais sous Linux, il n'y a pas de barre oblique inverse.
R Et donc vous devez comprendre comment les données textuelles sont écrites, même si elles sont organisées par lignes et qu'il s'agit d'une série
d'octets, les données binaires sont écrites comme une série d'octets exactement comme ils apparaissent en mémoire.
Ainsi, les exemples de fichiers qui ont des données binaires sont les données.
Nos fichiers comme les données d'image ou les fichiers binaires d'encodage de musique ne sont pas lisibles.
Nous allons nous concentrer sur les fichiers texte dans cette section, mais vous pouvez
écrire toutes les données que vous souhaitez dans un fichier.
Vous pouvez l'écrire sous la forme d'une série d'octets et de la façon dont ils apparaissent dans la mémoire, ou vous pouvez l'écrire sous forme de texte.
Mais une fois que le fichier a effectivement été écrit, il ne sera constitué que d'une série d'octets, même s'il
est représenté sous forme de texte.
Vous pouvez visualiser les fichiers texte dans un éditeur, ce qui les rend plus lisibles.
Vous devez comprendre le format du fichier afin de pouvoir le lire et c'est ce que j'ai mentionné
si vous travaillez sous DOS Windows ou Linux où Windows peut avoir des caractères supplémentaires lorsqu'il écrit des données.
Ainsi, une séquence de 12 octets dans un fichier binaire peut être 12 caractères, 12 entiers signés
de huit par huit bits ou 12 entiers non signés.
Les feux binaires sont particulièrement délicats car ils stockent simplement Watson comme mémoire apparente.
Ainsi, en mode binaire, chaque bit du fichier est accessible.
Mais pour pouvoir lire quelque chose à partir d'un fichier, vous devez comprendre ce qu'il contient en termes de données et comment il
est stocké.
Et cela peut dépendre du système sur lequel vous travaillez.
Et cela va également dépendre du fait qu'il s'agisse de texte ou de binaire.
Streams.
Les programmes C sont automatiquement ouverts sur trois fichiers en votre nom.
Un flux peut représenter un fichier, mais un flux est un terme plus générique qui peut représenter tout type d'entrée.
Il peut donc représenter le clavier, la console, un fichier ou
un socket.
Si vous êtes habitué à la mise en réseau, les flux sont un terme plus générique, et il existe trois flux qui sont ouverts automatiquement
pour vous dans le langage de programmation C.
L'un est l'entrée standard, et c'est le périphérique d'entrée normal de votre système.
En général, par défaut, c'est le clavier.
Nous avons utilisé l'entrée standard lorsque nous avons fait scan F, mais vous pouvez utiliser scan off pour lire des
fichiers.
Si vous modifiez le flux d'entrée, peut-être que vous modifiez le flux d'entrée vers un fichier de sortie standard, celui-ci
s'affiche généralement à l'écran, généralement via la console.
L'erreur standard est également affichée à l'écran, mais il faut généralement la rediriger pour la voir en utilisant
l'esperluette trois ou quelque chose comme ça.
Mais ce sont les trois sorties que j'ai mentionnées.
L'entrée standard est le fichier qui est lu par guitare et scan F La sortie standard est utilisée par sortie nous et print F
nous avons principalement utilisé printf.
Vous pouvez également rediriger des fichiers sur le système pour qu'ils soient reconnus comme l'entrée et la sortie standard.
C'est la redirection.
Il s'agit d'un concept du système d'exploitation qui permet de rediriger les données, d'envoyer la sortie vers un fichier par exemple, ou d'envoyer
l'entrée, d'obtenir l'entrée à partir d'un fichier par opposition à la norme.
C'est ici que vous pouvez utiliser les symboles "inférieur à" ou "supérieur à".
L'objectif de la sortie d'erreur standard est de fournir un endroit logiquement distinct pour envoyer des messages d'erreur.
C'est donc une sorte de séparation, même si elle est affichée à l'écran.
Pour y accéder, vous devez avoir une commande spéciale.
Le flux est une représentation abstraite de toute source ou destination externe de données.
C'est pourquoi il est plus générique que, par exemple, un fichier.
Le clavier.
La ligne de commande sur votre affichage des fichiers sur un disque.
Ce sont tous des exemples de la façon dont vous travaillez avec les flux.
Les flux seront beaucoup plus importants lorsque vous commencerez à étudier le C++.
La bibliothèque C fournit des fonctions de lecture et d'écriture de flux de données. Vous pouvez donc utiliser les mêmes fonctions
d'entrée-sortie pour lire et écrire sur n'importe quel périphérique externe mappé à un flux.
C'est pourquoi j'ai mentionné que vous pouviez utiliser le scan F pour lire sur le clavier.
Vous pouvez également utiliser le scan F pour lire des fichiers.
Tout dépend de l'entrée, où le flux pointe.
Et donc les fonctions sont très, très utiles et très, très flexibles pour faire cela.
Il s'agit donc d'une vue d'ensemble de haut niveau de ce qu'est un fichier et pourquoi nous l'utilisons, comment il s'agit de données
persistantes, d'une mémoire non volatile.
Il reste là, nous allons l'utiliser et nous allons utiliser le fichier d'en-tête standard IO pour lire et écrire
dessus lorsque nous avons besoin de stocker des données pour notre programme et nos programmes finissent par être beaucoup plus robustes,
beaucoup plus utilisables, beaucoup plus flexibles.
Dans notre prochain cours, nous parlerons de l'implémentation réelle de cette fonction en utilisant les fonctions de
l'en-tête IO standard.
Merci.