1
00:00:00,000 --> 00:00:02,000
[Powered by Google Translate] [Fichier E / S]

2
00:00:02,000 --> 00:00:04,000
[Jason Hirschhorn, l'Université de Harvard]

3
00:00:04,000 --> 00:00:07,000
[C'est CS50, CS50.TV]

4
00:00:07,000 --> 00:00:11,000
Quand nous pensons à un fichier, ce qui vient à l'esprit est un document Microsoft Word,

5
00:00:11,000 --> 00:00:14,000
une image JPEG, ou une chanson MP3,

6
00:00:14,000 --> 00:00:17,000
et nous interagissons avec chacun de ces types de fichiers de différentes manières.

7
00:00:17,000 --> 00:00:20,000
Par exemple, dans un document Word on ajouter du texte

8
00:00:20,000 --> 00:00:24,000
alors avec une image JPEG nous pourrions rogner les bords ou retoucher les couleurs.

9
00:00:24,000 --> 00:00:28,000
Pourtant, sous le capot tous les fichiers de notre ordinateur ne sont rien de plus

10
00:00:28,000 --> 00:00:31,000
d'une longue séquence de zéros et de uns.

11
00:00:31,000 --> 00:00:33,000
C'est à la demande spécifique qui interagit avec le fichier

12
00:00:33,000 --> 00:00:38,000
à décider de la manière de traiter cette séquence longue et la présenter à l'utilisateur.

13
00:00:38,000 --> 00:00:41,000
D'une part, un document peut ressembler à un seul octet,

14
00:00:41,000 --> 00:00:45,000
ou 8 zéros et des uns, et afficher un caractère ASCII sur l'écran.

15
00:00:45,000 --> 00:00:48,000
D'autre part, une image bitmap peut sembler moins 3 octets,

16
00:00:48,000 --> 00:00:50,000
ou 24 zéros et de uns,

17
00:00:50,000 --> 00:00:53,000
et les interpréter comme 3 nombres hexadécimaux

18
00:00:53,000 --> 00:00:56,000
qui représentent les valeurs de rouge, vert et bleu

19
00:00:56,000 --> 00:00:58,000
dans un pixel d'une image.

20
00:00:58,000 --> 00:01:01,000
Peu importe ce qu'ils peuvent ressembler à l'écran, à leur base,

21
00:01:01,000 --> 00:01:05,000
fichiers sont rien de plus qu'une suite de zéros et de uns.

22
00:01:05,000 --> 00:01:08,000
, Donc nous plonger et voir comment on fait manipuler ces zéros et de uns

23
00:01:08,000 --> 00:01:12,000
quand il s'agit de l'écriture et la lecture d'un fichier.

24
00:01:12,000 --> 00:01:15,000
>> Je vais commencer par le décomposant en un simple processus en 3 parties.

25
00:01:15,000 --> 00:01:19,000
Ensuite, je vais plonger dans deux exemples de code qui illustrent ces trois parties.

26
00:01:19,000 --> 00:01:23,000
Enfin, je vais examiner le processus et certains de ses détails les plus importants.

27
00:01:23,000 --> 00:01:25,000
Comme avec n'importe quel fichier qui se trouve sur votre bureau,

28
00:01:25,000 --> 00:01:28,000
la première chose à faire est de l'ouvrir.

29
00:01:28,000 --> 00:01:31,000
En C nous faisons cela en déclarant un pointeur vers une structure prédéfinie

30
00:01:31,000 --> 00:01:33,000
qui représente un fichier sur le disque.

31
00:01:33,000 --> 00:01:38,460
Dans cet appel de fonction, nous avons aussi décider si nous voulons écrire et à lire à partir du fichier.

32
00:01:38,460 --> 00:01:41,660
Ensuite, nous faisons la lecture et de l'écriture réelle.

33
00:01:41,660 --> 00:01:44,800
Il ya un certain nombre de fonctions spécialisées, nous pouvons utiliser dans cette partie,

34
00:01:44,800 --> 00:01:48,790
et la quasi-totalité d'entre eux commencent par la lettre F, qui représente le fichier.

35
00:01:48,790 --> 00:01:53,560
Enfin, apparenté aux petit X rouge dans le coin supérieur des fichiers ouverts sur votre ordinateur,

36
00:01:53,560 --> 00:01:56,680
nous fermons le dossier avec un appel de fonction finale.

37
00:01:56,680 --> 00:01:59,540
Maintenant que nous avons une idée générale de ce que nous allons faire,

38
00:01:59,540 --> 00:02:02,000
nous allons plonger dans le code.

39
00:02:02,000 --> 00:02:06,100
>> Dans ce répertoire, nous avons deux fichiers C et les fichiers exécutables correspondant.

40
00:02:06,100 --> 00:02:09,710
Le programme machine prend un argument en ligne de commande,

41
00:02:09,710 --> 00:02:12,060
le nom du document que nous voulons créer.

42
00:02:12,060 --> 00:02:16,160
Dans ce cas, nous allons l'appeler doc.txt.

43
00:02:16,160 --> 00:02:19,080
Lançons le programme et entrez quelques lignes.

44
00:02:19,080 --> 00:02:23,660
Salut. Mon nom est Jason.

45
00:02:23,660 --> 00:02:26,710
Enfin, nous allons taper "quit".

46
00:02:26,710 --> 00:02:29,720
Si nous avons maintenant la liste de tous les fichiers dans ce répertoire,

47
00:02:29,720 --> 00:02:33,770
nous voyons qu'un nouveau document appelé doc.txt existe.

48
00:02:34,190 --> 00:02:36,110
C'est le fichier de ce programme vient d'être créé.

49
00:02:36,110 --> 00:02:40,520
Et bien sûr, il est trop rien de plus qu'une longue suite de zéros et de uns.

50
00:02:41,100 --> 00:02:43,260
Si nous ouvrons ce nouveau fichier,

51
00:02:43,260 --> 00:02:45,870
nous voyons les 3 lignes de code, nous entrés dans notre programme -

52
00:02:46,060 --> 00:02:49,060
Salut. Nom est Jason mai.

53
00:02:49,580 --> 00:02:52,090
Mais qu'est-ce qui se passe réellement lorsque typewriter.c fonctionne?

54
00:02:52,810 --> 00:02:55,520
La première ligne de l'intérêt pour nous, c'est la ligne 24.

55
00:02:55,560 --> 00:02:58,490
Dans cette ligne, nous déclarons notre pointeur de fichier.

56
00:02:59,080 --> 00:03:03,140
La fonction qui retourne ce pointeur, fopen, prend deux arguments.

57
00:03:03,140 --> 00:03:07,440
Le premier est le nom du fichier, y compris l'extension de fichier le cas échéant.

58
00:03:07,440 --> 00:03:10,980
Rappelons qu'une extension de fichier n'influence pas le fichier à son niveau le plus bas.

59
00:03:10,980 --> 00:03:14,640
Nous sommes toujours face à une longue séquence de zéros et de uns.

60
00:03:14,640 --> 00:03:19,630
Mais cela influence la façon dont les fichiers sont interprétés et quelles applications sont utilisées pour les ouvrir.

61
00:03:19,630 --> 00:03:22,290
Le second argument de fopen est une seule lettre

62
00:03:22,290 --> 00:03:25,300
qui est synonyme de ce que nous comptons faire après avoir ouvert le fichier.

63
00:03:25,300 --> 00:03:30,630
Il existe trois options pour cet argument - W, R et A.

64
00:03:30,630 --> 00:03:34,900
Nous avons choisi de w dans ce cas parce que nous voulons écrire dans le fichier.

65
00:03:34,900 --> 00:03:38,820
R, comme vous pouvez probablement le deviner, est de lire le fichier.

66
00:03:38,820 --> 00:03:41,760
Et un est pour l'ajout au fichier.

67
00:03:41,760 --> 00:03:44,960
Bien que les deux poids et une peut être utilisé pour écrire dans des fichiers,

68
00:03:44,960 --> 00:03:47,460
w allons commencer à écrire dès le début du fichier

69
00:03:47,460 --> 00:03:50,810
et susceptible d'écraser toutes les données qui ont déjà été enregistrées.

70
00:03:50,810 --> 00:03:54,070
Par défaut, le fichier que nous ouvrons, si elle n'existe pas déjà,

71
00:03:54,070 --> 00:03:57,180
est créé dans notre répertoire de travail actuel.

72
00:03:57,180 --> 00:04:00,540
Cependant, si l'on veut accéder ou créer un fichier dans un emplacement différent,

73
00:04:00,540 --> 00:04:02,650
dans le premier argument de fopen,

74
00:04:02,650 --> 00:04:05,840
nous pouvons spécifier un chemin de fichier en plus du nom du fichier.

75
00:04:05,840 --> 00:04:09,490
Alors que la première partie de ce processus est une seule ligne de code long,

76
00:04:09,490 --> 00:04:12,350
il est toujours bon d'inclure une autre série de lignes

77
00:04:12,350 --> 00:04:15,930
que vérifier que le fichier a été ouvert ou créé.

78
00:04:15,930 --> 00:04:20,300
Si la fonction fopen retourne null, nous ne voulons pas aller de l'avant avec notre programme,

79
00:04:20,300 --> 00:04:23,270
et cela peut se produire si le système d'exploitation est hors de la mémoire

80
00:04:23,270 --> 00:04:27,940
ou si on essaie d'ouvrir un fichier dans un répertoire pour lequel nous n'avions pas les autorisations appropriées.

81
00:04:27,940 --> 00:04:31,780
>> La deuxième partie du processus se déroule en boucle tant que machine à écrire.

82
00:04:31,780 --> 00:04:35,000
Nous utilisons une fonction CS50 bibliothèque pour obtenir l'entrée de l'utilisateur,

83
00:04:35,000 --> 00:04:37,190
et en supposant qu'ils ne veulent pas quitter le programme,

84
00:04:37,190 --> 00:04:41,940
on utilise les fonctions fputs à prendre la chaîne et l'écrire dans le fichier.

85
00:04:41,940 --> 00:04:46,700
fputs n'est qu'une des nombreuses fonctions que nous pourrions utiliser pour écrire dans le fichier.

86
00:04:46,700 --> 00:04:51,920
D'autres incluent fwrite, fputc, et même fprintf.

87
00:04:51,920 --> 00:04:54,840
Quelle que soit la fonction particulière que nous finissez par utiliser, cependant,

88
00:04:54,840 --> 00:04:57,480
tous ont besoin de savoir, par l'intermédiaire de leurs arguments,

89
00:04:57,480 --> 00:04:59,670
au moins deux choses -

90
00:04:59,670 --> 00:05:03,140
ce qui doit être écrit et où il doit être écrit.

91
00:05:03,140 --> 00:05:07,240
Dans notre cas, l'entrée est la chaîne qui doit être écrite

92
00:05:07,240 --> 00:05:11,290
et fp est le pointeur qui nous dirige à l'endroit où nous écrivons.

93
00:05:11,290 --> 00:05:15,330
Dans ce programme, la deuxième partie du processus est assez simple.

94
00:05:15,330 --> 00:05:17,360
Nous sommes tout simplement en prenant une chaîne de l'utilisateur

95
00:05:17,360 --> 00:05:22,120
et de l'ajouter directement à notre fichier avec peu ou pas de validation d'entrée ou de contrôles de sécurité.

96
00:05:22,120 --> 00:05:26,160
Souvent, cependant, la deuxième partie prendra la majeure partie de votre code.

97
00:05:26,160 --> 00:05:30,580
Enfin, la troisième partie est sur la ligne 58, où nous fermons le dossier.

98
00:05:30,580 --> 00:05:34,860
Ici, nous appelons fclose et de le transmettre notre pointeur de fichier d'origine.

99
00:05:34,860 --> 00:05:39,500
Dans la ligne suivante, on revient à zéro, signalant la fin de notre programme.

100
00:05:39,500 --> 00:05:42,630
Et, oui, la troisième partie est aussi simple que cela.

101
00:05:42,630 --> 00:05:45,260
>> Passons à la lecture de fichiers.

102
00:05:45,260 --> 00:05:48,220
Retour dans notre annuaire, nous avons un fichier appelé printer.c.

103
00:05:48,220 --> 00:05:50,910
Nous allons le faire fonctionner avec le fichier que nous venons de créer -

104
00:05:50,910 --> 00:05:53,350
doc.txt.

105
00:05:53,350 --> 00:05:58,150
Ce programme, comme son nom l'indique, va simplement afficher le contenu du fichier qui lui est passé.

106
00:05:58,150 --> 00:06:00,230
Et là, nous l'avons.

107
00:06:00,230 --> 00:06:03,780
Les lignes de code que nous avions tapé plus tôt et enregistré dans doc.txt.

108
00:06:03,780 --> 00:06:06,980
Salut. Mon nom est Jason.

109
00:06:06,980 --> 00:06:09,120
Si nous plongeons dans printer.c,

110
00:06:09,120 --> 00:06:13,570
nous constatons qu'une grande partie du code ressemble à ce que nous y sommes allés par le biais de typewriter.c.

111
00:06:13,570 --> 00:06:16,720
En effet la ligne 22, où nous avons ouvert le fichier,

112
00:06:16,720 --> 00:06:19,220
et la ligne 39, où l'on a fermé le dossier,

113
00:06:19,220 --> 00:06:23,890
sont à la fois presque identique à typewriter.c, à l'exception de l'argument de fopen seconde.

114
00:06:23,890 --> 00:06:26,510
Cette fois nous allons lire un fichier,

115
00:06:26,510 --> 00:06:29,040
C'est pourquoi nous avons choisi r au lieu de w.

116
00:06:29,040 --> 00:06:31,950
Ainsi, concentrons-nous sur la deuxième partie de ce processus.

117
00:06:31,950 --> 00:06:36,060
Dans la ligne 35, la seconde condition dans notre 4 boucles,

118
00:06:36,060 --> 00:06:38,590
nous lançons un appel à fgets,

119
00:06:38,590 --> 00:06:42,190
la fonction d'accompagnement fputs d'avant.

120
00:06:42,190 --> 00:06:44,660
Cette fois-ci, nous avons trois arguments.

121
00:06:44,660 --> 00:06:48,810
Le premier est le pointeur vers le tableau de caractères, où la chaîne sera stockée.

122
00:06:48,810 --> 00:06:52,670
La seconde est le nombre maximal de caractères à lire.

123
00:06:52,670 --> 00:06:56,010
Et le troisième est le pointeur vers le fichier avec lequel nous travaillons.

124
00:06:56,010 --> 00:07:00,780
Vous remarquerez que la boucle for se termine lorsque fgets renvoie null.

125
00:07:00,780 --> 00:07:02,940
Il ya deux raisons que ce qui a pu arriver.

126
00:07:02,940 --> 00:07:05,380
Tout d'abord, une erreur a pu se produire.

127
00:07:05,380 --> 00:07:10,740
Deuxièmement, et c'est plus probable, à la fin du fichier a été atteinte et pas plus de caractères ont été lus.

128
00:07:10,740 --> 00:07:14,040
Dans le cas où vous vous poseriez la question, deux fonctions existent qui nous permettent de dire

129
00:07:14,040 --> 00:07:17,160
que la raison est la cause de ce pointeur NULL particulier.

130
00:07:17,160 --> 00:07:21,090
Et, sans surprise, car ils ont à voir avec l'utilisation des fichiers,

131
00:07:21,090 --> 00:07:26,940
à la fois la fonction et le début ferror fonction feof par la lettre f.

132
00:07:26,940 --> 00:07:32,130
>> Enfin, avant de conclure, un petit mot sur la fin de la fonction de fichier,

133
00:07:32,130 --> 00:07:36,690
qui, comme nous venons, est écrit comme feof.

134
00:07:36,690 --> 00:07:41,550
Souvent, vous vous retrouverez avec boucles while et for progressivement lire votre chemin à travers les fichiers.

135
00:07:41,550 --> 00:07:45,790
Ainsi, vous aurez besoin d'un moyen de mettre fin à ces boucles lorsque vous avez atteint la fin de ces fichiers.

136
00:07:45,790 --> 00:07:50,510
Appel feof sur votre pointeur de fichier et vérifier pour voir si c'est vrai

137
00:07:50,510 --> 00:07:52,310
serait faire exactement cela.

138
00:07:52,310 --> 00:07:59,820
Ainsi, une boucle while avec la condition (! Feof (fp)) peut sembler être une solution parfaitement appropriée.

139
00:07:59,820 --> 00:08:03,770
Cependant, dire que nous avons une ligne à gauche dans notre fichier texte.

140
00:08:03,770 --> 00:08:07,130
Nous allons entrer dans notre boucle while et tout fonctionnera comme prévu.

141
00:08:07,130 --> 00:08:12,750
Au tour suivant grâce, notre programme va vérifier pour voir si feof de fp est vrai,

142
00:08:12,750 --> 00:08:15,430
mais - et c'est là le point crucial de comprendre ici -

143
00:08:15,430 --> 00:08:17,770
il ne sera pas vrai pour l'instant.

144
00:08:17,770 --> 00:08:21,110
C'est parce que le but de feof n'est pas de vérifier

145
00:08:21,110 --> 00:08:24,400
si le prochain appel à une fonction de lecture va frapper la fin du fichier,

146
00:08:24,400 --> 00:08:28,190
mais plutôt de vérifier si oui ou non la fin du fichier a déjà été atteint.

147
00:08:28,190 --> 00:08:30,140
Dans le cas de cet exemple,

148
00:08:30,140 --> 00:08:32,780
lire la dernière ligne de notre dossier va parfaitement bien,

149
00:08:32,780 --> 00:08:36,210
mais le programme ne sait pas encore que nous avons atteint la fin de notre dossier.

150
00:08:36,210 --> 00:08:40,549
Il n'est pas jusqu'à ce qu'elle lit-on plus qu'elle s'oppose à la fin du fichier.

151
00:08:40,549 --> 00:08:43,210
Ainsi, une condition correcte serait la suivante:

152
00:08:43,210 --> 00:08:49,330
fgets et ses trois arguments - de sortie, la taille de la production, et fp -

153
00:08:49,330 --> 00:08:52,570
et tout cela n'est pas égale à null.

154
00:08:52,570 --> 00:08:55,260
C'est l'approche que nous a pris en printer.c,

155
00:08:55,260 --> 00:08:57,890
et dans ce cas, après la sortie de la boucle,

156
00:08:57,890 --> 00:09:04,290
l'on pourrait appeler feof ou ferror pour informer l'utilisateur que pour le raisonnement spécifique pour sortir de cette boucle.

157
00:09:04,290 --> 00:09:08,100
>> L'écriture et la lecture d'un fichier est, à la base,

158
00:09:08,100 --> 00:09:10,150
un simple processus en 3 parties.

159
00:09:10,150 --> 00:09:12,530
Tout d'abord, nous ouvrons le fichier.

160
00:09:12,530 --> 00:09:16,740
Deuxièmement, nous avons certaines choses dans notre fichier ou d'entreprendre certaines choses hors de lui.

161
00:09:16,740 --> 00:09:19,200
Troisièmement, nous fermons le dossier.

162
00:09:19,200 --> 00:09:21,170
La première et la dernière sont faciles.

163
00:09:21,170 --> 00:09:23,920
La partie centrale est l'endroit où se trouve l'étoffe délicate.

164
00:09:23,920 --> 00:09:27,760
Et bien que sous le capot, nous sommes toujours face à une longue séquence de zéros et de uns,

165
00:09:27,760 --> 00:09:30,710
elle aide lors du codage d'ajouter une couche d'abstraction

166
00:09:30,710 --> 00:09:35,350
qui transforme la séquence en quelque chose qui ressemble plus à ce que nous sommes habitués à voir.

167
00:09:35,350 --> 00:09:39,570
Par exemple, si nous travaillons avec un fichier bitmap 24 bits,

168
00:09:39,570 --> 00:09:43,290
nous allons probablement en train de lire ou d'écrire trois octets à la fois.

169
00:09:43,290 --> 00:09:46,450
Dans ce cas, il serait judicieux de définir et de nommer de manière appropriée

170
00:09:46,450 --> 00:09:48,980
une structure qui est de 3 octets grand.

171
00:09:48,980 --> 00:09:51,410
>> Bien travailler avec des fichiers peut sembler compliqué,

172
00:09:51,410 --> 00:09:54,530
les utiliser nous permet de faire quelque chose de vraiment remarquable.

173
00:09:54,530 --> 00:09:58,880
Nous pouvons changer l'état du monde en dehors de notre programme,

174
00:09:58,880 --> 00:10:01,730
nous pouvons créer quelque chose qui vit au-delà de la vie de notre programme,

175
00:10:01,730 --> 00:10:07,190
ou nous pouvons même changer quelque chose qui a été créé avant notre programme a commencé à courir.

176
00:10:07,190 --> 00:10:11,210
Interagir avec les fichiers est une partie vraiment puissant de la programmation en C.

177
00:10:11,210 --> 00:10:15,300
et je suis impatient de voir ce que vous allez créer avec elle dans le code à venir.

178
00:10:15,300 --> 00:10:19,770
Mon nom est Jason Hirschhorn. C'est CS50.

179
00:10:19,770 --> 00:10:21,770
[CS50.TV]

180
00:10:21,770 --> 00:10:25,940
>> [Rires]

181
00:10:25,940 --> 00:10:29,330
D'accord. Une seule prise. Nous y voilà.

182
00:10:49,000 --> 00:10:52,140
Quand nous pensons à un fichier - >> Oh, attendez. Désolé.

183
00:10:52,140 --> 00:10:56,800
[Rires] D'accord.

184
00:11:06,620 --> 00:11:09,970
Hey there.

185
00:11:13,670 --> 00:11:16,310
Quand nous pensons à un fichier -

186
00:11:17,610 --> 00:11:20,710
Quand vous pensez d'un fichier - D'accord. Dites-moi quand vous êtes prêt.

187
00:11:20,710 --> 00:11:22,520
Oh, génial.

188
00:11:22,520 --> 00:11:26,180
Bien que la lecture d'un prompteur peut sembler - no. My bad.