1
00:00:00,000 --> 00:00:05,330

2
00:00:05,330 --> 00:00:07,870
>> 演讲嘉宾：到目前为止，它可能
大多数的程序

3
00:00:07,870 --> 00:00:10,170
已经有点短暂。

4
00:00:10,170 --> 00:00:13,310
你运行像马里奥或贪婪的程序。

5
00:00:13,310 --> 00:00:17,350
它做的东西，它可能提示
对于某些信息的用户，

6
00:00:17,350 --> 00:00:20,400
打印某些输出到屏幕上，
但是当你的程序已经结束了，

7
00:00:20,400 --> 00:00:23,252
真的没有证据表明有
这是有史以来第一位执行。

8
00:00:23,252 --> 00:00:25,960
我的意思是，当然，你可能已经离开
它在终端窗口中打开，

9
00:00:25,960 --> 00:00:29,770
但如果你清楚你的屏幕上，有
真的没有证据证明它的存在。

10
00:00:29,770 --> 00:00:33,720
我们没有存储的手段
持久性信息，信息

11
00:00:33,720 --> 00:00:36,890
我们以后存在
程序已停止运行，

12
00:00:36,890 --> 00:00:39,241
或者我们还没有到这一点。

13
00:00:39,241 --> 00:00:41,490
幸运的是，虽然，C做
我们提供的能力

14
00:00:41,490 --> 00:00:44,220
通过实施这样做
叫什么

15
00:00:44,220 --> 00:00:48,330
一个文件，这样的结构，基本上
代表你会加倍文件

16
00:00:48,330 --> 00:00:53,826
单击您的计算机上，如果你
用于图形用户环境。

17
00:00:53,826 --> 00:00:55,700
一般工作时
与C，我们实际上

18
00:00:55,700 --> 00:00:59,965
将要与工作
指针files--文件stars--

19
00:00:59,965 --> 00:01:02,090
除了一点点
当我们谈论的一对夫妇

20
00:01:02,090 --> 00:01:04,560
的函数
使用文件指针工作。

21
00:01:04,560 --> 00:01:08,990
你并不需要真的挖到
太深入的了解指针

22
00:01:08,990 --> 00:01:09,730
自己。

23
00:01:09,730 --> 00:01:12,870
有一点蝇头位
在这里，我们将谈论他们，

24
00:01:12,870 --> 00:01:18,090
但一般文件指针和
三分球，而相互关联的，

25
00:01:18,090 --> 00:01:20,290
不完全一样的东西。

26
00:01:20,290 --> 00:01:22,440
>> 现在，这是什么意思时，
我说的持久性数据？

27
00:01:22,440 --> 00:01:23,650
什么是持久性数据？

28
00:01:23,650 --> 00:01:25,232
我们为什么要关心它？

29
00:01:25,232 --> 00:01:27,190
说，例如，该
你正在运行的程序

30
00:01:27,190 --> 00:01:29,850
或者你已经重写一个
程序，这是一个游戏，

31
00:01:29,850 --> 00:01:32,960
你想跟踪
所有用户的招式

32
00:01:32,960 --> 00:01:36,620
因此，也许如果出了问题，
您可以查看在比赛结束后的文件。

33
00:01:36,620 --> 00:01:39,970
这就是我们的时候，我们的意思是
谈论持久性数据。

34
00:01:39,970 --> 00:01:43,930
>> 在运行的过程中你
程序，文件被创建。

35
00:01:43,930 --> 00:01:45,680
而当你的程序
已停止运行，

36
00:01:45,680 --> 00:01:48,689
该文件仍然存在你的系统上。

37
00:01:48,689 --> 00:01:50,230
我们可以看一下它，研究它。

38
00:01:50,230 --> 00:01:53,670
并且使得节目将被设置为
创造了一些持久性数据，

39
00:01:53,670 --> 00:01:57,390
程序后的数据存在
已完成运行。

40
00:01:57,390 --> 00:02:02,320
>> 现在，所有这些功能的工作
与创建文件和操作

41
00:02:02,320 --> 00:02:04,940
他们以不同的方式
住在标准io.h，

42
00:02:04,940 --> 00:02:08,210
这是一个头文件
你可能是英镑

43
00:02:08,210 --> 00:02:10,910
包括漂亮的顶部
多所有程序

44
00:02:10,910 --> 00:02:14,130
因为它包含的所述一个
对我们来说最有用的功能，

45
00:02:14,130 --> 00:02:16,130
printf的，这也让
住在标准io.h.

