[Powered by Google Translate] [Fichier E / S]
[Jason Hirschhorn, l'Université de Harvard]
[C'est CS50, CS50.TV]
Quand nous pensons à un fichier, ce qui vient à l'esprit est un document Microsoft Word,
une image JPEG, ou une chanson MP3,
et nous interagissons avec chacun de ces types de fichiers de différentes manières.
Par exemple, dans un document Word on ajouter du texte
alors avec une image JPEG nous pourrions rogner les bords ou retoucher les couleurs.
Pourtant, sous le capot tous les fichiers de notre ordinateur ne sont rien de plus
d'une longue séquence de zéros et de uns.
C'est à la demande spécifique qui interagit avec le fichier
à décider de la manière de traiter cette séquence longue et la présenter à l'utilisateur.
D'une part, un document peut ressembler à un seul octet,
ou 8 zéros et des uns, et afficher un caractère ASCII sur l'écran.
D'autre part, une image bitmap peut sembler moins 3 octets,
ou 24 zéros et de uns,
et les interpréter comme 3 nombres hexadécimaux
qui représentent les valeurs de rouge, vert et bleu
dans un pixel d'une image.
Peu importe ce qu'ils peuvent ressembler à l'écran, à leur base,
fichiers sont rien de plus qu'une suite de zéros et de uns.
, Donc nous plonger et voir comment on fait manipuler ces zéros et de uns
quand il s'agit de l'écriture et la lecture d'un fichier.
>> Je vais commencer par le décomposant en un simple processus en 3 parties.
Ensuite, je vais plonger dans deux exemples de code qui illustrent ces trois parties.
Enfin, je vais examiner le processus et certains de ses détails les plus importants.
Comme avec n'importe quel fichier qui se trouve sur votre bureau,
la première chose à faire est de l'ouvrir.
En C nous faisons cela en déclarant un pointeur vers une structure prédéfinie
qui représente un fichier sur le disque.
Dans cet appel de fonction, nous avons aussi décider si nous voulons écrire et à lire à partir du fichier.
Ensuite, nous faisons la lecture et de l'écriture réelle.
Il ya un certain nombre de fonctions spécialisées, nous pouvons utiliser dans cette partie,
et la quasi-totalité d'entre eux commencent par la lettre F, qui représente le fichier.
Enfin, apparenté aux petit X rouge dans le coin supérieur des fichiers ouverts sur votre ordinateur,
nous fermons le dossier avec un appel de fonction finale.
Maintenant que nous avons une idée générale de ce que nous allons faire,
nous allons plonger dans le code.
>> Dans ce répertoire, nous avons deux fichiers C et les fichiers exécutables correspondant.
Le programme machine prend un argument en ligne de commande,
le nom du document que nous voulons créer.
Dans ce cas, nous allons l'appeler doc.txt.
Lançons le programme et entrez quelques lignes.
Salut. Mon nom est Jason.
Enfin, nous allons taper "quit".
Si nous avons maintenant la liste de tous les fichiers dans ce répertoire,
nous voyons qu'un nouveau document appelé doc.txt existe.
C'est le fichier de ce programme vient d'être créé.
Et bien sûr, il est trop rien de plus qu'une longue suite de zéros et de uns.
Si nous ouvrons ce nouveau fichier,
nous voyons les 3 lignes de code, nous entrés dans notre programme -
Salut. Nom est Jason mai.
Mais qu'est-ce qui se passe réellement lorsque typewriter.c fonctionne?
La première ligne de l'intérêt pour nous, c'est la ligne 24.
Dans cette ligne, nous déclarons notre pointeur de fichier.
La fonction qui retourne ce pointeur, fopen, prend deux arguments.
Le premier est le nom du fichier, y compris l'extension de fichier le cas échéant.
Rappelons qu'une extension de fichier n'influence pas le fichier à son niveau le plus bas.
Nous sommes toujours face à une longue séquence de zéros et de uns.
Mais cela influence la façon dont les fichiers sont interprétés et quelles applications sont utilisées pour les ouvrir.
Le second argument de fopen est une seule lettre
qui est synonyme de ce que nous comptons faire après avoir ouvert le fichier.
Il existe trois options pour cet argument - W, R et A.
Nous avons choisi de w dans ce cas parce que nous voulons écrire dans le fichier.
R, comme vous pouvez probablement le deviner, est de lire le fichier.
Et un est pour l'ajout au fichier.
Bien que les deux poids et une peut être utilisé pour écrire dans des fichiers,
w allons commencer à écrire dès le début du fichier
et susceptible d'écraser toutes les données qui ont déjà été enregistrées.
Par défaut, le fichier que nous ouvrons, si elle n'existe pas déjà,
est créé dans notre répertoire de travail actuel.
Cependant, si l'on veut accéder ou créer un fichier dans un emplacement différent,
dans le premier argument de fopen,
nous pouvons spécifier un chemin de fichier en plus du nom du fichier.
Alors que la première partie de ce processus est une seule ligne de code long,
il est toujours bon d'inclure une autre série de lignes
que vérifier que le fichier a été ouvert ou créé.
Si la fonction fopen retourne null, nous ne voulons pas aller de l'avant avec notre programme,
et cela peut se produire si le système d'exploitation est hors de la mémoire
ou si on essaie d'ouvrir un fichier dans un répertoire pour lequel nous n'avions pas les autorisations appropriées.
>> La deuxième partie du processus se déroule en boucle tant que machine à écrire.
Nous utilisons une fonction CS50 bibliothèque pour obtenir l'entrée de l'utilisateur,
et en supposant qu'ils ne veulent pas quitter le programme,
on utilise les fonctions fputs à prendre la chaîne et l'écrire dans le fichier.
fputs n'est qu'une des nombreuses fonctions que nous pourrions utiliser pour écrire dans le fichier.
D'autres incluent fwrite, fputc, et même fprintf.
Quelle que soit la fonction particulière que nous finissez par utiliser, cependant,
tous ont besoin de savoir, par l'intermédiaire de leurs arguments,
au moins deux choses -
ce qui doit être écrit et où il doit être écrit.
Dans notre cas, l'entrée est la chaîne qui doit être écrite
et fp est le pointeur qui nous dirige à l'endroit où nous écrivons.
Dans ce programme, la deuxième partie du processus est assez simple.
Nous sommes tout simplement en prenant une chaîne de l'utilisateur
et de l'ajouter directement à notre fichier avec peu ou pas de validation d'entrée ou de contrôles de sécurité.
Souvent, cependant, la deuxième partie prendra la majeure partie de votre code.
Enfin, la troisième partie est sur la ligne 58, où nous fermons le dossier.
Ici, nous appelons fclose et de le transmettre notre pointeur de fichier d'origine.
Dans la ligne suivante, on revient à zéro, signalant la fin de notre programme.
Et, oui, la troisième partie est aussi simple que cela.
>> Passons à la lecture de fichiers.
Retour dans notre annuaire, nous avons un fichier appelé printer.c.
Nous allons le faire fonctionner avec le fichier que nous venons de créer -
doc.txt.
Ce programme, comme son nom l'indique, va simplement afficher le contenu du fichier qui lui est passé.
Et là, nous l'avons.
Les lignes de code que nous avions tapé plus tôt et enregistré dans doc.txt.
Salut. Mon nom est Jason.
Si nous plongeons dans printer.c,
nous constatons qu'une grande partie du code ressemble à ce que nous y sommes allés par le biais de typewriter.c.
En effet la ligne 22, où nous avons ouvert le fichier,
et la ligne 39, où l'on a fermé le dossier,
sont à la fois presque identique à typewriter.c, à l'exception de l'argument de fopen seconde.
Cette fois nous allons lire un fichier,
C'est pourquoi nous avons choisi r au lieu de w.
Ainsi, concentrons-nous sur la deuxième partie de ce processus.
Dans la ligne 35, la seconde condition dans notre 4 boucles,
nous lançons un appel à fgets,
la fonction d'accompagnement fputs d'avant.
Cette fois-ci, nous avons trois arguments.
Le premier est le pointeur vers le tableau de caractères, où la chaîne sera stockée.
La seconde est le nombre maximal de caractères à lire.
Et le troisième est le pointeur vers le fichier avec lequel nous travaillons.
Vous remarquerez que la boucle for se termine lorsque fgets renvoie null.
Il ya deux raisons que ce qui a pu arriver.
Tout d'abord, une erreur a pu se produire.
Deuxièmement, et c'est plus probable, à la fin du fichier a été atteinte et pas plus de caractères ont été lus.
Dans le cas où vous vous poseriez la question, deux fonctions existent qui nous permettent de dire
que la raison est la cause de ce pointeur NULL particulier.
Et, sans surprise, car ils ont à voir avec l'utilisation des fichiers,
à la fois la fonction et le début ferror fonction feof par la lettre f.
>> Enfin, avant de conclure, un petit mot sur la fin de la fonction de fichier,
qui, comme nous venons, est écrit comme feof.
Souvent, vous vous retrouverez avec boucles while et for progressivement lire votre chemin à travers les fichiers.
Ainsi, vous aurez besoin d'un moyen de mettre fin à ces boucles lorsque vous avez atteint la fin de ces fichiers.
Appel feof sur votre pointeur de fichier et vérifier pour voir si c'est vrai
serait faire exactement cela.
Ainsi, une boucle while avec la condition (! Feof (fp)) peut sembler être une solution parfaitement appropriée.
Cependant, dire que nous avons une ligne à gauche dans notre fichier texte.
Nous allons entrer dans notre boucle while et tout fonctionnera comme prévu.
Au tour suivant grâce, notre programme va vérifier pour voir si feof de fp est vrai,
mais - et c'est là le point crucial de comprendre ici -
il ne sera pas vrai pour l'instant.
C'est parce que le but de feof n'est pas de vérifier
si le prochain appel à une fonction de lecture va frapper la fin du fichier,
mais plutôt de vérifier si oui ou non la fin du fichier a déjà été atteint.
Dans le cas de cet exemple,
lire la dernière ligne de notre dossier va parfaitement bien,
mais le programme ne sait pas encore que nous avons atteint la fin de notre dossier.
Il n'est pas jusqu'à ce qu'elle lit-on plus qu'elle s'oppose à la fin du fichier.
Ainsi, une condition correcte serait la suivante:
fgets et ses trois arguments - de sortie, la taille de la production, et fp -
et tout cela n'est pas égale à null.
C'est l'approche que nous a pris en printer.c,
et dans ce cas, après la sortie de la boucle,
l'on pourrait appeler feof ou ferror pour informer l'utilisateur que pour le raisonnement spécifique pour sortir de cette boucle.
>> L'écriture et la lecture d'un fichier est, à la base,
un simple processus en 3 parties.
Tout d'abord, nous ouvrons le fichier.
Deuxièmement, nous avons certaines choses dans notre fichier ou d'entreprendre certaines choses hors de lui.
Troisièmement, nous fermons le dossier.
La première et la dernière sont faciles.
La partie centrale est l'endroit où se trouve l'étoffe délicate.
Et bien que sous le capot, nous sommes toujours face à une longue séquence de zéros et de uns,
elle aide lors du codage d'ajouter une couche d'abstraction
qui transforme la séquence en quelque chose qui ressemble plus à ce que nous sommes habitués à voir.
Par exemple, si nous travaillons avec un fichier bitmap 24 bits,
nous allons probablement en train de lire ou d'écrire trois octets à la fois.
Dans ce cas, il serait judicieux de définir et de nommer de manière appropriée
une structure qui est de 3 octets grand.
>> Bien travailler avec des fichiers peut sembler compliqué,
les utiliser nous permet de faire quelque chose de vraiment remarquable.
Nous pouvons changer l'état du monde en dehors de notre programme,
nous pouvons créer quelque chose qui vit au-delà de la vie de notre programme,
ou nous pouvons même changer quelque chose qui a été créé avant notre programme a commencé à courir.
Interagir avec les fichiers est une partie vraiment puissant de la programmation en C.
et je suis impatient de voir ce que vous allez créer avec elle dans le code à venir.
Mon nom est Jason Hirschhorn. C'est CS50.
[CS50.TV]
>> [Rires]
D'accord. Une seule prise. Nous y voilà.
Quand nous pensons à un fichier - >> Oh, attendez. Désolé.
[Rires] D'accord.
Hey there.
Quand nous pensons à un fichier -
Quand vous pensez d'un fichier - D'accord. Dites-moi quand vous êtes prêt.
Oh, génial.
Bien que la lecture d'un prompteur peut sembler - no. My bad.