46
00:02:16,130 --> 00:02:20,400
所以，你不需要砸向包括
任何其他文件可能

47
00:02:20,400 --> 00:02:23,540
为了与文件指针一起工作。

48
00:02:23,540 --> 00:02:29,980
>> 现在，每一个文件的指针功能，
或者每一个文件I / O输入输出

49
00:02:29,980 --> 00:02:33,310
功能，接收为一体
其参数或输入

50
00:02:33,310 --> 00:02:35,822
文件pointer--除
一，FOPEN，这

51
00:02:35,822 --> 00:02:38,280
是你用什么来获取文件
指针摆在首位。

52
00:02:38,280 --> 00:02:41,010
但是，你打开后，
文件并且得到文件指针，

53
00:02:41,010 --> 00:02:43,510
那么你可以将它们作为
参数的各种功能

54
00:02:43,510 --> 00:02:46,720
我们要谈
今天，以及许多其他

55
00:02:46,720 --> 00:02:48,520
这样您就可以使用文件。

56
00:02:48,520 --> 00:02:50,980
>> 因此，有6个漂亮
常见的基本要点

57
00:02:50,980 --> 00:02:52,870
那我们要谈论今天。

58
00:02:52,870 --> 00:02:57,160
FOPEN和它的同伴
函数fclose函数，龟etc

59
00:02:57,160 --> 00:03:02,670
及其配套功能的fputc，
和FREAD及其配套功能，

60
00:03:02,670 --> 00:03:03,820
FWRITE。

61
00:03:03,820 --> 00:03:05,180
因此，让我们马上进去。

62
00:03:05,180 --> 00:03:07,050
>> fopen--它有什么作用？

63
00:03:07,050 --> 00:03:10,050
那么，它会打开一个文件，并将其
给你一个文件指针指向它，

64
00:03:10,050 --> 00:03:14,000
这样你就可以使用
文件指针作为参数

65
00:03:14,000 --> 00:03:16,730
任何其他文件I / O功能。

66
00:03:16,730 --> 00:03:19,100
最重要的事情
要记住的fopen

67
00:03:19,100 --> 00:03:24,222
是，你必须开后
文件或在这里取得像一个呼叫，

68
00:03:24,222 --> 00:03:26,930
你需要检查，以确保
那你回来的指针

69
00:03:26,930 --> 00:03:28,320
不等于空。

70
00:03:28,320 --> 00:03:31,320
如果你还没有看过上的视频
三分球，这可能没有什么意义。

71
00:03:31,320 --> 00:03:35,639
但是，如果你尝试取消引用
一个空指针召回，

72
00:03:35,639 --> 00:03:38,180
你的程序可能会吃亏
分段[听不清]。

73
00:03:38,180 --> 00:03:40,540
我们要确保我们
得到了一个合法的指针返回。

74
00:03:40,540 --> 00:03:43,665
的大多数时间我们将
已经获得了合法的指针回

75
00:03:43,665 --> 00:03:45,280
它不会成为一个问题。

76
00:03:45,280 --> 00:03:46,760
>> 那么，我们如何拨打电话给fopen？

77
00:03:46,760 --> 00:03:48,051
它看起来非常像这样。

78
00:03:48,051 --> 00:03:52,690
文件明星ptr-- PTR是一个通用的
命名文件pointer-- FOPEN

79
00:03:52,690 --> 00:03:57,300
我们通过在两件事情，一个文件名
和操作我们要进行。

80
00:03:57,300 --> 00:04:01,690
所以，我们可能有一个电话，看起来像
this--文件明星PTR 1等于FOPEN

81
00:04:01,690 --> 00:04:04,040
FILE1.TXT。

82
00:04:04,040 --> 00:04:07,020
而我所选择的操作为r。

83
00:04:07,020 --> 00:04:08,639
>> 那么，你认为r是在这里吗？

84
00:04:08,639 --> 00:04:11,180
什么是各种各样的事情，我们
也许能够做的文件吗？

85
00:04:11,180 --> 00:04:13,760

86
00:04:13,760 --> 00:04:17,500
以r是操作，我们
选择当我们要读取文件。

87
00:04:17,500 --> 00:04:20,260
所以我们基本上是在
我们做这样的呼吁

88
00:04:20,260 --> 00:04:25,440
越来越自己一个文件指针
这样，我们便可以读取信息

89
00:04:25,440 --> 00:04:27,770
从FILE1.TXT。

90
00:04:27,770 --> 00:04:34,190
>> 同样，我们可以打开的文件2.txt
写作，所以我们可以通过PTR2，

91
00:04:34,190 --> 00:04:38,210
我在这里创建的文件指针，
作为参数传递给任何函数

92
00:04:38,210 --> 00:04:40,080
将信息写入到一个文件。

93
00:04:40,080 --> 00:04:43,767
而类似的写作，有
还可以选择追加一个。

94
00:04:43,767 --> 00:04:45,600
之间的差
写作和附加

95
00:04:45,600 --> 00:04:50,920
是当你写一个文件，
如果你打个电话给fopen写作

96
00:04:50,920 --> 00:04:54,761
而该文件已经存在，它的
要覆盖整个文件。

97
00:04:54,761 --> 00:04:56,510
这将启动
在开始的时候，

98
00:04:56,510 --> 00:04:58,820
删除所有信息
这是已经存在。

99
00:04:58,820 --> 00:05:02,210
>> 然而，如果你打开​​它进行追加，
将进入该文件的结束

100
00:05:02,210 --> 00:05:04,340
如果有已经在文本
它或在它的信息，

101
00:05:04,340 --> 00:05:06,040
它将再启动
从那里写作。

102
00:05:06,040 --> 00:05:08,570
所以，你不会丢失任何的
你以前做过的信息。

103
00:05:08,570 --> 00:05:12,110
无论你想要写或追加
那种视情况而定。

104
00:05:12,110 --> 00:05:16,840
但是，你可能知道的
正确的操作是在时机成熟时。

105
00:05:16,840 --> 00:05:18,020
所以这是FOPEN。

106
00:05:18,020 --> 00:05:18,930
>> 什么fclose函数？

107
00:05:18,930 --> 00:05:21,600
嗯，倒也干脆，fclose函数
刚刚接受文件指针。

108
00:05:21,600 --> 00:05:24,000
正如你所期望的，
它将关闭该文件。

109
00:05:24,000 --> 00:05:29,270
一旦我们已经关闭的文件，我们不能
执行任何更多的文件I / O功能，

110
00:05:29,270 --> 00:05:31,420
读取或写入，在该文件中。

111
00:05:31,420 --> 00:05:36,444
我们不得不重新打开
文件中的另一个时间，以便

112
00:05:36,444 --> 00:05:38,610
继续与工作
使用它的I / O功能。

113
00:05:38,610 --> 00:05:41,520
我们这样做fclose函数方法
正与此文件。

114
00:05:41,520 --> 00:05:44,690
而所有我们需要传递的是
一个文件指针的名称。

115
00:05:44,690 --> 00:05:50,010
因此，一对夫妇幻灯片前，我们
fopened文件1点文本阅读

116
00:05:50,010 --> 00:05:52,854
我们分配了
文件指针ptr1的。

117
00:05:52,854 --> 00:05:55,020
现在我们已经决定我们
完成从文件中读取。

118
00:05:55,020 --> 00:05:56,561
我们不需要做任何更多的它。

119
00:05:56,561 --> 00:05:58,890
我们可以只fclose函数ptr1的。

120
00:05:58,890 --> 00:06:01,950
同样，我们能否
F关闭其他的。

121
00:06:01,950 --> 00:06:02,450
好吧。

122
00:06:02,450 --> 00:06:03,700
这样的开始和结束。

123
00:06:03,700 --> 00:06:05,780
这些是两个基本
启动操作。

124
00:06:05,780 --> 00:06:08,050
>> 现在，我们要以实际
做一些有趣的东西，

125
00:06:08,050 --> 00:06:11,940
和第一个功能，我们将
看到将这样做是fgetc--

126
00:06:11,940 --> 00:06:14,110
文件中获取一个字符。

127
00:06:14,110 --> 00:06:17,350
这就是通常龟etc
将转化。

128
00:06:17,350 --> 00:06:20,190
其人生目标是
读取下一个字符，

129
00:06:20,190 --> 00:06:22,079
如果这是你很
到龟etc第一个电话

130
00:06:22,079 --> 00:06:23,870
为一个特定的文件，
第一个字符。

131
00:06:23,870 --> 00:06:26,210
但在那之后，
你的下一个，

132
00:06:26,210 --> 00:06:31,500
该文件的最下一个字符，
并将其存储在一个字符变量。

133
00:06:31,500 --> 00:06:34,490
正如我们所做的，
焦炭CH等于龟etc，

134
00:06:34,490 --> 00:06:36,389
通过在一个文件指针的名称。

135
00:06:36,389 --> 00:06:38,180
再次，这是非常
重要的是必须记住

136
00:06:38,180 --> 00:06:41,430
是，为了有
这种操作成功，

137
00:06:41,430 --> 00:06:45,690
文件指针本身意有所指
打开阅读。

138
00:06:45,690 --> 00:06:50,589
我们不能从文件中读取一个字符
指针，我们进行写入操作。

139
00:06:50,589 --> 00:06:52,630
所以这是之一
的FOPEN的限制，对不对？

140
00:06:52,630 --> 00:06:55,470
我们一定要限制
我们只执行

141
00:06:55,470 --> 00:06:57,710
一个操作一个文件指针。

142
00:06:57,710 --> 00:07:00,220
如果我们想读，
从同一个文件中写入，

143
00:07:00,220 --> 00:07:03,840
我们就必须打开两个独立的
文件指向同一file--

144
00:07:03,840 --> 00:07:05,670
一个用于读，一个用于写。

145
00:07:05,670 --> 00:07:08,400
>> 如此反复，唯一的理由
我提起这件事，现在是

146
00:07:08,400 --> 00:07:11,920
因为如果我们要拨打电话
到龟etc，该文件指针意有所指

147
00:07:11,920 --> 00:07:14,172
打开阅读。

148
00:07:14,172 --> 00:07:15,880
然后倒也干脆，
所有我们需要做的

149
00:07:15,880 --> 00:07:17,546
是通过在文件指针的名称。

150
00:07:17,546 --> 00:07:21,060
因此，焦炭CH等于龟etc ptr1的。

151
00:07:21,060 --> 00:07:23,200
>> 那将让我们
接下来character--

152
00:07:23,200 --> 00:07:25,575
或再次，如果这是第一个
一次，我们已经取得了这一呼吁，

153
00:07:25,575 --> 00:07:29,750
的第一character--任何
文件由ptr1的指向。

154
00:07:29,750 --> 00:07:32,210
回想一下，这是文件1点文字。

155
00:07:32,210 --> 00:07:36,490
它会得到的第一个字符
我们将其存储在变量通道。

156
00:07:36,490 --> 00:07:37,941
很简单。

157
00:07:37,941 --> 00:07:40,190
因此，我们只看到三个
功能和已经我们

158
00:07:40,190 --> 00:07:43,070
可以做一些漂亮整洁。

159
00:07:43,070 --> 00:07:46,320
>> 因此，如果我们把这种能力
得到一个字符的

160
00:07:46,320 --> 00:07:48,943
我们循环它 - 所以我们
继续得到字符

161
00:07:48,943 --> 00:07:51,390
从一个文件过来，
过去，over--现在我们

162
00:07:51,390 --> 00:07:54,500
可以读取每一个
字符的文件名。

163
00:07:54,500 --> 00:07:58,670
如果我们打印的每一个字符
之后我们读它，

164
00:07:58,670 --> 00:08:01,960
我们现在已经从文件中读取和
印刷的内容到屏幕上。

165
00:08:01,960 --> 00:08:05,610
我们已经有效地连接起来
在屏幕上该文件。

166
00:08:05,610 --> 00:08:09,670
而这正是
Linux命令的猫一样。

167
00:08:09,670 --> 00:08:13,250
>> 如果您在文件名中键入的猫，它
将打印出的全部内容

168
00:08:13,250 --> 00:08:15,160
在终端窗口中的文件。

169
00:08:15,160 --> 00:08:19,010
所以这里这个小环，
只有三行代码，

170
00:08:19,010 --> 00:08:23,270
但它有效地复制
Linux命令猫。

171
00:08:23,270 --> 00:08:25,210
所以这个语法可能
看起来有点怪异，

172
00:08:25,210 --> 00:08:26,670
但这里的这里发生了什么。

173
00:08:26,670 --> 00:08:31,460
虽然CH等于龟etc，ptr不
等于EOF--它是一个整体一口，

174
00:08:31,460 --> 00:08:34,669
但让我们把它分解只
所以很明显的语法。

175
00:08:34,669 --> 00:08:37,169
我已经巩固了它
为求空间，

176
00:08:37,169 --> 00:08:39,049
虽然这是一个有点
语法棘手。

177
00:08:39,049 --> 00:08:41,194
>> 因此，这部分绿色右
现在，它在干什么？

178
00:08:41,194 --> 00:08:42,860
好吧，这只是我们的龟etc电话，对不对？

179
00:08:42,860 --> 00:08:44,530
我们已经看到过。

180
00:08:44,530 --> 00:08:49,500
它获得一种
字符从该文件。

181
00:08:49,500 --> 00:08:53,220
然后，我们比较一下
性格对EOF。

182
00:08:53,220 --> 00:08:57,470
EOF是一个特殊的值，它是
在标准io.h，定义了

183
00:08:57,470 --> 00:08:59,390
为文件结束字符。

184
00:08:59,390 --> 00:09:03,450
所以基本上什么事情要发生
在这个循环将读取一个字符，

185
00:09:03,450 --> 00:09:07,445
把它比作EOF时，
文件结束符。

186
00:09:07,445 --> 00:09:10,070
如果它们不匹配，所以我们没有
到达文件的结尾，

187
00:09:10,070 --> 00:09:11,490
我们将打印字符的。

188
00:09:11,490 --> 00:09:13,740
然后，我们将回到
重新开始循环。

189
00:09:13,740 --> 00:09:18,310
我们会得到一个字符，检查
对EOF，打印出来，等

190
00:09:18,310 --> 00:09:21,094
等等，
以这种方式遍历

191
00:09:21,094 --> 00:09:22,760
直到我们到达了文件的末尾。

192
00:09:22,760 --> 00:09:24,593
然后由这一点，
我们将印

193
00:09:24,593 --> 00:09:26,210
出文件的全部内容。

194
00:09:26,210 --> 00:09:29,450
所以，再一次，我们只看到
FOPEN和fclose和龟etc

195
00:09:29,450 --> 00:09:34,950
而且我们已经可以复制
Linux终端命令。

196
00:09:34,950 --> 00:09:38,850
>> 正如我在开始时说，
我们有龟etc和的fputc，

197
00:09:38,850 --> 00:09:41,860
和的fputc是伴侣
和函数fgetc的。

198
00:09:41,860 --> 00:09:44,880
所以，如你所想，
它是写入等效。

199
00:09:44,880 --> 00:09:49,440
它可以让我们写一个
单个字符到一个文件。

200
00:09:49,440 --> 00:09:53,290
>> 同样，需要注意的是，刚
就像是与龟etc，该文件

201
00:09:53,290 --> 00:09:56,660
我们正在编写到一定发生了
打开写入或追加。

202
00:09:56,660 --> 00:10:00,820
如果我们尝试使用的fputc上的文件
我们已经为读而打开，

203
00:10:00,820 --> 00:10:02,760
我们要吃亏
有点错误。

204
00:10:02,760 --> 00:10:04,440
但通话是非常简单的。

205
00:10:04,440 --> 00:10:08,000
的fputc大写的A PTR2，所有
这是怎么回事要做的就是它的

206
00:10:08,000 --> 00:10:12,040
打算写的信
成阿成的文件2点

207
00:10:12,040 --> 00:10:14,760
文本，这是的名称
文件我们打开并分配

208
00:10:14,760 --> 00:10:17,280
指针PTR2。

209
00:10:17,280 --> 00:10:20,430
所以，我们要编写一个
大写字母A到文件2点文字。

210
00:10:20,430 --> 00:10:24,592
我们将编写一个感叹号
指向文件3点

211
00:10:24,592 --> 00:10:27,330
文本，这是由ptr3指出。

212
00:10:27,330 --> 00:10:29,730
如此反复，很简单在这里。

213
00:10:29,730 --> 00:10:32,727
>> 但是现在我们可以做的另一件事。

214
00:10:32,727 --> 00:10:34,560
我们有这样的例子
我们只是在看

215
00:10:34,560 --> 00:10:38,950
对能够复制猫
Linux命令，打印出一

216
00:10:38,950 --> 00:10:40,500
到屏幕上。

217
00:10:40,500 --> 00:10:43,510
好了，现在我们有能力
以从文件中读取字符

218
00:10:43,510 --> 00:10:46,590
和写入字符的文件，
为什么我们不只是替换了

219
00:10:46,590 --> 00:10:50,720
调用printf一个调用的fputc。

220
00:10:50,720 --> 00:10:54,090
>> 现在，我们已经重复CP，
一个非常基本的Linux命令

221
00:10:54,090 --> 00:10:59,100
我们刚才谈到的方式长
以前在Linux命令的视频。

222
00:10:59,100 --> 00:11:01,070
我们有效地已经
重复的就在这里。

223
00:11:01,070 --> 00:11:04,790
我们读一个字符，然后我们
写这个角色到另一个文件。

224
00:11:04,790 --> 00:11:07,660
从一个文件读，写
到另一个，遍地

225
00:11:07,660 --> 00:11:11,350
一遍又一遍，直到我们遇到EOF。

226
00:11:11,350 --> 00:11:14,250
我们一定要的到底
文件我们试图从复制。

227
00:11:14,250 --> 00:11:18,500
而由我们自己编写的所有
的字符，我们需要将文件

228
00:11:18,500 --> 00:11:19,500
我们正在写。

229
00:11:19,500 --> 00:11:24,270
因此，这是CP，Linux的复制命令。

230
00:11:24,270 --> 00:11:26,550
>> 在一开始
这个视频，我的告诫

231
00:11:26,550 --> 00:11:29,840
我们会聊
关于指针点点。

232
00:11:29,840 --> 00:11:32,480
下面是具体在哪里我们
要谈论的指针

233
00:11:32,480 --> 00:11:34,800
除了文件指针。

234
00:11:34,800 --> 00:11:37,870
所以这个功能看起来有种可怕的。

235
00:11:37,870 --> 00:11:39,120
它有几个参数。

236
00:11:39,120 --> 00:11:40,430
有很多怎么回事。

237
00:11:40,430 --> 00:11:42,760
有很多的不同
颜色和文字。

238
00:11:42,760 --> 00:11:47,100
但实际上，它只是
龟etc通用版

239
00:11:47,100 --> 00:11:50,110
这使我们能够得到任何
的信息量。

240
00:11:50,110 --> 00:11:53,560
它可以是一个有点低效率的，如果我们是
获得的字符之一的时间，

241
00:11:53,560 --> 00:11:55,770
通过文件迭代
一个字符的时间。

242
00:11:55,770 --> 00:12:00,230
那岂不是更好得到
100在一个时间或500的时间？

243
00:12:00,230 --> 00:12:03,250
>> 那么，FREAD和它的伴侣函数
FWRITE，我们将谈谈

244
00:12:03,250 --> 00:12:05,490
在第二，使我们能够做到这一点。

245
00:12:05,490 --> 00:12:08,480
我们可以读取任意数量
从文件中的信息

246
00:12:08,480 --> 00:12:10,290
我们存储在某个地方暂时的。

247
00:12:10,290 --> 00:12:12,980
而不是能够只
在一个变量适合它，

248
00:12:12,980 --> 00:12:15,790
我们可能需要将其存放在数组中。

249
00:12:15,790 --> 00:12:19,980
因此，我们通过在四个
参数fread--指针

250
00:12:19,980 --> 00:12:23,940
到我们的位置
要存储的信息，

251
00:12:23,940 --> 00:12:29,180
多大每个信息单元
将成为信息多少个单位

252
00:12:29,180 --> 00:12:35,192
我们想要收购，而从
我们希望得到他们的文件。

253
00:12:35,192 --> 00:12:37,150
也许最好的说明
在这里的一个例子。

254
00:12:37,150 --> 00:12:41,640
因此，让我们说，我们声明
10整数数组。

255
00:12:41,640 --> 00:12:45,080
我们在刚刚宣布
堆栈任意诠释ARR 10。

256
00:12:45,080 --> 00:12:46,970
所以这是非常简单的。

257
00:12:46,970 --> 00:12:51,970
现在我们正在做的虽然是什么
frecall是我们在阅读为int的大小

258
00:12:51,970 --> 00:12:54,180
次10字节的信息。

259
00:12:54,180 --> 00:12:59,040
INT存在尺寸four--那
在C的整数的大小。

260
00:12:59,040 --> 00:13:02,790
>> 因此，我们正在做的事情是，我们正在阅读
40个字节的信息

261
00:13:02,790 --> 00:13:05,850
从文件指向PTR。

262
00:13:05,850 --> 00:13:08,600
我们要存储这些
40个字节的地方

263
00:13:08,600 --> 00:13:12,080
在这里，我们已预留
40个字节的内存。

264
00:13:12,080 --> 00:13:15,970
幸运的是，我们已经完成了由
声明ARR，该数组就在这里。

265
00:13:15,970 --> 00:13:19,770
是能够保持的
10四字节单元。

266
00:13:19,770 --> 00:13:22,860
因此，在总，它可以容纳40
个字节的信息。

267
00:13:22,860 --> 00:13:26,540
而我们现在正在读40个字节
从文件的信息，

268
00:13:26,540 --> 00:13:30,330
我们正在将它存储在编曲。

269
00:13:30,330 --> 00:13:35,470
>> 从指针的视频回忆
的阵列，如改编的名称，

270
00:13:35,470 --> 00:13:38,370
真的只是一个指针
其第一元件。

271
00:13:38,370 --> 00:13:43,680
所以，当我们通过在编曲那里，我们
是的，其实，传递一个指针。

272
00:13:43,680 --> 00:13:46,120
>> 同样，我们可以做的this--
我们不一定

273
00:13:46,120 --> 00:13:51,200
需要保存我们的缓冲区在堆栈中。

274
00:13:51,200 --> 00:13:54,990
我们还可以动态地分配
一个缓冲区就是这样，用malloc。

275
00:13:54,990 --> 00:13:57,340
请记住，当我们
动态分配内存，

276
00:13:57,340 --> 00:14:00,550
我们将其保存在
堆，而不是叠。

277
00:14:00,550 --> 00:14:02,110
但它仍然是一个缓冲区。

278
00:14:02,110 --> 00:14:06,810
>> 它仍然在这种情况下，是
保持640个字节的信息

279
00:14:06,810 --> 00:14:09,230
因为双占用了八个字节。

280
00:14:09,230 --> 00:14:11,570
而且我们要求为80人。

281
00:14:11,570 --> 00:14:13,770
我们希望能有空间
持有80双打。

282
00:14:13,770 --> 00:14:17,210
因此，80倍8是640个字节的信息。

283
00:14:17,210 --> 00:14:21,880
这调用fread是
收集640个字节的信息

284
00:14:21,880 --> 00:14:27,770
从文件指向
PTR现在将它存储在ARR2。

285
00:14:27,770 --> 00:14:32,770
>> 现在，我们也可以把FREAD
就像调用龟etc。

286
00:14:32,770 --> 00:14:37,140
在这种情况下，我们只是想
从文件中获取一个字符。

287
00:14:37,140 --> 00:14:40,070
我们不需要
数组来保存一个字符。

288
00:14:40,070 --> 00:14:43,170
我们只需将其存放在
一个字符变量。

289
00:14:43,170 --> 00:14:46,390
>> 美中不足的，不过，是
当我们只是有一个变量，

290
00:14:46,390 --> 00:14:50,290
我们需要传递的
该变量的地址

291
00:14:50,290 --> 00:14:52,550
因为回想一下，
第一个参数FREAD

292
00:14:52,550 --> 00:14:59,210
是指向的位置和存储器
在这里我们要存储的信息。

293
00:14:59,210 --> 00:15:01,550
再次，一个名
阵列是一个指针。

294
00:15:01,550 --> 00:15:04,200
所以我们并不需要做符号阵列。

295
00:15:04,200 --> 00:15:07,270
但是，C，字符c
这里，不是数组。

296
00:15:07,270 --> 00:15:08,390
这只是一个变量。

297
00:15:08,390 --> 00:15:11,840
因此，我们需要传递一个
符号C到指示

298
00:15:11,840 --> 00:15:15,350
那这就是我们想要的地址
存储信息的这一个字节，

299
00:15:15,350 --> 00:15:20,479
这一个字符
我们收集的PTR。

300
00:15:20,479 --> 00:15:22,270
Fwrite--我会去通过
这一点

301
00:15:22,270 --> 00:15:25,440
quickly--几乎是
FREAD的完全等效

302
00:15:25,440 --> 00:15:27,720
除了它的写作
而不是阅读，只是

303
00:15:27,720 --> 00:15:31,610
像other--我们已经开
和关闭，进入一个人物，

304
00:15:31,610 --> 00:15:32,530
写一个字。

305
00:15:32,530 --> 00:15:35,040
现在，获得任意
的信息量，

306
00:15:35,040 --> 00:15:37,170
右的任意数量的信息。

307
00:15:37,170 --> 00:15:39,790
因此，只要像以前一样，我们可以
有10整数数组

308
00:15:39,790 --> 00:15:43,210
在这里我们已经有
信息存储，也许吧。

309
00:15:43,210 --> 00:15:46,580
>> 这可能是一些代码行
应在这两者之间去

310
00:15:46,580 --> 00:15:49,990
在这里我填写常用3与
有意义的事。

311
00:15:49,990 --> 00:15:51,880
我填补它与10个不同的整数。

312
00:15:51,880 --> 00:15:54,920
而相反，就是我
做的是从编曲写

313
00:15:54,920 --> 00:15:58,600
和收集从ARR的信息。

314
00:15:58,600 --> 00:16:02,390
我要带的资料
把球送入该文件。

315
00:16:02,390 --> 00:16:05,410
>> 因此，而不是其被
文件到缓冲器，

316
00:16:05,410 --> 00:16:08,790
我们现在从去
缓冲区到该文件。

317
00:16:08,790 --> 00:16:10,580
因此，它正好相反。

318
00:16:10,580 --> 00:16:16,680
如此反复，就如同之前，我们就可以
也有一个内存堆块

319
00:16:16,680 --> 00:16:19,600
我们动态地已经
分配并从阅读

320
00:16:19,600 --> 00:16:21,570
并编写该文件。

321
00:16:21,570 --> 00:16:24,900
>> 而且我们也有一个变量
能够容纳一个字节

322
00:16:24,900 --> 00:16:27,200
的信息，诸如字符。

323
00:16:27,200 --> 00:16:29,830
但同样，我们需要传递
该变量的地址

324
00:16:29,830 --> 00:16:31,840
当我们想从中读取。

325
00:16:31,840 --> 00:16:35,280
因此，我们可以写信息
我们发现在该地址

326
00:16:35,280 --> 00:16:39,050
该文件指针，PTR。

327
00:16:39,050 --> 00:16:41,630
>> 还有很多其他的
大文件I / O功能

328
00:16:41,630 --> 00:16:44,650
即做各种事情，除了
那些我们已经谈到了今天。

329
00:16:44,650 --> 00:16:46,450
一对夫妇的那些
你可能会发现有用

330
00:16:46,450 --> 00:16:50,840
是fgets和的fputs，
它们是等效

331
00:16:50,840 --> 00:16:56,190
的龟etc和的fputc但对于阅读
从文件中一个字符串。

332
00:16:56,190 --> 00:16:59,020
而不是一个单一的字符，
它会读取整个字符串。

333
00:16:59,020 --> 00:17:02,940
fprintf中，基本上允许
你用printf写入文件。

334
00:17:02,940 --> 00:17:05,619
所以，就像你可以做
使用变量替换

335
00:17:05,619 --> 00:17:09,900
占位符％的I和
百分之d和等，具有的printf

336
00:17:09,900 --> 00:17:14,690
你同样可以把
printf的字符串和打印的东西

337
00:17:14,690 --> 00:17:16,800
这样的一个文件。

338
00:17:16,800 --> 00:17:20,720
>> fseek--如果你有一台DVD播放机
就是这个比喻我通常使用这里 - 

339
00:17:20,720 --> 00:17:23,109
有点像用你
快退和快进

340
00:17:23,109 --> 00:17:25,819
按钮移动影片各地。

341
00:17:25,819 --> 00:17:28,369
同样，您可以在文件移动。

342
00:17:28,369 --> 00:17:30,250
一个里面的东西
该文件的结构

343
00:17:30,250 --> 00:17:34,270
将c为您创建是一个指标
在那里你是在文件中。

344
00:17:34,270 --> 00:17:36,420
你是在很
开始，在0字节？

345
00:17:36,420 --> 00:17:39,290
你是在字节100，
字节1000，以此类推？

346
00:17:39,290 --> 00:17:44,340
您可以使用fseek的任意移动
该指标前进或后退。

347
00:17:44,340 --> 00:17:46,744
>> 而FTELL，再次
类似于DVD播放机，

348
00:17:46,744 --> 00:17:49,660
就像一个小时钟，告诉
你有多少分钟，你秒

349
00:17:49,660 --> 00:17:52,480
是到特定的电影。

350
00:17:52,480 --> 00:17:56,990
同样，FTELL告诉您如何
你是到文件的字节数。

351
00:17:56,990 --> 00:18:00,210
的feof是一个不同的版本
检测你是否已经

352
00:18:00,210 --> 00:18:01,700
到达文件的结尾。

353
00:18:01,700 --> 00:18:03,600
和ferror是一个函数
您可以使用

354
00:18:03,600 --> 00:18:06,959
检测到的东西是否有
出了问题的工作与文件。

355
00:18:06,959 --> 00:18:08,750
同样，这仅仅是
表面文章。

356
00:18:08,750 --> 00:18:12,730
仍然有很多更多的文件I / O
在标准io.h.功能

357
00:18:12,730 --> 00:18:16,620
但是，这可能会得到你
开始与文件指针工作。

358
00:18:16,620 --> 00:18:17,640
我是道格·劳埃德。

359
00:18:17,640 --> 00:18:19,750
这是CS50。

360
00:18:19,750 --> 00:18:21,669