1
00:00:00,000 --> 00:00:07,810

2
00:00:07,810 --> 00:00:09,840
>> JASON HIRSCHHORN：欢迎光临，
每个人，至第6周。

3
00:00:09,840 --> 00:00:14,790
我很高兴看到你们都活得很好
测验0后，因为我知道，

4
00:00:14,790 --> 00:00:15,810
是有点粗糙。

5
00:00:15,810 --> 00:00:18,370
但幸运的是，你的所有
做了令人难以置信的好。

6
00:00:18,370 --> 00:00:21,680
所以这是美妙的。

7
00:00:21,680 --> 00:00:25,840
如果你在我的部分，我已经给了最
你已经备份你的测验。

8
00:00:25,840 --> 00:00:28,050
>> 一对夫妇的你，我满足
下课。

9
00:00:28,050 --> 00:00:32,360
如果你是一个扩展的学生，
您还没有收到您的回测验

10
00:00:32,360 --> 00:00:35,490
然而，你的TF可能是工作就可以了
和分级它，将它找回来

11
00:00:35,490 --> 00:00:36,490
给您回复。

12
00:00:36,490 --> 00:00:39,650
所以，我的扩展学生谁
看现在 - 希望生活 - 

13
00:00:39,650 --> 00:00:42,880
我会得到你的测验
短期内也是如此。

14
00:00:42,880 --> 00:00:45,670
>> 我们今天的议程如下。

15
00:00:45,670 --> 00:00:50,170
首先，我们要介绍一些
资源CS50提供给你。

16
00:00:50,170 --> 00:00:54,590
我们要投奔测验0下了，
我会回答任何问题，任何人

17
00:00:54,590 --> 00:00:57,360
有关于特定问题。

18
00:00:57,360 --> 00:01:02,050
然后，我们将去了
文件I / O和习题集5。

19
00:01:02,050 --> 00:01:07,360
那些过去的​​两个主题将采取
达今日栏目的体积。

20
00:01:07,360 --> 00:01:11,680
>> 我每星期把这个列表为一个
提醒你所有，但核心

21
00:01:11,680 --> 00:01:14,650
节中，我们只为90分钟 - 我们
不能涵盖一切，我

22
00:01:14,650 --> 00:01:16,280
很想掩护你们。

23
00:01:16,280 --> 00:01:21,170
但我们有一吨的资源，为
你借鉴，你了解

24
00:01:21,170 --> 00:01:24,000
通过材料和工
你的习题集。

25
00:01:24,000 --> 00:01:30,810
>> 提醒一下，我有一个在线文字
中，设置为你填写，如果你

26
00:01:30,810 --> 00:01:33,250
有任何意见对我来说，
正面和

27
00:01:33,250 --> 00:01:35,180
建设性的，关于部分。

28
00:01:35,180 --> 00:01:38,600
该URL坐落在此地。

29
00:01:38,600 --> 00:01:43,250
所以，请花一点时间，如果您有任何
反馈，无论是节期间，

30
00:01:43,250 --> 00:01:48,030
或之后，或者在您观看视频
在网上，给我你的反馈。

31
00:01:48,030 --> 00:01:52,100
我真的很感激它的任何和所有。

32
00:01:52,100 --> 00:01:55,730
>> 所以我一直有小对话
有很多我的

33
00:01:55,730 --> 00:01:59,350
学生们整个星期 - 因为我的手
回测验，说起

34
00:01:59,350 --> 00:02:01,480
当然，看你怎么做。

35
00:02:01,480 --> 00:02:05,120
和一个主题已经拿出了过来，
在多谈论 - 在

36
00:02:05,120 --> 00:02:05,660
特别是 - 

37
00:02:05,660 --> 00:02:07,710
习题集。

38
00:02:07,710 --> 00:02:13,090
我已经封装的主题
在黑板上现在。

39
00:02:13,090 --> 00:02:16,630
>> 从本质上讲，有一个区别
在转弯的东西是间

40
00:02:16,630 --> 00:02:19,590
正确办什么事
做到这一点很好。

41
00:02:19,590 --> 00:02:22,920
大多数人一直在做梦幻
在正确性方面 - 

42
00:02:22,920 --> 00:02:25,460
5人或4对所有的pset。

43
00:02:25,460 --> 00:02:27,930
大多数人越来越
这些所有的时间。

44
00:02:27,930 --> 00:02:31,150
>> 然而，仅仅因为你所做的
正确的事情并不意味着你已经

45
00:02:31,150 --> 00:02:34,450
做了一些为优雅，或
有效，或干净的你

46
00:02:34,450 --> 00:02:35,270
可以办到的。

47
00:02:35,270 --> 00:02:36,790
而这正是设计 - 

48
00:02:36,790 --> 00:02:39,230
并在较小的程度，风格 - 

49
00:02:39,230 --> 00:02:40,450
轴的。

50
00:02:40,450 --> 00:02:45,130
因此，我推你的一切，和其他转录因子
是推动你们，不仅转

51
00:02:45,130 --> 00:02:48,320
的事情是正确的，但把
在编码很好的事情。

52
00:02:48,320 --> 00:02:53,060
>> 如果不这样做不必要的FOR循环，
不重新计算的变量，如果

53
00:02:53,060 --> 00:02:53,800
你不必。

54
00:02:53,800 --> 00:02:58,520
例如，回想问题集
4，放置在砖时

55
00:02:58,520 --> 00:03:03,070
屏幕上，每一行 - 在每一个砖
给定的行具有相同的y坐标 - 

56
00:03:03,070 --> 00:03:04,390
相同的高度坐标。

57
00:03:04,390 --> 00:03:07,930
>> 使y坐标也没必要
可以在内部计算内

58
00:03:07,930 --> 00:03:11,070
嵌套的for循环，你可能使用
把屏幕上的砖块。

59
00:03:11,070 --> 00:03:14,030
它仅需要将每一个计算
一次交换一排，或

60
00:03:14,030 --> 00:03:15,200
向下移动一行。

61
00:03:15,200 --> 00:03:19,760
所以说，如果有10个砖头在
行，每一块砖可以有相同的

62
00:03:19,760 --> 00:03:22,260
y坐标，而y坐标
可以只计算

63
00:03:22,260 --> 00:03:23,550
一旦所有这些的。

64
00:03:23,550 --> 00:03:27,810
>> 它并不需要计算10
次，也没有那个必要计算

65
00:03:27,810 --> 00:03:30,220
要发生在实际
函数调用 - 

66
00:03:30,220 --> 00:03:33,020
新gracked函数调用。

67
00:03:33,020 --> 00:03:37,820
因此，如果这是一个有点混乱的
你，更一般地，事

68
00:03:37,820 --> 00:03:40,730
并不需要发生的每一次
你经过一个FOR循环不应该

69
00:03:40,730 --> 00:03:42,900
把FOR循环里面，不应该
发生一次你去的时间

70
00:03:42,900 --> 00:03:44,080
通过FOR循环。

71
00:03:44,080 --> 00:03:49,270
>> 我们看到了另一个很好的设计实例
在第3周为15，你可以保持

72
00:03:49,270 --> 00:03:50,500
轨道零。

73
00:03:50,500 --> 00:03:53,600
所以，当你初始化板，
保存 - 在一个全局变量，也许 - 

74
00:03:53,600 --> 00:03:56,140
x和y坐标的零点。

75
00:03:56,140 --> 00:03:57,520
然后每当你 - 

76
00:03:57,520 --> 00:04:00,310
在您的移动功能，只要您
一个成功的举动，您更新

77
00:04:00,310 --> 00:04:02,040
零的位置。

78
00:04:02,040 --> 00:04:06,240
>> 这将节省您不必做
嵌套的for循环，以期待通过

79
00:04:06,240 --> 00:04:10,700
登上每一次在你的移动功能
并找到了零，或者找瓷砖，

80
00:04:10,700 --> 00:04:12,460
然后检查接下来会发生什么吧。

81
00:04:12,460 --> 00:04:16,329
相反，你必须的位置
零，你可以看上面，下面，

82
00:04:16,329 --> 00:04:21,160
以及它的左侧和右侧，以找到
你要找的瓷砖。

83
00:04:21,160 --> 00:04:24,970
>> 因此，在我们的节目条款
写作，他们是永远不够大

84
00:04:24,970 --> 00:04:28,580
其中一些设计决策
真的要妨碍你

85
00:04:28,580 --> 00:04:31,670
程序，或使其运行速度比较慢，
或者甚至耗尽内存。

86
00:04:31,670 --> 00:04:35,030
但我们仍坚持你们
写的优雅

87
00:04:35,030 --> 00:04:36,450
高效的代码越好。

88
00:04:36,450 --> 00:04:39,910
>> 所以，如果你做的写出来的东西
具有显著较大

89
00:04:39,910 --> 00:04:44,660
范围，它们将被写入具有良好的
设计除了是正确的。

90
00:04:44,660 --> 00:04:46,300
因此，一些有
带了这一点。

91
00:04:46,300 --> 00:04:48,560
这是我们正在寻找的 - 
东西我们要继续

92
00:04:48,560 --> 00:04:49,840
按你们的。

93
00:04:49,840 --> 00:04:52,460
>> 如果你有关于任何问题
你的程序设计，可以自由

94
00:04:52,460 --> 00:04:56,870
接触到我，我很高兴
走过你的程序和你在一起，

95
00:04:56,870 --> 00:05:01,320
并指出一些设计
你做，给你一些决定

96
00:05:01,320 --> 00:05:06,240
如何提出建议，甚至
更好的设计决策。

97
00:05:06,240 --> 00:05:08,870
>> 所以，我们要继续前进
要说起测验0。

98
00:05:08,870 --> 00:05:11,300
在我们这样做，是否有人
有任何疑问什么

99
00:05:11,300 --> 00:05:14,252
我已经介绍了这么远吗？

100
00:05:14,252 --> 00:05:21,500
>> [沙沙噪声]

101
00:05:21,500 --> 00:05:22,750
>> JASON HIRSCHHORN：七秒。

102
00:05:22,750 --> 00:05:23,250
确定。

103
00:05:23,250 --> 00:05:24,970
让我们来谈谈测验0位。

104
00:05:24,970 --> 00:05:26,700
大多数时候，你有你的测验0的背上。

105
00:05:26,700 --> 00:05:29,820
如果你不这样做，希望
你还记得它一下。

106
00:05:29,820 --> 00:05:34,770
但是，如果你已经采取测验0，那么你
在还可以使用到PDF在线

107
00:05:34,770 --> 00:05:35,890
样品溶液。

108
00:05:35,890 --> 00:05:39,480
>> 没有任何人有之前的任何问题
我们跳进了一周的有关材料

109
00:05:39,480 --> 00:05:41,520
在测验0的特殊问题 - 

110
00:05:41,520 --> 00:05:44,630
为什么答案是它是什么？

111
00:05:44,630 --> 00:05:47,255
是任何人都感到困惑什么？

112
00:05:47,255 --> 00:05:50,230
即使你得到了正确的问题，但
只是希望我解释了一下

113
00:05:50,230 --> 00:05:52,640
更多的，我很高兴现在这样做。

114
00:05:52,640 --> 00:05:57,800
>> 于是我问你们来
要准备好一些

115
00:05:57,800 --> 00:05:59,440
有关测验0的想法。

116
00:05:59,440 --> 00:06:02,660
那么，谁愿意让我们
开始用的问题或

117
00:06:02,660 --> 00:06:04,655
有关测验0个评论？

118
00:06:04,655 --> 00:06:07,435

119
00:06:07,435 --> 00:06:10,410
>> [纸张的沙沙声]

120
00:06:10,410 --> 00:06:11,470
>> JASON HIRSCHHORN：不是每个人都
做完美。

121
00:06:11,470 --> 00:06:12,720
所以我知道（笑）

122
00:06:12,720 --> 00:06:15,950
有有一些问题
关于测验0。

123
00:06:15,950 --> 00:06:27,940

124
00:06:27,940 --> 00:06:28,590
确定。

125
00:06:28,590 --> 00:06:29,210
是。

126
00:06:29,210 --> 00:06:29,600
Ompica。

127
00:06:29,600 --> 00:06:30,520
>> OMPICA：10号。

128
00:06:30,520 --> 00:06:33,560
>> JASON HIRSCHHORN：10号。

129
00:06:33,560 --> 00:06:35,400
其中一个是10号？

130
00:06:35,400 --> 00:06:35,840
>> OMPICA：本 - 

131
00:06:35,840 --> 00:06:36,420
>> JASON HIRSCHHORN：我haven't  - 

132
00:06:36,420 --> 00:06:37,670
>> OMPICA：将包括 - 

133
00:06:37,670 --> 00:06:40,060

134
00:06:40,060 --> 00:06:42,180
>> JASON HIRSCHHORN：10号是八
为i  - 写八到我？

135
00:06:42,180 --> 00:06:42,980
>> OMPICA：是啊。

136
00:06:42,980 --> 00:06:43,630
>> JASON HIRSCHHORN：确定。

137
00:06:43,630 --> 00:06:47,390
所以另外一个问题，你可以有
问了我我有先见之明？

138
00:06:47,390 --> 00:06:48,630
答案是肯定的。

139
00:06:48,630 --> 00:06:52,060
在测验前一节，我问
你们的代码既英镑和

140
00:06:52,060 --> 00:06:52,980
八到我。

141
00:06:52,980 --> 00:06:54,770
他们都发生在
出现在测验。

142
00:06:54,770 --> 00:06:57,510
所以希望，你付出
注意这一点。

143
00:06:57,510 --> 00:07:02,520
>> 如果你有，那么你将不得不
大概就这两个做得很好。

144
00:07:02,520 --> 00:07:06,030
但八到我，我们实际上并没有代码
在课堂上，但它是，再次，

145
00:07:06,030 --> 00:07:07,500
问的测验。

146
00:07:07,500 --> 00:07:13,270
因此，一对夫妇的事情要
注意编码八到我的时候。

147
00:07:13,270 --> 00:07:17,320
的第一件事，每问题，是
你需要检查字符串

148
00:07:17,320 --> 00:07:20,300
等于空。

149
00:07:20,300 --> 00:07:28,060
>> 一对夫妇的人试图检查以后
在程序中如果s支架我是 - 

150
00:07:28,060 --> 00:07:30,940
在这样一个特定的字符
字符串 - 等于空。

151
00:07:30,940 --> 00:07:35,600
但要记住，空本质上是 - 
它的好，想到的

152
00:07:35,600 --> 00:07:39,100
null作为一个零指针 - 
一个指针到零 - 

153
00:07:39,100 --> 00:07:40,920
某处在内存中
你永远无法访问。

154
00:07:40,920 --> 00:07:44,730
>> 所以，如果事情是为n​​ull，则
知道它没有被初始化，

155
00:07:44,730 --> 00:07:46,430
或者有什么也没有。

156
00:07:46,430 --> 00:07:50,950
所以s是一个char明星，S
支架i是一个char。

157
00:07:50,950 --> 00:07:57,410
所以是有意义的比较s到空，
但不发支架I为null。

158
00:07:57,410 --> 00:07:59,390
但是再一次 - 所以这是第一件事情
你应该做的事情 - 

159
00:07:59,390 --> 00:08:03,510
检查以确保你真正
有了一个真正的字符串。

160
00:08:03,510 --> 00:08:08,020
>> 接下来，你想去通过
每个字符的字符串。

161
00:08:08,020 --> 00:08:12,500
所以这将是像一个s支架
我举个例子，如果我是你的迭代器。

162
00:08:12,500 --> 00:08:17,250
并采取该字符，然后
得到它的实际价值。

163
00:08:17,250 --> 00:08:21,800
你有它存储为一个char，但
零的ASCII值 - 

164
00:08:21,800 --> 00:08:23,010
零的性格 - 

165
00:08:23,010 --> 00:08:25,450
实际上不是整数为零。

166
00:08:25,450 --> 00:08:28,700
它的一些其他数字，你可以
查ASCII表中。

167
00:08:28,700 --> 00:08:30,790
>> 这样的一种方式来纠正该 - 
可能纠正的最佳方式

168
00:08:30,790 --> 00:08:33,760
这 - 是从它减去
字符值 - 

169
00:08:33,760 --> 00:08:35,140
零的一个字符。

170
00:08:35,140 --> 00:08:38,490
所以减去单引号，零，
另一个单引号。

171
00:08:38,490 --> 00:08:44,620
这将需要的任何数字你有
作为一个字符，并得到它等于

172
00:08:44,620 --> 00:08:46,720
数作为实际的整数。

173
00:08:46,720 --> 00:08:50,300
>> 那是非常相似的方法
很多人在发生

174
00:08:50,300 --> 00:08:52,800
问题设置2，与凯撒
和Viginere  - 

175
00:08:52,800 --> 00:08:55,160
这些密码，当你
被旋转它们。

176
00:08:55,160 --> 00:08:59,210
你拥有了它作为一个从打完
零到9，然后 - 视

177
00:08:59,210 --> 00:09:02,750
它不用在最终的数字 - 
你需要乘以

178
00:09:02,750 --> 00:09:04,120
以10的幂。

179
00:09:04,120 --> 00:09:07,340
>> 有些人从后面移动到
前，再乘以个人

180
00:09:07,340 --> 00:09:08,940
以10的幂数。

181
00:09:08,940 --> 00:09:11,160
有些人感动
从前到后 - 

182
00:09:11,160 --> 00:09:14,430
等了最高
订单号第一 - 

183
00:09:14,430 --> 00:09:18,190
并会拯救那些在
全局计数器变量。

184
00:09:18,190 --> 00:09:20,880
然后通过对每个时间
循环，乘以全球巨头

185
00:09:20,880 --> 00:09:25,640
10计数器变量，使
空间的下一个字符。

186
00:09:25,640 --> 00:09:28,750
>> 所以这是没有一点混乱
我写在黑板上。

187
00:09:28,750 --> 00:09:31,550
但试样溶液
是提供给您。

188
00:09:31,550 --> 00:09:32,870
但是，这些都是大事情
我们所期待的。

189
00:09:32,870 --> 00:09:36,400
另外一个检查，以确保每个
个性确实是一个

190
00:09:36,400 --> 00:09:39,780
零点九，而不是字符之间
其他一些字符，比如一个A，

191
00:09:39,780 --> 00:09:41,160
例如。

192
00:09:41,160 --> 00:09:43,150
>> 这些都是我们所期待的东西
对于这个问题。

193
00:09:43,150 --> 00:09:46,510

194
00:09:46,510 --> 00:09:47,980
这是否回答你的问题？

195
00:09:47,980 --> 00:09:49,320
>> OMPICA：是啊。

196
00:09:49,320 --> 00:09:50,240
>> JASON HIRSCHHORN：确定。

197
00:09:50,240 --> 00:09:53,940
是否有任何其他问题
有关测验0？

198
00:09:53,940 --> 00:09:55,440
怎么样编译？

199
00:09:55,440 --> 00:09:56,740
每个人都编译吧？

200
00:09:56,740 --> 00:09:58,370
号

201
00:09:58,370 --> 00:09:58,840
当时有 - 

202
00:09:58,840 --> 00:10:01,010
[笑]

203
00:10:01,010 --> 00:10:03,265
有关的任何问题
编译过程？

204
00:10:03,265 --> 00:10:06,050

205
00:10:06,050 --> 00:10:06,966
哇。

206
00:10:06,966 --> 00:10:11,090
>> [纸张的沙沙声]

207
00:10:11,090 --> 00:10:11,520
>> JASON HIRSCHHORN：是的。

208
00:10:11,520 --> 00:10:11,700
迈克尔。

209
00:10:11,700 --> 00:10:14,140
>> 迈克尔：是7号 - 随机？

210
00:10:14,140 --> 00:10:16,500
>> JASON HIRSCHHORN：号码7。

211
00:10:16,500 --> 00:10:20,670
数字7是得到一个随机整数。

212
00:10:20,670 --> 00:10:21,110
优秀的。

213
00:10:21,110 --> 00:10:25,630
所以你给出一个整数a和
整数b，你想一个随机

214
00:10:25,630 --> 00:10:28,710
a和b之间的整数。

215
00:10:28,710 --> 00:10:31,740
实际上，我们可以这样写一个关于
该板，因为这一个

216
00:10:31,740 --> 00:10:33,320
是一行代码 - 

217
00:10:33,320 --> 00:10:34,390
一种方式来做到这一点。

218
00:10:34,390 --> 00:10:37,810
>> 所以我们作为一个给定的DRAND
函数我们可以使用。

219
00:10:37,810 --> 00:10:38,820
又是什么DRAND  - 

220
00:10:38,820 --> 00:10:40,290
假设它已经播种 - 

221
00:10:40,290 --> 00:10:42,316
是什么DRAND返回？

222
00:10:42,316 --> 00:10:44,840
>> MICHAEL：0.0和1.0之间的浮点数。

223
00:10:44,840 --> 00:10:45,530
>> JASON HIRSCHHORN：许多 - 是啊。

224
00:10:45,530 --> 00:10:47,910
一个数字0和1之间。

225
00:10:47,910 --> 00:10:51,760
因此，我们有b和。

226
00:10:51,760 --> 00:10:55,480
然后，我们有我们的随机数
0和1之间赐给我们DRAND。

227
00:10:55,480 --> 00:11:01,480

228
00:11:01,480 --> 00:11:06,630
有些人试图把B或B减
一，什么里面那些

229
00:11:06,630 --> 00:11:07,960
括号内。

230
00:11:07,960 --> 00:11:11,210
这将意味着他们
参数给这个函数。

231
00:11:11,210 --> 00:11:13,450
>> DRAND不带任何参数 - 
喜欢做的getString

232
00:11:13,450 --> 00:11:14,330
不带任何参数。

233
00:11:14,330 --> 00:11:16,600
所以它只是开括号，靠近
括号 - 这，本身就是

234
00:11:16,600 --> 00:11:17,330
函数调用。

235
00:11:17,330 --> 00:11:19,770
这给了你一个数字
0和1之间。

236
00:11:19,770 --> 00:11:22,820
当然，我们有一个整体范围
该号码可以是英寸

237
00:11:22,820 --> 00:11:28,470
>> 说，如果b为10和5，我们真的
想用范围为5的数。

238
00:11:28,470 --> 00:11:36,940
因此，我们需要做的下一件事是
由范围B减一乘这一点。

239
00:11:36,940 --> 00:11:40,380
这样假设的成倍增加。

240
00:11:40,380 --> 00:11:42,590
而这将给我们一个数
在给定的范围内。

241
00:11:42,590 --> 00:11:46,610
而这特定范围即
B减一之间的差异。

242
00:11:46,610 --> 00:11:50,030
>> 终于，那将只能从给它 - 
说B减一之间的范围

243
00:11:50,030 --> 00:11:52,520
是5，那会给我们一个
数从0到5。

244
00:11:52,520 --> 00:11:56,000
但是，如果实际上5，我们需要提高
这个范围可达到它的

245
00:11:56,000 --> 00:12:01,380
其实应该是，通过增加一个。

246
00:12:01,380 --> 00:12:02,580
从而使得到的逻辑正确。

247
00:12:02,580 --> 00:12:03,745
然后，你会不会有
另一个问题？

248
00:12:03,745 --> 00:12:04,547
>> MICHAEL：号

249
00:12:04,547 --> 00:12:06,010
我只是觉得非常愚蠢的现在。

250
00:12:06,010 --> 00:12:06,405
[笑]

251
00:12:06,405 --> 00:12:06,730
>> JASON HIRSCHHORN：号

252
00:12:06,730 --> 00:12:08,640
不要觉得自己很愚蠢。

253
00:12:08,640 --> 00:12:10,560
许多人挣扎
带着这样的疑问。

254
00:12:10,560 --> 00:12:13,920
然后，其他的问题是，DRAND，
你说，给你一个浮动 - 

255
00:12:13,920 --> 00:12:14,940
返回一个浮点数。

256
00:12:14,940 --> 00:12:18,020
但这个功能居然问
对于一个整数返回。

257
00:12:18,020 --> 00:12:23,700
>> 你不需要显式转换本
为整数，因为这些

258
00:12:23,700 --> 00:12:29,090
操作将把它作为一个全
浮动 - 作为一个浮点数。

259
00:12:29,090 --> 00:12:31,570
这样的意志 - 哪怕这
是一个整数，这将

260
00:12:31,570 --> 00:12:32,890
正确地成​​倍增加。

261
00:12:32,890 --> 00:12:34,000
所有的乘法会的工作。

262
00:12:34,000 --> 00:12:35,060
你不需要在这里投。

263
00:12:35,060 --> 00:12:36,480
其实，你不应该投它。

264
00:12:36,480 --> 00:12:37,310
>> 那会 - 

265
00:12:37,310 --> 00:12:40,750
如果你想投一个数字
这是介于0和1  - 

266
00:12:40,750 --> 00:12:42,680
一个随机数，一个浮点 - 

267
00:12:42,680 --> 00:12:47,850
然后它要么是只有0或1，所以
你将失去所有的精度。

268
00:12:47,850 --> 00:12:50,120
但最后，当您返回时，
它会自动获取

269
00:12:50,120 --> 00:12:51,620
发送回为整数。

270
00:12:51,620 --> 00:12:56,870
所以，你不需要做
该铸造自己。

271
00:12:56,870 --> 00:13:00,810
>> 因此，这是答案
这个问题，数字7。

272
00:13:00,810 --> 00:13:02,190
在测验0没有其他问题？

273
00:13:02,190 --> 00:13:03,300
是啊，安妮。

274
00:13:03,300 --> 00:13:05,050
>> 安妮：我们什么时候使用递归 - 

275
00:13:05,050 --> 00:13:07,850
当我们使用迭代循环？

276
00:13:07,850 --> 00:13:10,210
>> JASON HIRSCHHORN：你什么时候使用
递归 - 因此更一般地，本

277
00:13:10,210 --> 00:13:14,110
与递归的利弊
迭代方法。

278
00:13:14,110 --> 00:13:17,110
谁能提供一个亲还是一个反面？

279
00:13:17,110 --> 00:13:19,460
请？

280
00:13:19,460 --> 00:13:20,140
没有任何人可以。

281
00:13:20,140 --> 00:13:22,526
谁可以提供一个专业或一个反面？

282
00:13:22,526 --> 00:13:26,963
>> [纸张的沙沙声]

283
00:13:26,963 --> 00:13:29,730
>> 学生1：递归是少
编码 - 少打字？

284
00:13:29,730 --> 00:13:33,170
>> JASON HIRSCHHORN：那么一般，
递归尤其是，函数 - 

285
00:13:33,170 --> 00:13:35,750
或者像合并的算法
排序 - 这使它

286
00:13:35,750 --> 00:13:37,300
以递归的方法 - 

287
00:13:37,300 --> 00:13:40,710
可能是更直接
编写递归。

288
00:13:40,710 --> 00:13:43,940
而就更有意义
递归地做到这一点。

289
00:13:43,940 --> 00:13:46,230
所以这将是一个亲以递归。

290
00:13:46,230 --> 00:13:46,610
其他人呢？

291
00:13:46,610 --> 00:13:47,467
是吗？

292
00:13:47,467 --> 00:13:49,240
>> 学生2：CON递归 - 

293
00:13:49,240 --> 00:13:50,940
它使用更多的内存。

294
00:13:50,940 --> 00:13:52,200
>> JASON HIRSCHHORN：那么完全正确。

295
00:13:52,200 --> 00:13:55,720
递归函数将继续增加
堆栈帧堆栈。

296
00:13:55,720 --> 00:13:59,690
所以，如果你经营了很多的
数字和必须调用此

297
00:13:59,690 --> 00:14:02,560
功能很多，那么你肯定会
占用更多的内存，而

298
00:14:02,560 --> 00:14:05,810
迭代的方法只会把一
堆栈帧堆栈上，因为

299
00:14:05,810 --> 00:14:08,420
这一切在一个函数中发生。

300
00:14:08,420 --> 00:14:11,010
>> 任何其它的优点和缺点？

301
00:14:11,010 --> 00:14:11,500
是啊。

302
00:14:11,500 --> 00:14:12,550
>> 学生3：优点递归。

303
00:14:12,550 --> 00:14:15,950
您不必确定
提前多少次

304
00:14:15,950 --> 00:14:17,660
代码必须被重复。

305
00:14:17,660 --> 00:14:22,810
可以有预定数量的
你必须遍历，那么次

306
00:14:22,810 --> 00:14:26,420
递归是更好的，因为
它需要的结果。

307
00:14:26,420 --> 00:14:27,780
>> JASON HIRSCHHORN：我认为这是真的。

308
00:14:27,780 --> 00:14:30,770
但我认为，在这两种情况下
你永远不会 - 

309
00:14:30,770 --> 00:14:33,290
你可能会得到一些
来自用户的输入。

310
00:14:33,290 --> 00:14:35,990
或该功能将有一定的投入
这将确定多少次

311
00:14:35,990 --> 00:14:36,730
应该运行。

312
00:14:36,730 --> 00:14:39,520
所以通常，你不会硬编码 - 
即使是在迭代的方法 - 如何

313
00:14:39,520 --> 00:14:40,940
很多次，循环应该运行。

314
00:14:40,940 --> 00:14:46,100

315
00:14:46,100 --> 00:14:48,670
>> 你是否也有另一个你
想着，安妮？

316
00:14:48,670 --> 00:14:49,330
确定。

317
00:14:49,330 --> 00:14:51,650
因此，那些可能是两个 - 

318
00:14:51,650 --> 00:14:54,370
最大的亲和最大的
CON到一个递归与

319
00:14:54,370 --> 00:14:57,080
迭代方法。

320
00:14:57,080 --> 00:14:57,690
确定。

321
00:14:57,690 --> 00:14:59,465
什么都在测验0？

322
00:14:59,465 --> 00:15:08,940

323
00:15:08,940 --> 00:15:09,920
>> 让我们继续前进。

324
00:15:09,920 --> 00:15:15,260
文件I / O。有一个绝妙的短
本周在文件I / O有希望

325
00:15:15,260 --> 00:15:19,270
你看过多
时间和钦佩。

326
00:15:19,270 --> 00:15:22,910
大量的工作去成，我也
听说它是出奇的帮助。

327
00:15:22,910 --> 00:15:25,740
我也包括在这张幻灯片的链接，
如果你还没有一个

328
00:15:25,740 --> 00:15:29,160
机会观看它的10倍。

329
00:15:29,160 --> 00:15:35,280
>> 所以，我们要简要地走在
主要步骤来打开和工作

330
00:15:35,280 --> 00:15:38,400
与文件，然后我们将
潜入编码问题之前，

331
00:15:38,400 --> 00:15:40,400
检查问题集。

332
00:15:40,400 --> 00:15:44,330
所以，再一次，我打算把这段话放在
在屏幕上，但我要谈的

333
00:15:44,330 --> 00:15:47,630
只是一个关于什么我们是分钟
与文件在这里做I/O--

334
00:15:47,630 --> 00:15:49,090
这是什么意思？

335
00:15:49,090 --> 00:15:55,280
>> 这意味着，我们可以创建
的程序，然后有我们的节目

336
00:15:55,280 --> 00:16:00,370
退出，并没有作出任何影响
我们的计划之外的世界。

337
00:16:00,370 --> 00:16:04,630
但是，当我们开始对文件进行工作 - 
两个读他们和创造

338
00:16:04,630 --> 00:16:10,460
他们 - 我们可以对一些效果
我们的计划外面的世界。

339
00:16:10,460 --> 00:16:15,440
>> 就像如果Microsoft Word中无法
做任何Word文档，然后

340
00:16:15,440 --> 00:16:18,710
一旦微软的Word退出，所有的
工作将消失，并会

341
00:16:18,710 --> 00:16:19,740
真的是无用的。

342
00:16:19,740 --> 00:16:23,620
我们最终希望能够
编写能够影响计划的

343
00:16:23,620 --> 00:16:31,350
他们周围的世界，无论是通过采取在
复杂的输入 - 在文件中的条款，

344
00:16:31,350 --> 00:16:37,080
通过文件，并且还创造有趣
和令人信服的输出 - 

345
00:16:37,080 --> 00:16:39,520
在不同类型的文件方面。

346
00:16:39,520 --> 00:16:43,730
>> 所以这就是为什么我们开始
学习如何处理文件。

347
00:16:43,730 --> 00:16:47,080
更具体地，什么
我们做的是如下。

348
00:16:47,080 --> 00:16:47,680
这是非常简单的。

349
00:16:47,680 --> 00:16:51,530
目前只有几个步骤，和
在此列出的这些代码。

350
00:16:51,530 --> 00:16:55,130
因此，我们要经过
这段代码的每一行。

351
00:16:55,130 --> 00:16:57,630
>> 首先，可以看到突出 - 

352
00:16:57,630 --> 00:17:01,330
当你正在使用的文件，
不管文件的类型是，

353
00:17:01,330 --> 00:17:02,670
你需要将其打开。

354
00:17:02,670 --> 00:17:05,130
而这是通过调用FOPEN  - 

355
00:17:05,130 --> 00:17:05,950
就在这里。

356
00:17:05,950 --> 00:17:07,980
您包含文件的名称。

357
00:17:07,980 --> 00:17:11,930
如果文件是不是在你的目录中，
或者所在的文件夹这个程序

358
00:17:11,930 --> 00:17:15,910
生活，那么你还需要包括
一个路径，如该文件是。

359
00:17:15,910 --> 00:17:19,099
>> 我们将假定这
所谓“的text.txt”文件 - 

360
00:17:19,099 --> 00:17:24,220
一个简单的文本文件 - 在
同一文件夹作为这个计划是。

361
00:17:24,220 --> 00:17:26,859
所以这是另一回事，以保持在
心态 - 如果你想打开一个文件

362
00:17:26,859 --> 00:17:30,050
在其他地方，你的实际需要
以包括它的位置。

363
00:17:30,050 --> 00:17:33,520
>> 其次，你可以将参数传递给
FOPEN，这就是你想要做什么

364
00:17:33,520 --> 00:17:34,620
与该文件。

365
00:17:34,620 --> 00:17:38,450
有三个主要的论据，
你要传递给fopen。

366
00:17:38,450 --> 00:17:40,060
谁可以给我那三个？

367
00:17:40,060 --> 00:17:44,960

368
00:17:44,960 --> 00:17:47,130
谁可以给我其中之一吗？

369
00:17:47,130 --> 00:17:48,130
是。

370
00:17:48,130 --> 00:17:50,010
>> 学生4：文件名？

371
00:17:50,010 --> 00:17:50,440
>> JASON HIRSCHHORN：对不起。

372
00:17:50,440 --> 00:17:55,490
您可以通过三种主要观点
作为第二个参数给fopen。

373
00:17:55,490 --> 00:17:57,060
你说得对 - 文件名
是第一个参数。

374
00:17:57,060 --> 00:18:01,620
但第二个参数给fopen是
一般三根弦，和 - 是的。

375
00:18:01,620 --> 00:18:02,210
位于Aleja。

376
00:18:02,210 --> 00:18:03,490
>> ALEJA：A可以进行追加。

377
00:18:03,490 --> 00:18:06,840
>> JASON HIRSCHHORN：A，如果你想
追加到已存在的文件。

378
00:18:06,840 --> 00:18:07,810
>> 学生5​​：R读取。

379
00:18:07,810 --> 00:18:09,930
>> JASON HIRSCHHORN：A，如果你
想从一个文件中读取。

380
00:18:09,930 --> 00:18:10,670
>> 学生6：W表示写。

381
00:18:10,670 --> 00:18:12,840
>> JASON HIRSCHHORN：和W，如果你
要写入文件。

382
00:18:12,840 --> 00:18:17,570
因此，在这种情况下，我们正在编写
到文件，所以我们有瓦特

383
00:18:17,570 --> 00:18:22,360
你打开它，你也必须保存
文件的地方，那就是与

384
00:18:22,360 --> 00:18:26,000
代码的左手侧
赋值运算符 - 

385
00:18:26,000 --> 00:18:31,220
我创建一个指向文件
叫，在这种情况下，文件。

386
00:18:31,220 --> 00:18:36,070
>> 我们不会担心什么
这全部大写作品就是。

387
00:18:36,070 --> 00:18:40,600
不必多说，它是一个长
零和一的流。

388
00:18:40,600 --> 00:18:44,970
这就是我们如何来
运行它，了解它。

389
00:18:44,970 --> 00:18:47,300
>> 接下来的事情，我们需要做的 - 和
这是非常重要的 - 

390
00:18:47,300 --> 00:18:49,070
每当你打开一个文件 - 

391
00:18:49,070 --> 00:18:54,250
其实，只要你调用malloc，为
例如，并得到一些内存，并尝试

392
00:18:54,250 --> 00:18:57,980
并将其保存在一个指针，你总是
要检查，以确保该

393
00:18:57,980 --> 00:19:00,230
函数没有返回null。

394
00:19:00,230 --> 00:19:05,230
>> 因此，在这种情况下，我们检查，以
确保我们实际上打开了

395
00:19:05,230 --> 00:19:10,230
文件正确，并且有
在我们的程序没有错误。

396
00:19:10,230 --> 00:19:15,160
接下来，一旦我们检查，以确保
我们有一个工作的文件，我们可以

397
00:19:15,160 --> 00:19:18,520
写入或读出，
或追加到文件。

398
00:19:18,520 --> 00:19:24,270
在这种情况下，我只是简单地打印
一行到该文件。

399
00:19:24,270 --> 00:19:25,450
>> 我怎么知道？

400
00:19:25,450 --> 00:19:27,990
好吧，我使用这个功能
所谓FPRINTF。

401
00:19:27,990 --> 00:19:30,970
所有将要使用的功能
写入或从其中读出或当

402
00:19:30,970 --> 00:19:34,950
操作文件将类似于
你已经看到过，但是功能

403
00:19:34,950 --> 00:19:38,420
先从字母F，
站立文件。

404
00:19:38,420 --> 00:19:43,440
和fprintf，不像我们的正常打印
应用程序，需要一个额外的参数，

405
00:19:43,440 --> 00:19:47,800
那是文件，你
希望此行打印到。

406
00:19:47,800 --> 00:19:50,640
>> 我没有什么要
ohai的右侧。

407
00:19:50,640 --> 00:19:52,860
我没有第三
参数对printf  - 

408
00:19:52,860 --> 00:19:57,030
或者第二个参数的printf时，
第三个参数fprintf等，因为我

409
00:19:57,030 --> 00:19:59,480
没有在这里任何占位符。

410
00:19:59,480 --> 00:20:01,070
我不包括任何变量。

411
00:20:01,070 --> 00:20:06,070
但同样，和FPRINTF所有这些文件的
与文件操作的函数

412
00:20:06,070 --> 00:20:09,820
通常将需要的文件
上，他们正在运作。

413
00:20:09,820 --> 00:20:15,960
>> 最后，最后重要的事情
做的是关闭该文件，就像

414
00:20:15,960 --> 00:20:19,530
与 - 每当我们用malloc的东西，
我们要释放的东西，免得我们

415
00:20:19,530 --> 00:20:22,730
有内存泄漏 - 我们希望
关闭我们的文件。

416
00:20:22,730 --> 00:20:28,180
如果该程序没有关闭退出
该文件，赔率是不会有事

417
00:20:28,180 --> 00:20:30,050
错了，特别是如果它
是个小巧的文件。

418
00:20:30,050 --> 00:20:35,020
>> 但肯定是良好的编码风格
实践总是闭上你的文件

419
00:20:35,020 --> 00:20:38,050
当你使用它就完蛋了。

420
00:20:38,050 --> 00:20:43,630
所以这是文件的基本I / O。
你可能已经看到过，或

421
00:20:43,630 --> 00:20:45,710
在这梦幻般的短看着它。

422
00:20:45,710 --> 00:20:48,410
没有任何人有任何疑问，前
我们进入一些练习编码

423
00:20:48,410 --> 00:20:51,800
问题，关于文件I / O或
步骤我刚刚去了？

424
00:20:51,800 --> 00:21:00,198

425
00:21:00,198 --> 00:21:03,162
>> [打字声音]

426
00:21:03,162 --> 00:21:04,150
>> JASON HIRSCHHORN：你
有一个问题，AVI？

427
00:21:04,150 --> 00:21:04,660
>> AVI：号

428
00:21:04,660 --> 00:21:04,740
>> JASON HIRSCHHORN：确定。

429
00:21:04,740 --> 00:21:06,746
我打算再等
7秒。

430
00:21:06,746 --> 00:21:07,590
[笑]

431
00:21:07,590 --> 00:21:08,620
这是一个非常好的提示。

432
00:21:08,620 --> 00:21:10,750
你们就是不喜欢
问这问那。

433
00:21:10,750 --> 00:21:11,660
这很好。

434
00:21:11,660 --> 00:21:12,330
确定。

435
00:21:12,330 --> 00:21:17,620
所以，我们的第一个实践的问题是，我们是
要复制的功能

436
00:21:17,620 --> 00:21:22,330
一个命令行工具，你可能
副本 - 前使用 - 

437
00:21:22,330 --> 00:21:23,500
复制工具。

438
00:21:23,500 --> 00:21:28,050
如果您键入CP，然后传递两个
参数传递到你的终端，你可以

439
00:21:28,050 --> 00:21:28,980
复制文件。

440
00:21:28,980 --> 00:21:31,220
而这正是我们要
到现在写的。

441
00:21:31,220 --> 00:21:35,830
>> 所以，再一次，读了这张幻灯片中，我倒是
你写一个程序，需要

442
00:21:35,830 --> 00:21:38,130
二，只有两个命令行
论据 - 

443
00:21:38,130 --> 00:21:40,750
源文件和目标文件 - 

444
00:21:40,750 --> 00:21:44,590
并复制源中的内容
文件复制到目标文件

445
00:21:44,590 --> 00:21:46,960
1字节的时间。

446
00:21:46,960 --> 00:21:48,510
所以这是一个很多要求。

447
00:21:48,510 --> 00:21:52,200
>> 同样，一个好方法，这是对
没有直奔C代码，但

448
00:21:52,200 --> 00:21:54,280
把它分解成几个步骤。

449
00:21:54,280 --> 00:21:58,400
首先，想想逻辑 - 正是
就是我要问你做 - 

450
00:21:58,400 --> 00:22:00,620
并了解所有的
步骤对这个问题。

451
00:22:00,620 --> 00:22:04,410
不是在C中，只是在一些伪代码，
或者甚至是心理模型

452
00:22:04,410 --> 00:22:06,030
这是怎么回事。

453
00:22:06,030 --> 00:22:10,050
>> 接下来，一旦你有伪下来，
弄清楚如何的伪代码

454
00:22:10,050 --> 00:22:14,600
地图上的工具和事情，我们已经
学会了在C使用

455
00:22:14,600 --> 00:22:19,070
>> 最后，一​​旦你把所有的
在一起，你可以编写问题。

456
00:22:19,070 --> 00:22:23,370
需要5到10分钟，以
在这个问题上工作。

457
00:22:23,370 --> 00:22:25,800
我把说明书
备份在第二。

458
00:22:25,800 --> 00:22:27,990
然后我们要去投奔
的伪代码，和代码

459
00:22:27,990 --> 00:22:29,230
它生活作为一个群体。

460
00:22:29,230 --> 00:22:31,640
>> 如果您有任何问题，而你
这方面的工作，可以自由地提高

461
00:22:31,640 --> 00:22:34,260
你的手，我会来
周围并回答他们。

462
00:22:34,260 --> 00:22:37,020

463
00:22:37,020 --> 00:22:39,330
>> 学生7：我可以刷卡
一张纸？

464
00:22:39,330 --> 00:22:41,537
>> JASON HIRSCHHORN：这是怎么回事？

465
00:22:41,537 --> 00:26:46,047

466
00:26:46,047 --> 00:26:48,043
>> [打字声音]

467
00:26:48,043 --> 00:26:48,730
>> JASON HIRSCHHORN：确定。

468
00:26:48,730 --> 00:26:51,710
让我们在第一伪代码，和
然后我给你一对夫妇更

469
00:26:51,710 --> 00:26:52,960
分钟完成编码。

470
00:26:52,960 --> 00:26:55,540

471
00:26:55,540 --> 00:26:58,650
>> 谁愿意开始我关闭
与第一线

472
00:26:58,650 --> 00:27:00,030
伪代码这个功能呢？

473
00:27:00,030 --> 00:27:03,330

474
00:27:03,330 --> 00:27:05,740
>> 学生8：检查以确保
给您提供两个文件。

475
00:27:05,740 --> 00:27:06,990
>> JASON HIRSCHHORN：确定。

476
00:27:06,990 --> 00:27:21,270

477
00:27:21,270 --> 00:27:22,990
如果我们不是？

478
00:27:22,990 --> 00:27:25,974
>> 学生8：我将返回0。

479
00:27:25,974 --> 00:27:27,872
>> JASON HIRSCHHORN：我们是否应该返回0？

480
00:27:27,872 --> 00:27:30,182
>> 学生8：返回一个 - 

481
00:27:30,182 --> 00:27:30,650
消隐。

482
00:27:30,650 --> 00:27:30,850
抱歉。

483
00:27:30,850 --> 00:27:31,210
>> JASON HIRSCHHORN：是啊。

484
00:27:31,210 --> 00:27:32,710
可能不为0。

485
00:27:32,710 --> 00:27:34,680
因为0表示一切都很好。

486
00:27:34,680 --> 00:27:35,030
确定。

487
00:27:35,030 --> 00:27:36,730
所以这是第一行
的伪代码。

488
00:27:36,730 --> 00:27:38,715
谁拥有伪代码的第二行？

489
00:27:38,715 --> 00:27:40,630
>> 学生9：打开这两个文件？

490
00:27:40,630 --> 00:27:41,880
>> JASON HIRSCHHORN：打开这两个文件。

491
00:27:41,880 --> 00:27:49,970

492
00:27:49,970 --> 00:27:50,920
好不好？

493
00:27:50,920 --> 00:27:52,850
>> 学生10：检查
如果该文件是否为NULL？

494
00:27:52,850 --> 00:28:10,906

495
00:28:10,906 --> 00:28:12,580
>> JASON HIRSCHHORN：检查并
肯定也不是NULL。

496
00:28:12,580 --> 00:28:15,800
顺便说一句 - 

497
00:28:15,800 --> 00:28:17,540
斜线0  - 

498
00:28:17,540 --> 00:28:18,887
是空？

499
00:28:18,887 --> 00:28:20,080
>> 学生11：第

500
00:28:20,080 --> 00:28:21,190
>> JASON HIRSCHHORN：这是不是NULL。

501
00:28:21,190 --> 00:28:23,400
这就是所谓的NULL结束。

502
00:28:23,400 --> 00:28:25,580
它实际上是拼写只有一个湖

503
00:28:25,580 --> 00:28:28,580
所以，检查针对的东西是 - 
这实际上是一个字 - 

504
00:28:28,580 --> 00:28:31,710
因此检查针对的东西是
不一样的检查，看它是否

505
00:28:31,710 --> 00:28:32,690
等于NULL。

506
00:28:32,690 --> 00:28:34,100
>> 有的人 - 

507
00:28:34,100 --> 00:28:36,040
在他们的测验和他们的问题
套 - 已经得到了

508
00:28:36,040 --> 00:28:36,890
二那些混淆。

509
00:28:36,890 --> 00:28:38,830
但其中的两个是
其实不同。

510
00:28:38,830 --> 00:28:40,220
一个结尾的字符串 - 

511
00:28:40,220 --> 00:28:43,210
1是一个指针为0。

512
00:28:43,210 --> 00:28:46,490
>> 学生12：你为什么不检查
确保该文件是不是NULL

513
00:28:46,490 --> 00:28:48,670
你打开它们之前？

514
00:28:48,670 --> 00:28:54,772
>> JASON HIRSCHHORN：所以节省开
一些在该文件中。

515
00:28:54,772 --> 00:28:57,780
如果你去回到这里 - 

516
00:28:57,780 --> 00:28:59,520
所以这条线 -  FOPEN  - 

517
00:28:59,520 --> 00:29:05,300
会给你一个地址和存储
在文件中的地址，如果它的工作原理。

518
00:29:05,300 --> 00:29:07,650
如果它不工作，它
将存储NULL  - 

519
00:29:07,650 --> 00:29:08,020
>> 学生12：哦。

520
00:29:08,020 --> 00:29:08,180
确定。

521
00:29:08,180 --> 00:29:08,500
得了你。

522
00:29:08,500 --> 00:29:09,050
>> JASON HIRSCHHORN：在文件中。

523
00:29:09,050 --> 00:29:11,990
所以，你可以不检查是否为NULL
你打开它们。

524
00:29:11,990 --> 00:29:13,520
NULL表示什么都没有
正常工作。

525
00:29:13,520 --> 00:29:18,030

526
00:29:18,030 --> 00:29:18,740
确定。

527
00:29:18,740 --> 00:29:22,590
因此，检查，以确保两者都不是？

528
00:29:22,590 --> 00:29:23,200
或者是？

529
00:29:23,200 --> 00:29:23,770
我们会怎么想？

530
00:29:23,770 --> 00:29:24,310
我们将一起去了。

531
00:29:24,310 --> 00:29:24,520
>> 学生13：是。

532
00:29:24,520 --> 00:29:25,020
>> JASON HIRSCHHORN：是？

533
00:29:25,020 --> 00:29:25,930
两者都不是？

534
00:29:25,930 --> 00:29:26,350
>> 学生13：是。

535
00:29:26,350 --> 00:29:26,390
>> JASON HIRSCHHORN：确定。

536
00:29:26,390 --> 00:29:28,510
我们似乎有一些
在这种共识。

537
00:29:28,510 --> 00:29:30,520
无论是NULL。

538
00:29:30,520 --> 00:29:32,250
OK，伪代码的下一行。

539
00:29:32,250 --> 00:29:33,600
谁没有给我行了吗？

540
00:29:33,600 --> 00:29:37,350

541
00:29:37,350 --> 00:29:38,295
我们会等你的。

542
00:29:38,295 --> 00:29:39,020
是啊。

543
00:29:39,020 --> 00:29:40,895
>> 学生14：您必须阅读
从第一个文件？

544
00:29:40,895 --> 00:29:42,290
>> JASON HIRSCHHORN：确定。

545
00:29:42,290 --> 00:29:46,240
>> 学生14：或者我们用fscanf和
类似的东西，第一个文件？

546
00:29:46,240 --> 00:29:50,650
>> JASON HIRSCHHORN：因此，我们要
从第一个文件中读取和 - 

547
00:29:50,650 --> 00:29:51,900
让我们把这种权利在这里。

548
00:29:51,900 --> 00:30:00,600

549
00:30:00,600 --> 00:30:01,880
读取源文件。

550
00:30:01,880 --> 00:30:05,370
然后，就在我们我们做什么
从源文件中读取？

551
00:30:05,370 --> 00:30:06,620
别人？

552
00:30:06,620 --> 00:30:09,150

553
00:30:09,150 --> 00:30:12,190
>> 学生15：写入到
目标文件？

554
00:30:12,190 --> 00:30:22,080

555
00:30:22,080 --> 00:30:25,620
>> JASON HIRSCHHORN：我们写
目标文件，以及 - 

556
00:30:25,620 --> 00:30:26,210
确定。

557
00:30:26,210 --> 00:30:30,030
是我们缺少什么？

558
00:30:30,030 --> 00:30:32,460
其他人谁没有给我一个
代码行了 - 伪代码。

559
00:30:32,460 --> 00:30:33,510
是啊。

560
00:30:33,510 --> 00:30:36,540
>> 学生16：也许你可以随时查询
是否有东西可以读，

561
00:30:36,540 --> 00:30:37,970
就像下一行？

562
00:30:37,970 --> 00:30:39,550
这就像下一行，
看它是否存在。

563
00:30:39,550 --> 00:30:40,660
>> [电子提示音]

564
00:30:40,660 --> 00:30:41,095
>> JASON HIRSCHHORN：哎呀。

565
00:30:41,095 --> 00:30:43,120
这是我的日记软件。

566
00:30:43,120 --> 00:30:43,580
是吗？

567
00:30:43,580 --> 00:30:44,960
>> 学生16：是啊。

568
00:30:44,960 --> 00:30:48,940
>> JASON HIRSCHHORN：所以给
它给我更多的时间。

569
00:30:48,940 --> 00:30:51,640
>> 学生16：检查是否有
从静止的下一行

570
00:30:51,640 --> 00:30:52,920
源文件中读取。

571
00:30:52,920 --> 00:30:53,500
>> JASON HIRSCHHORN：确定。

572
00:30:53,500 --> 00:30:56,060
因此，我们不读线 - 
这里被读取字节 - 

573
00:30:56,060 --> 00:30:57,590
但你是正确的。

574
00:30:57,590 --> 00:31:00,040
我们要读取和写入，直到
有没有更多的字节。

575
00:31:00,040 --> 00:31:11,430

576
00:31:11,430 --> 00:31:11,735
确定。

577
00:31:11,735 --> 00:31:16,940
等等这些真正应该缩进
有点，因为他们在那里。

578
00:31:16,940 --> 00:31:17,470
对不对？

579
00:31:17,470 --> 00:31:20,620
直到我们出的字节，我们要
从源文件读取和写入

580
00:31:20,620 --> 00:31:22,160
到目标文件。

581
00:31:22,160 --> 00:31:24,510
>> 然后，什么是最后的
伪代码的行？

582
00:31:24,510 --> 00:31:26,380
谁不给谁的
我的东西呢。

583
00:31:26,380 --> 00:31:29,270

584
00:31:29,270 --> 00:31:30,260
>> 学生17：关闭文件？

585
00:31:30,260 --> 00:31:31,510
>> JASON HIRSCHHORN：没错。

586
00:31:31,510 --> 00:31:36,370

587
00:31:36,370 --> 00:31:37,450
关闭文件。

588
00:31:37,450 --> 00:31:38,400
所以这是我们的伪代码。

589
00:31:38,400 --> 00:31:41,870
我打算把伪代码为
gedit的，并在一两分钟我们

590
00:31:41,870 --> 00:31:44,626
将共同编写的。

591
00:31:44,626 --> 00:33:55,280

592
00:33:55,280 --> 00:33:56,000
>> 确定。

593
00:33:56,000 --> 00:33:58,290
让我们开始为一组。

594
00:33:58,290 --> 00:33:59,940
NISHANT，我有我的新文件。

595
00:33:59,940 --> 00:34:01,130
我刚刚开了这家了。

596
00:34:01,130 --> 00:34:01,880
无标题文档1。

597
00:34:01,880 --> 00:34:05,490
什么是我应该做的第一件事？

598
00:34:05,490 --> 00:34:07,040
>> NISHANT：包括库？

599
00:34:07,040 --> 00:34:08,219
>> JASON HIRSCHHORN：确定。

600
00:34:08,219 --> 00:34:11,070
哪些图书馆？

601
00:34:11,070 --> 00:34:17,570
>> NISHANT：stdio.h中，stdlib.h中，我相信？

602
00:34:17,570 --> 00:34:18,000
>> JASON HIRSCHHORN：确定。

603
00:34:18,000 --> 00:34:21,592
什么是stdlib的呢？

604
00:34:21,592 --> 00:34:23,010
>> NISHANT：我忘了。

605
00:34:23,010 --> 00:34:23,219
>> JASON HIRSCHHORN：确定。

606
00:34:23,219 --> 00:34:24,179
因此，包括标准输入输出。

607
00:34:24,179 --> 00:34:28,630
我应该怎么做，甚至在
我开始编码？

608
00:34:28,630 --> 00:34:29,710
>> NISHANT：写一个头？

609
00:34:29,710 --> 00:34:31,830
>> JASON HIRSCHHORN：如何
我把它上色？

610
00:34:31,830 --> 00:34:34,060
>> [插VOICES]

611
00:34:34,060 --> 00:34:35,040
>> NISHANT：你怎么得到它的颜色？

612
00:34:35,040 --> 00:34:38,060
>> JASON HIRSCHHORN：如何
我的颜色编码？

613
00:34:38,060 --> 00:34:38,570
>> NISHANT：我不知道。

614
00:34:38,570 --> 00:34:38,830
呵呵。

615
00:34:38,830 --> 00:34:39,389
保存。

616
00:34:39,389 --> 00:34:39,929
>> JASON HIRSCHHORN：保存。

617
00:34:39,929 --> 00:34:40,270
是。

618
00:34:40,270 --> 00:34:41,760
我应该将其保存为。角

619
00:34:41,760 --> 00:34:46,239
因此，将它保存在桌面的cp.c.上

620
00:34:46,239 --> 00:34:47,280
甜蜜。

621
00:34:47,280 --> 00:34:51,199
如果我想要得到完整的风格
点，我应该怎么

622
00:34:51,199 --> 00:34:53,085
包括在顶部？

623
00:34:53,085 --> 00:34:58,390
>> NISHANT：你可以写你的名字，名字
该程序，并且该目的的

624
00:34:58,390 --> 00:34:59,640
方案呢？

625
00:34:59,640 --> 00:35:08,400

626
00:35:08,400 --> 00:35:10,040
>> JASON HIRSCHHORN：看起来不错。

627
00:35:10,040 --> 00:35:10,470
优秀的。

628
00:35:10,470 --> 00:35:12,940
所以，你已经开始了我们完美的。

629
00:35:12,940 --> 00:35:13,720
＃包括 - 

630
00:35:13,720 --> 00:35:15,365
我们也写 - 

631
00:35:15,365 --> 00:35:30,050

632
00:35:30,050 --> 00:35:30,870
确定。

633
00:35:30,870 --> 00:35:33,520
所以，我想我所有的设置去。

634
00:35:33,520 --> 00:35:38,003
谁拥有的第一行代码对我来说 - 
或代码的第一行是

635
00:35:38,003 --> 00:35:41,280
这将需要满足我们的第一个
在伪代码有何评论？

636
00:35:41,280 --> 00:35:41,985
您。

637
00:35:41,985 --> 00:35:48,780
>> 学生18：难道不应该是int
ARGC，然后字符* argv的？

638
00:35:48,780 --> 00:35:49,490
>> JASON HIRSCHHORN：我觉得
你说得对。

639
00:35:49,490 --> 00:35:56,270
让我们来改变它为int主，开括号，
整型的argc，逗号，字符* argv的？

640
00:35:56,270 --> 00:35:57,150
喜欢吗？

641
00:35:57,150 --> 00:35:57,410
>> 学生18：括号。

642
00:35:57,410 --> 00:35:58,260
>> JASON HIRSCHHORN：括号。

643
00:35:58,260 --> 00:35:59,860
打开支架，接近支架，
接近父母。

644
00:35:59,860 --> 00:36:00,240
完美的。

645
00:36:00,240 --> 00:36:02,160
现在，我可以带命令行参数。

646
00:36:02,160 --> 00:36:02,430
确定。

647
00:36:02,430 --> 00:36:04,250
确保我们给出两个文件。

648
00:36:04,250 --> 00:36:07,905
你可以给我说，好。

649
00:36:07,905 --> 00:36:09,180
>> 学生18：如果ARGC  - 

650
00:36:09,180 --> 00:36:11,060
这其中不等于3。

651
00:36:11,060 --> 00:36:14,360
>> JASON HIRSCHHORN：如果开括号
的argc不等于3？

652
00:36:14,360 --> 00:36:16,970
>> 学生18：是啊，你回
1或任何东西。

653
00:36:16,970 --> 00:36:17,460
>> JASON HIRSCHHORN：对不起。

654
00:36:17,460 --> 00:36:19,120
>> 学生18：返回1或任​​何东西。

655
00:36:19,120 --> 00:36:20,270
>> JASON HIRSCHHORN：返回1。

656
00:36:20,270 --> 00:36:22,230
好不好？

657
00:36:22,230 --> 00:36:22,970
大。

658
00:36:22,970 --> 00:36:24,290
打开这两个文件。

659
00:36:24,290 --> 00:36:26,160
谁可以帮我打开这两个文件？

660
00:36:26,160 --> 00:36:28,125
谁没有给我的代码吗？

661
00:36:28,125 --> 00:36:31,510

662
00:36:31,510 --> 00:36:32,320
库尔特？

663
00:36:32,320 --> 00:36:36,145
>> KURT：所以全部大写F-Ⅰ-L-E星源。

664
00:36:36,145 --> 00:36:39,390

665
00:36:39,390 --> 00:36:40,920
>> JASON HIRSCHHORN：我要去
取出元音。

666
00:36:40,920 --> 00:36:41,570
这些都是很酷的。

667
00:36:41,570 --> 00:36:42,716
这就像QQ空间分享。

668
00:36:42,716 --> 00:36:44,610
>> 学生18：等于FOPEN  - 

669
00:36:44,610 --> 00:36:46,612
>> JASON HIRSCHHORN：等于FOPEN？

670
00:36:46,612 --> 00:36:49,870
>> 学生18：开括号，
argv的，开放的支架。

671
00:36:49,870 --> 00:36:50,055
>> JASON HIRSCHHORN：等待。

672
00:36:50,055 --> 00:36:50,240
抱歉。

673
00:36:50,240 --> 00:36:51,050
开括号。

674
00:36:51,050 --> 00:36:51,456
确定。

675
00:36:51,456 --> 00:36:53,080
>> 学生18：是啊。

676
00:36:53,080 --> 00:36:55,110
ARGV子1。

677
00:36:55,110 --> 00:36:55,860
>> JASON HIRSCHHORN：子1？

678
00:36:55,860 --> 00:36:56,140
>> 学生18：是啊。

679
00:36:56,140 --> 00:36:58,540
argv的开放式支架1  - 

680
00:36:58,540 --> 00:36:59,730
是。

681
00:36:59,730 --> 00:37:06,470
然后逗号，然后开双
报价河，双引号，

682
00:37:06,470 --> 00:37:08,250
接近括号，分号。

683
00:37:08,250 --> 00:37:09,450
>> JASON HIRSCHHORN：甜。

684
00:37:09,450 --> 00:37:10,950
又是怎么回事另外一个？

685
00:37:10,950 --> 00:37:16,030
>> 学生18：十分相似，而是
S-R-C中，你会称之为D-S-T。

686
00:37:16,030 --> 00:37:17,060
>> JASON HIRSCHHORN：哦哦！

687
00:37:17,060 --> 00:37:17,772
我喜欢这样。

688
00:37:17,772 --> 00:37:20,010
>> 学生18：只要D-S-T。是啊。

689
00:37:20,010 --> 00:37:23,057
然后的argv，打开支架，2。

690
00:37:23,057 --> 00:37:23,200
是啊。

691
00:37:23,200 --> 00:37:26,720
然后瓦特，而不是河

692
00:37:26,720 --> 00:37:27,620
是啊。

693
00:37:27,620 --> 00:37:29,630
>> JASON HIRSCHHORN：太好了。

694
00:37:29,630 --> 00:37:31,360
接下来几行。

695
00:37:31,360 --> 00:37:34,040
另外，如果有人有事情要添加到
我们所做的线条，随意

696
00:37:34,040 --> 00:37:35,690
添加这些为好。

697
00:37:35,690 --> 00:37:37,520
检查以确保既不为NULL。

698
00:37:37,520 --> 00:37:41,450
谁可以给我我需要的代码
满足该行伪代码的？

699
00:37:41,450 --> 00:37:44,430

700
00:37:44,430 --> 00:37:45,870
弓箭手。

701
00:37:45,870 --> 00:37:58,645
>> ARCHER：如果SRC等于等于
NULL或DST等于等于

702
00:37:58,645 --> 00:38:04,590
NULL，则返回 - 

703
00:38:04,590 --> 00:38:07,130

704
00:38:07,130 --> 00:38:07,976
>> JASON HIRSCHHORN：什么？

705
00:38:07,976 --> 00:38:08,890
>> ARCHER：返回2？

706
00:38:08,890 --> 00:38:09,760
>> JASON HIRSCHHORN：返回2。

707
00:38:09,760 --> 00:38:14,400
所以，如果开括号的src等于
等于NULL，或者 - 

708
00:38:14,400 --> 00:38:15,590
不管这thing's  - 管？

709
00:38:15,590 --> 00:38:16,346
管？

710
00:38:16,346 --> 00:38:17,140
我们会打电话给它管。

711
00:38:17,140 --> 00:38:22,340
管材，管件，DST等于等于
NULL，则返回2。

712
00:38:22,340 --> 00:38:23,900
好不好？

713
00:38:23,900 --> 00:38:26,060
直到我们出的字节 - 

714
00:38:26,060 --> 00:38:29,820
我们有点跳过此步骤
伪代码部分将在这里。

715
00:38:29,820 --> 00:38:31,970
>> 但是，直到我们出的字节 - 
这是什么样的声音？

716
00:38:31,970 --> 00:38:34,680
什么C的结构类型 - 

717
00:38:34,680 --> 00:38:36,160
但我不使用这个词的结构，
因为我们要开始使用

718
00:38:36,160 --> 00:38:37,350
在其他情况下 - 

719
00:38:37,350 --> 00:38:39,495
但C刀这听起来像不像？

720
00:38:39,495 --> 00:38:39,970
>> 学生19：一个循环。

721
00:38:39,970 --> 00:38:40,980
>> JASON HIRSCHHORN：一个循环。

722
00:38:40,980 --> 00:38:43,060
听起来像是一个循环。

723
00:38:43,060 --> 00:38:49,670
那么，谁可以给我的第一行
的循环代码就在这里？

724
00:38:49,670 --> 00:38:56,320

725
00:38:56,320 --> 00:39:01,980
您也可以选择什么样的
循环你想，如果你给我

726
00:39:01,980 --> 00:39:03,215
这行代码。

727
00:39:03,215 --> 00:39:04,150
有三种。

728
00:39:04,150 --> 00:39:06,530
你来挑。

729
00:39:06,530 --> 00:39:08,080
我会建议其中之一。

730
00:39:08,080 --> 00:39:08,410
阿维。

731
00:39:08,410 --> 00:39:09,230
哪一个你想要什么？

732
00:39:09,230 --> 00:39:09,960
>> AVI：FOR。

733
00:39:09,960 --> 00:39:11,460
>> JASON HIRSCHHORN：FOR。

734
00:39:11,460 --> 00:39:15,180
>> AVI：INT I等于零。

735
00:39:15,180 --> 00:39:17,360
>> JASON HIRSCHHORN：确定。

736
00:39:17,360 --> 00:39:18,570
>> AVI：这部分我不知道。

737
00:39:18,570 --> 00:39:29,080
但i小于大小
星源？

738
00:39:29,080 --> 00:39:31,128
我不知道这一点。

739
00:39:31,128 --> 00:39:32,580
>> JASON HIRSCHHORN：确定。

740
00:39:32,580 --> 00:39:35,870
>> AVI：因为你想要的
一个文件的大小，对不对？

741
00:39:35,870 --> 00:39:41,090
>> JASON HIRSCHHORN：那么这可能不会
给我们的实际大小

742
00:39:41,090 --> 00:39:43,010
文件中的字节。

743
00:39:43,010 --> 00:39:47,680
所以，我们还有什么可以做？

744
00:39:47,680 --> 00:39:48,810
这是另一种类型的循环？

745
00:39:48,810 --> 00:39:50,180
还是应该坚持使用FOR循环？

746
00:39:50,180 --> 00:39:55,350

747
00:39:55,350 --> 00:39:57,900
>> 学生20：你能不能做一个WHILE循环？

748
00:39:57,900 --> 00:40:01,350
然后，你会做的是you'd  - 

749
00:40:01,350 --> 00:40:03,930
因为我们有一个char *的文件。

750
00:40:03,930 --> 00:40:07,950
所以，如果我们只是一味的递增
直到我们会发现在NULL字符

751
00:40:07,950 --> 00:40:08,500
它的结束？

752
00:40:08,500 --> 00:40:11,130
或者没有，是不是文件如何工作的？

753
00:40:11,130 --> 00:40:14,300
>> JASON HIRSCHHORN：所以我们可以保持
递增的char *

754
00:40:14,300 --> 00:40:16,340
直到我们找到空 - 

755
00:40:16,340 --> 00:40:18,580
>> 学生20：从本质上继续前进
逐字符，直到我们打

756
00:40:18,580 --> 00:40:21,250
该文件的末尾。

757
00:40:21,250 --> 00:40:21,600
>> JASON HIRSCHHORN：是的。

758
00:40:21,600 --> 00:40:22,560
所以，这就是我们想要做的。

759
00:40:22,560 --> 00:40:24,545
我们要坚持读书，性格
由字符，直到我们得到

760
00:40:24,545 --> 00:40:25,080
该文件的末尾。

761
00:40:25,080 --> 00:40:25,375
>> 学生20：是啊。

762
00:40:25,375 --> 00:40:25,860
发现 - 

763
00:40:25,860 --> 00:40:28,540
什么是结束或停止的迹象
在一个文本文件的末尾。

764
00:40:28,540 --> 00:40:28,620
>> JASON HIRSCHHORN：确定。

765
00:40:28,620 --> 00:40:30,140
所以，当我们到达文件的末尾 - 
我们怎么知道我们已经达到

766
00:40:30,140 --> 00:40:33,200
一个文件的末尾？

767
00:40:33,200 --> 00:40:34,710
如果我打电话 - 

768
00:40:34,710 --> 00:40:35,910
所以让我们退一步。

769
00:40:35,910 --> 00:40:37,550
什么是函数？

770
00:40:37,550 --> 00:40:39,360
让我们去这条线就在这里。

771
00:40:39,360 --> 00:40:40,630
读取源文件。

772
00:40:40,630 --> 00:40:41,880
谁可以给我那行代码？

773
00:40:41,880 --> 00:40:45,592

774
00:40:45,592 --> 00:40:47,590
>> 学生21：的fscanf？

775
00:40:47,590 --> 00:40:49,110
>> JASON HIRSCHHORN：的fscanf。

776
00:40:49,110 --> 00:40:49,510
确定。

777
00:40:49,510 --> 00:40:52,240
如果我想读什么，很
具体而言，1字节？

778
00:40:52,240 --> 00:40:55,012

779
00:40:55,012 --> 00:40:56,860
>> 学生21：我不知道。

780
00:40:56,860 --> 00:40:57,110
>> JASON HIRSCHHORN：确定。

781
00:40:57,110 --> 00:40:59,380
甚至比的fscanf简单 - 什么是 - 

782
00:40:59,380 --> 00:41:01,890
我想从一个源文件中读取？

783
00:41:01,890 --> 00:41:03,720
读取源文件。

784
00:41:03,720 --> 00:41:04,850
什么是函数 - 是啊。

785
00:41:04,850 --> 00:41:05,380
>> 学生22：这是用fread？

786
00:41:05,380 --> 00:41:06,070
>> JASON HIRSCHHORN：FREAD。

787
00:41:06,070 --> 00:41:07,550
我认为让我们坚持使用
那一个现在。

788
00:41:07,550 --> 00:41:10,380

789
00:41:10,380 --> 00:41:13,650
什么样的参数
并用fread走？

790
00:41:13,650 --> 00:41:17,410
>> 学生22：可能的文件类型，
然后在文件中的位置？

791
00:41:17,410 --> 00:41:19,550
>> JASON HIRSCHHORN：我可以在这里输入
要弄清楚什么类型的参数

792
00:41:19,550 --> 00:41:20,950
FREAD需要？

793
00:41:20,950 --> 00:41:23,710
>> 多名学生：人的fread。

794
00:41:23,710 --> 00:41:24,740
>> JASON HIRSCHHORN：男性
fread和fwrite的。

795
00:41:24,740 --> 00:41:25,980
看起来他们一起挂出。

796
00:41:25,980 --> 00:41:29,589
所以用fread需要多少个参数？

797
00:41:29,589 --> 00:41:30,920
>> 学生23：四。

798
00:41:30,920 --> 00:41:32,690
>> JASON HIRSCHHORN：这需要
四个参数。

799
00:41:32,690 --> 00:41:41,100
它需要一个指针，一个大小，而
的事情，这是奇怪的，和一些文件。

800
00:41:41,100 --> 00:41:42,000
好不好？

801
00:41:42,000 --> 00:41:43,990
让我们看一下这里。

802
00:41:43,990 --> 00:41:49,370
“函数fread显示为N MEMB
数据元素，每个元素的字节大小

803
00:41:49,370 --> 00:41:53,840
长，从流指向
流，将它们存储在该位置

804
00:41:53,840 --> 00:41:56,170
通过指针发出。“

805
00:41:56,170 --> 00:41:57,960
>> 所以四个参数。

806
00:41:57,960 --> 00:42:04,510
为什么不让我只是复制这个，
，并将其粘贴在这里。

807
00:42:04,510 --> 00:42:10,060

808
00:42:10,060 --> 00:42:10,770
确定。

809
00:42:10,770 --> 00:42:13,673
那么，谁可以开始填写
这些论点对我？

810
00:42:13,673 --> 00:42:15,840
阿维。

811
00:42:15,840 --> 00:42:17,720
>> AVI：取出无效。

812
00:42:17,720 --> 00:42:20,530
把刚刚SRC。

813
00:42:20,530 --> 00:42:23,142
取出指针和明星。

814
00:42:23,142 --> 00:42:26,102
把src中。

815
00:42:26,102 --> 00:42:27,050
然后 - 

816
00:42:27,050 --> 00:42:28,500
>> JASON HIRSCHHORN：所以我打算停止
你在那里，因为这是不正确。

817
00:42:28,500 --> 00:42:32,590

818
00:42:32,590 --> 00:42:34,710
你说得对与SRC，但是
应该在哪里SRC去了？

819
00:42:34,710 --> 00:42:35,960
>> [插VOICES]

820
00:42:35,960 --> 00:42:38,976

821
00:42:38,976 --> 00:42:41,610
>> JASON HIRSCHHORN：应该
走在这里。

822
00:42:41,610 --> 00:42:43,790
这就是SRC  - 我们的src是一个类型。

823
00:42:43,790 --> 00:42:44,610
让我们来看看这里。

824
00:42:44,610 --> 00:42:49,610
这要求一个类型FILE *，我们
其实平时看到他们这样。

825
00:42:49,610 --> 00:42:57,630
因此，这是要求的参数
类型的文件名为*流为src。

826
00:42:57,630 --> 00:42:58,480
好不好？

827
00:42:58,480 --> 00:43:00,410
>> 事情做大小
我们要读？

828
00:43:00,410 --> 00:43:03,340
我在给你这
问题说明。

829
00:43:03,340 --> 00:43:04,370
>> 学生24：一次一个字节。

830
00:43:04,370 --> 00:43:05,340
>> JASON HIRSCHHORN：一个字节。

831
00:43:05,340 --> 00:43:08,205
多大是一个字节？

832
00:43:08,205 --> 00:43:11,642
它的大小是以字节为单位，还等什么
我可以把在那里？

833
00:43:11,642 --> 00:43:12,910
>> 学生25：一。

834
00:43:12,910 --> 00:43:14,730
>> JASON HIRSCHHORN：一。

835
00:43:14,730 --> 00:43:17,020
右。

836
00:43:17,020 --> 00:43:19,940
它的大小是在单位字节，
所以1是1个字节。

837
00:43:19,940 --> 00:43:22,284
有多少我想读的时间。

838
00:43:22,284 --> 00:43:23,520
>> 学生26：一？

839
00:43:23,520 --> 00:43:24,270
>> JASON HIRSCHHORN：一件事。

840
00:43:24,270 --> 00:43:28,540
我想读的大小一件事
1，一咬的时间。

841
00:43:28,540 --> 00:43:32,110
和我在哪里把它，一旦我读它？

842
00:43:32,110 --> 00:43:35,050

843
00:43:35,050 --> 00:43:36,510
>> 学生27：目的地？

844
00:43:36,510 --> 00:43:39,270
>> JASON HIRSCHHORN：所以我不能把
它直接进入目的地。

845
00:43:39,270 --> 00:43:40,800
>> 学生28：你会放
它到第三指针？

846
00:43:40,800 --> 00:43:41,780
>> 学生27：到了目的地。

847
00:43:41,780 --> 00:43:42,270
>> JASON HIRSCHHORN：确定。

848
00:43:42,270 --> 00:43:42,630
是啊。

849
00:43:42,630 --> 00:43:46,820
>> 学生29：你可以声明某事
作为一个临时存储较早。

850
00:43:46,820 --> 00:43:47,350
>> JASON HIRSCHHORN：确定。

851
00:43:47,350 --> 00:43:50,080
给我说。

852
00:43:50,080 --> 00:43:53,930
>> 学生29：另一个文件
指针，也许？

853
00:43:53,930 --> 00:43:54,220
>> JASON HIRSCHHORN：确定。

854
00:43:54,220 --> 00:43:55,585
因此，这是无效的明星 - 

855
00:43:55,585 --> 00:43:57,750
它是一个void类型的明星，所以也没有
必须是一个文件指针。

856
00:43:57,750 --> 00:44:02,520
如果我在读一个字节，
那里将是一个不错的地方

857
00:44:02,520 --> 00:44:03,850
存储一个字节？

858
00:44:03,850 --> 00:44:04,660
>> 学生29：一个数组？

859
00:44:04,660 --> 00:44:05,770
>> JASON HIRSCHHORN：一个数组。

860
00:44:05,770 --> 00:44:07,730
确定。

861
00:44:07,730 --> 00:44:14,040
还有什么是值得的
确切大小一个字节？

862
00:44:14,040 --> 00:44:16,980

863
00:44:16,980 --> 00:44:18,060
>> 学生30：一个char *？

864
00:44:18,060 --> 00:44:18,530
>> 学生29：是啊。

865
00:44:18,530 --> 00:44:19,880
>> JASON HIRSCHHORN：一个char *
不是一个字节。

866
00:44:19,880 --> 00:44:20,440
>> 学生29：一个字符。

867
00:44:20,440 --> 00:44:21,810
>> JASON HIRSCHHORN：一个char是一个字节。

868
00:44:21,810 --> 00:44:22,920
对不对？

869
00:44:22,920 --> 00:44:26,740
因此，让我们称这个缓冲区是一个通用的
名称用于这些东西存储

870
00:44:26,740 --> 00:44:27,910
一些暂时的。

871
00:44:27,910 --> 00:44:30,880
所以我创建了一个缓冲区。

872
00:44:30,880 --> 00:44:31,150
对不对？

873
00:44:31,150 --> 00:44:32,990
但它确实需要一个void *。

874
00:44:32,990 --> 00:44:38,660
因此，也许你是对的，它
应该是大小为0的缓冲区。

875
00:44:38,660 --> 00:44:41,070
因此，它存储一个 - 

876
00:44:41,070 --> 00:44:41,280
右。

877
00:44:41,280 --> 00:44:43,560
>> 因为在这里权利 - 炭
缓冲器是一个字符，但

878
00:44:43,560 --> 00:44:45,110
这需要一个void *  - 

879
00:44:45,110 --> 00:44:45,870
一个指针。

880
00:44:45,870 --> 00:44:50,640
所以我可以做到这一点，现在
缓冲器是一个指针。

881
00:44:50,640 --> 00:44:53,214
我还能做什么？

882
00:44:53,214 --> 00:44:55,775
>> 学生31：把为char未来的明星。

883
00:44:55,775 --> 00:44:58,380
>> JASON HIRSCHHORN：我可以
创建它的char *。

884
00:44:58,380 --> 00:45:00,216
确定。

885
00:45:00,216 --> 00:45:03,131
什么是另一回事，我能怎么办？

886
00:45:03,131 --> 00:45:04,050
还是让我们一起去这一个。

887
00:45:04,050 --> 00:45:05,740
字符*缓冲区，所以什么
我摆在这里？

888
00:45:05,740 --> 00:45:08,290

889
00:45:08,290 --> 00:45:09,310
>> 学生31：缓冲区。

890
00:45:09,310 --> 00:45:10,560
>> JASON HIRSCHHORN：缓冲区。

891
00:45:10,560 --> 00:45:12,640

892
00:45:12,640 --> 00:45:14,500
缓冲区是一个指针，指向一个char。

893
00:45:14,500 --> 00:45:19,480
并在该位置，我们把
的东西，我们已经读取一个字节。

894
00:45:19,480 --> 00:45:19,980
是啊。

895
00:45:19,980 --> 00:45:20,700
阿维。

896
00:45:20,700 --> 00:45:21,230
>> AVI：只是一个快速的问题。

897
00:45:21,230 --> 00:45:24,440
你想用malloc缓冲？

898
00:45:24,440 --> 00:45:25,930
>> JASON HIRSCHHORN：谁能
回答这个问题？

899
00:45:25,930 --> 00:45:30,210
>> 学生32：嗯，它并不真正的
点任何东西的权利，所以 - 

900
00:45:30,210 --> 00:45:32,610
>> JASON HIRSCHHORN：但是做
我们想用malloc呢？

901
00:45:32,610 --> 00:45:35,600
>> 学生32：如果你是这样做的
这样，我想，是啊，因为你需要

902
00:45:35,600 --> 00:45:36,990
一些地方为它指向。

903
00:45:36,990 --> 00:45:38,350
>> JASON HIRSCHHORN：我们
必须用malloc呢？

904
00:45:38,350 --> 00:45:40,580
>> 学生33：如果你要
使用它的环的外侧。

905
00:45:40,580 --> 00:45:42,524
>> JASON HIRSCHHORN：我们是否要
使用它的循环之外？

906
00:45:42,524 --> 00:45:44,392
>> 学生34：是的。

907
00:45:44,392 --> 00:45:44,860
>> 学生35：等待。

908
00:45:44,860 --> 00:45:46,980
难道我们要声明它
在环路以外？

909
00:45:46,980 --> 00:45:50,100
>> JASON HIRSCHHORN：所以我想我们有
在这里，我们是一些伪WHILE循环

910
00:45:50,100 --> 00:45:51,950
想弄清楚，那
我们还没有得到到呢。

911
00:45:51,950 --> 00:45:54,710

912
00:45:54,710 --> 00:45:56,010
我们不需要将malloc它。

913
00:45:56,010 --> 00:45:59,310
我们的主要工作时，它一定会
要使用这个循环中。

914
00:45:59,310 --> 00:46:00,540
它不需要存在
超出此。

915
00:46:00,540 --> 00:46:02,340
>> 因此，它可以是一个局部变量。

916
00:46:02,340 --> 00:46:03,925
你有一个指针
一个局部变量。

917
00:46:03,925 --> 00:46:07,984

918
00:46:07,984 --> 00:46:09,590
>> 学生36：但它不是
指向任何东西。

919
00:46:09,590 --> 00:46:11,540
>> JASON HIRSCHHORN：不，这不是
初始化为任何东西。

920
00:46:11,540 --> 00:46:12,790
但我们不打算使用它也。

921
00:46:12,790 --> 00:46:15,300
我们要装上去
这是我们第一次使用它。

922
00:46:15,300 --> 00:46:16,580
所以，似乎确定。

923
00:46:16,580 --> 00:46:17,780
所以我们这里不需要的malloc。

924
00:46:17,780 --> 00:46:19,360
我认为这是确定不变。

925
00:46:19,360 --> 00:46:24,350

926
00:46:24,350 --> 00:46:25,790
确定。

927
00:46:25,790 --> 00:46:27,190
我们是fread线。

928
00:46:27,190 --> 00:46:28,490
让我们做的下一行。

929
00:46:28,490 --> 00:46:32,984
>> 如果我们要写入一个文件，什么是
一个很好的函数用来做呢？

930
00:46:32,984 --> 00:46:33,770
>> 学生37：fwrite的？

931
00:46:33,770 --> 00:46:35,140
>> 学生38：FPRINTF？

932
00:46:35,140 --> 00:46:36,010
>> JASON HIRSCHHORN：是FPRINTF之一。

933
00:46:36,010 --> 00:46:37,260
有什么其它的吗？

934
00:46:37,260 --> 00:46:37,680
>> 学生39：fwrite的。

935
00:46:37,680 --> 00:46:38,510
>> JASON HIRSCHHORN：fwrite的。

936
00:46:38,510 --> 00:46:41,250
而对于我们来说，fwrite的，
我们在这里看到的，是

937
00:46:41,250 --> 00:46:42,500
可能是更好的选择。

938
00:46:42,500 --> 00:46:51,970

939
00:46:51,970 --> 00:46:53,950
它有四个参数为好。

940
00:46:53,950 --> 00:46:57,570
NISHANT，你可以给
我的论点？

941
00:46:57,570 --> 00:47:00,570
>> NISHANT：第一个是怎么回事
是公正的缓冲区。

942
00:47:00,570 --> 00:47:02,210
>> JASON HIRSCHHORN：确定。

943
00:47:02,210 --> 00:47:06,752
>> NISHANT：第二个的
只是要1。

944
00:47:06,752 --> 00:47:09,510
第三个将是1。

945
00:47:09,510 --> 00:47:11,470
而第四个将是DST。

946
00:47:11,470 --> 00:47:18,010

947
00:47:18,010 --> 00:47:19,550
>> JASON HIRSCHHORN：没有任何人有
关于该行的任何问题吗？

948
00:47:19,550 --> 00:47:28,370

949
00:47:28,370 --> 00:47:29,130
这看起来不错。

950
00:47:29,130 --> 00:47:29,590
确定。

951
00:47:29,590 --> 00:47:34,250
所以，现在它看起来像一件事情我们
失踪 - 其实，让我们写

952
00:47:34,250 --> 00:47:35,090
这最后一道防线。

953
00:47:35,090 --> 00:47:36,300
关闭文件。

954
00:47:36,300 --> 00:47:38,880
谁可以完成了我们的写作
这最后的两行？

955
00:47:38,880 --> 00:47:39,120
是。

956
00:47:39,120 --> 00:47:39,850
对不起，你叫什么名字？

957
00:47:39,850 --> 00:47:40,580
>> 露西：露西。

958
00:47:40,580 --> 00:47:41,580
>> JASON HIRSCHHORN：露西。

959
00:47:41,580 --> 00:47:47,560
>> 露西：FCLOSE src和再
FCLOSE目的地。

960
00:47:47,560 --> 00:47:52,430
>> JASON HIRSCHHORN：FCLOSE，开括号，
SRC，关闭括号，分号。

961
00:47:52,430 --> 00:47:53,680
和FCLOSE  - 

962
00:47:53,680 --> 00:47:57,560

963
00:47:57,560 --> 00:47:58,090
是吗？

964
00:47:58,090 --> 00:48:01,710
>> 露西：开括号，DST
然后分号。

965
00:48:01,710 --> 00:48:02,520
>> JASON HIRSCHHORN：太好了。

966
00:48:02,520 --> 00:48:04,338
而且我应该在年底包括哪些内容？

967
00:48:04,338 --> 00:48:05,210
>> 露西：返回0。

968
00:48:05,210 --> 00:48:05,570
>> JASON HIRSCHHORN：返回0。

969
00:48:05,570 --> 00:48:06,820
难道我有什么打算？

970
00:48:06,820 --> 00:48:10,560

971
00:48:10,560 --> 00:48:12,590
只是一个问题。

972
00:48:12,590 --> 00:48:14,957
是否一定要包括返回0？

973
00:48:14,957 --> 00:48:16,240
>> 多名学生：号

974
00:48:16,240 --> 00:48:16,430
>> JASON HIRSCHHORN：号

975
00:48:16,430 --> 00:48:18,090
主要的自动完成
如果你到达终点。

976
00:48:18,090 --> 00:48:20,580
但我认为这是很好的
包括它明确。

977
00:48:20,580 --> 00:48:23,860
特别是当我们返回其他
整个事情的程序。

978
00:48:23,860 --> 00:48:24,810
确定。

979
00:48:24,810 --> 00:48:26,230
这是我们错过了什么 - 

980
00:48:26,230 --> 00:48:28,520
WHILE什么？

981
00:48:28,520 --> 00:48:31,630
谁又能想到一些 - 

982
00:48:31,630 --> 00:48:35,240
有一些感觉是什么东西
能去那里？

983
00:48:35,240 --> 00:48:37,350
即使它只是在一些伪代码
喜欢的语言？

984
00:48:37,350 --> 00:48:41,330
>> 什么是我们真正 - 什么
我们想要去，直到？

985
00:48:41,330 --> 00:48:41,980
是啊，露西。

986
00:48:41,980 --> 00:48:43,240
>> 露西：文件的末尾。

987
00:48:43,240 --> 00:48:44,990
>> JASON HIRSCHHORN：文件的末尾。

988
00:48:44,990 --> 00:48:49,280
所以，你是什么文件到底意味着什么？

989
00:48:49,280 --> 00:48:50,955
>> 露西：一旦你到达
该文件的末尾，停下来。

990
00:48:50,955 --> 00:48:51,240
>> JASON HIRSCHHORN：确定。

991
00:48:51,240 --> 00:48:53,460
所以一旦我们到达文件的末尾。

992
00:48:53,460 --> 00:48:56,893
我们怎么知道什么时候我们已经达到
该文件的末尾？

993
00:48:56,893 --> 00:48:59,900
>> 学生40：我认为缓冲区
将被设置为NULL。

994
00:48:59,900 --> 00:49:01,885
>> 学生41：缓冲区声明
内循环。

995
00:49:01,885 --> 00:49:03,670
>> JASON HIRSCHHORN：所以你认为
缓冲区将被设置为NULL。

996
00:49:03,670 --> 00:49:05,850
为什么缓冲区设置为NULL？

997
00:49:05,850 --> 00:49:10,420
>> 学生40：因为当你
用fread，你试图把

998
00:49:10,420 --> 00:49:13,528
什么到缓冲区。

999
00:49:13,528 --> 00:49:13,980
>> JASON HIRSCHHORN：确定。

1000
00:49:13,980 --> 00:49:15,550
所以，你在想用fread  - 

1001
00:49:15,550 --> 00:49:19,000
当我们已经达到的结束
文件，什么是用fread怎么办呢？

1002
00:49:19,000 --> 00:49:21,230
我认为这是问题
我们必须弄清楚。

1003
00:49:21,230 --> 00:49:21,960
什么是FREAD办？

1004
00:49:21,960 --> 00:49:25,640
它把空的缓冲区，或
它做别的吗？

1005
00:49:25,640 --> 00:49:27,510
我们怎样才能弄清楚它？

1006
00:49:27,510 --> 00:49:28,190
>> 学生42：人。

1007
00:49:28,190 --> 00:49:28,810
>> JASON HIRSCHHORN：人。

1008
00:49:28,810 --> 00:49:32,280
所以，让我们来看看在这里。

1009
00:49:32,280 --> 00:49:34,000
返回值。

1010
00:49:34,000 --> 00:49:39,620
如果成功，fread和fwrite的返回
读出或写入的项目数。

1011
00:49:39,620 --> 00:49:43,700
这个数目等于字节数
转让只有当大小为1。

1012
00:49:43,700 --> 00:49:47,780
如果发生错误，或者在该端
到达文件，返回值是一个

1013
00:49:47,780 --> 00:49:51,490
短期项目数或0。

1014
00:49:51,490 --> 00:49:57,860
>> 所以对于我们来说，如果用fread河段
该文件的末尾，以及从读出

1015
00:49:57,860 --> 00:50:02,100
文件末尾，什么都不剩
阅读，什么是它要回来吗？

1016
00:50:02,100 --> 00:50:03,290
>> 学生43：零？

1017
00:50:03,290 --> 00:50:04,540
>> JASON HIRSCHHORN：什么？

1018
00:50:04,540 --> 00:50:05,300
>> 学生43：零？

1019
00:50:05,300 --> 00:50:05,690
>> JASON HIRSCHHORN：零。

1020
00:50:05,690 --> 00:50:06,940
它会返回零。

1021
00:50:06,940 --> 00:50:09,360

1022
00:50:09,360 --> 00:50:13,010
所以我们知道，用fread，当我们已经
到达文件的结尾，会

1023
00:50:13,010 --> 00:50:13,690
返回零。

1024
00:50:13,690 --> 00:50:17,460
我们怎样才能用它来我们的优势在哪里？

1025
00:50:17,460 --> 00:50:21,733
>> AVI：你可以在外面声明一个变量
所谓单向循环。

1026
00:50:21,733 --> 00:50:27,040
如果检查等于 - 

1027
00:50:27,040 --> 00:50:28,190
现在 - 之一。

1028
00:50:28,190 --> 00:50:28,920
>> JASON HIRSCHHORN：确定。

1029
00:50:28,920 --> 00:50:38,050
>> AVI：然后你可以把一个IF
之后用fread说，如果声明

1030
00:50:38,050 --> 00:50:42,600
用fread等于零 - 

1031
00:50:42,600 --> 00:50:43,850
没有。

1032
00:50:43,850 --> 00:50:46,002

1033
00:50:46,002 --> 00:50:47,252
>> JASON HIRSCHHORN：谁
可以帮助阿维出来？

1034
00:50:47,252 --> 00:50:49,690

1035
00:50:49,690 --> 00:50:52,410
>> AVI：什么是价值
通过用fread返回？

1036
00:50:52,410 --> 00:50:54,060
>> JASON HIRSCHHORN：我们只是
走过去的。

1037
00:50:54,060 --> 00:50:55,450
>> AVI：你怎么表示呢？

1038
00:50:55,450 --> 00:50:57,190
>> JASON HIRSCHHORN：所以它返回 - 让我们
期待在这里 - 它返回一个

1039
00:50:57,190 --> 00:50:59,340
为size_t，它实质上是
的整数。

1040
00:50:59,340 --> 00:51:02,240

1041
00:51:02,240 --> 00:51:03,410
因此，它返回一个整数。

1042
00:51:03,410 --> 00:51:05,160
而在我们的例子中，它会
返回1或0  - 

1043
00:51:05,160 --> 00:51:08,760
1，如果它读一件事 - 一个字节，
和0，如果我们已经走到了尽头。

1044
00:51:08,760 --> 00:51:13,560

1045
00:51:13,560 --> 00:51:16,450
所以，如果用fread  - 

1046
00:51:16,450 --> 00:51:16,855
是吗？

1047
00:51:16,855 --> 00:51:20,330
>> 学生45：你不能只是把全
用fread（缓冲液，1，1，SRC）进

1048
00:51:20,330 --> 00:51:21,660
while循环？

1049
00:51:21,660 --> 00:51:26,510
>> JASON HIRSCHHORN：所以你建议
这样做有进入这个？

1050
00:51:26,510 --> 00:51:27,600
>> [插VOICES]

1051
00:51:27,600 --> 00:51:29,520
>> JASON HIRSCHHORN：等一下。

1052
00:51:29,520 --> 00:51:30,885
因此，我们摆脱这一点。

1053
00:51:30,885 --> 00:51:33,300
所以你建议把
用fread到那里？

1054
00:51:33,300 --> 00:51:35,457
我们应该怎么也动
如果你想这样做？

1055
00:51:35,457 --> 00:51:36,740
>> 学生45：缓冲区以外。

1056
00:51:36,740 --> 00:51:38,110
>> JASON HIRSCHHORN：我们应该
也可以移动这个在这里。

1057
00:51:38,110 --> 00:51:41,700
>> 学生45：但这是否不断
向前移动？

1058
00:51:41,700 --> 00:51:42,950
>> [插VOICES]

1059
00:51:42,950 --> 00:51:46,540

1060
00:51:46,540 --> 00:51:47,470
>> JASON HIRSCHHORN：确定。

1061
00:51:47,470 --> 00:51:50,570
因此，这是Okshar建议。

1062
00:51:50,570 --> 00:51:51,930
我们创建缓冲区。

1063
00:51:51,930 --> 00:51:57,020
我们WHILE的fread，那么我们fwrite的。

1064
00:51:57,020 --> 00:51:59,760
对此怎么看？

1065
00:51:59,760 --> 00:52:04,050
>> 学生46：我唯一的问题是，会
它实际上执行命令的fread？

1066
00:52:04,050 --> 00:52:06,175
>> JASON HIRSCHHORN：大问题。

1067
00:52:06,175 --> 00:52:11,050
当你把一个函数调用
的条件里面，这是否

1068
00:52:11,050 --> 00:52:12,300
函数调用执行？

1069
00:52:12,300 --> 00:52:15,760

1070
00:52:15,760 --> 00:52:17,770
我们以前见过这样的例子。

1071
00:52:17,770 --> 00:52:24,900

1072
00:52:24,900 --> 00:52:25,660
对不对？

1073
00:52:25,660 --> 00:52:26,125
>> 学生46：确定。

1074
00:52:26,125 --> 00:52:26,590
是啊。

1075
00:52:26,590 --> 00:52:30,140
所以它确实执行。

1076
00:52:30,140 --> 00:52:31,790
>> JASON HIRSCHHORN：我们已经看到的东西
像之前，我们有一个

1077
00:52:31,790 --> 00:52:33,550
的条件里面的函数调用。

1078
00:52:33,550 --> 00:52:35,540
这是否函数调用执行？

1079
00:52:35,540 --> 00:52:36,350
是。

1080
00:52:36,350 --> 00:52:37,410
因此，答案是肯定的。

1081
00:52:37,410 --> 00:52:41,010
此函数调用将被执行。

1082
00:52:41,010 --> 00:52:42,418
但同样，这是我们想要的吗？

1083
00:52:42,418 --> 00:52:49,250

1084
00:52:49,250 --> 00:52:52,204
>> 什么是我们可以计算的一种方法
它是否是我们想要的吗？

1085
00:52:52,204 --> 00:52:53,470
>> 多名学生：运行呢？

1086
00:52:53,470 --> 00:52:54,460
>> JASON HIRSCHHORN：我们可以运行它。

1087
00:52:54,460 --> 00:52:57,500
但在此之前，我们做到这一点，我们可以
也有理由通过这一点。

1088
00:52:57,500 --> 00:52:57,920
如果 - 

1089
00:52:57,920 --> 00:53:01,920
说我们有一个字节我们
文件中，我们会得到在这里，

1090
00:53:01,920 --> 00:53:02,660
我们会得到这个代码。

1091
00:53:02,660 --> 00:53:03,620
这将运行。

1092
00:53:03,620 --> 00:53:07,780
用fread将返回一个字节，
将其存储在缓冲器中。

1093
00:53:07,780 --> 00:53:11,290
这将评估为1，
右，后，他返回1。

1094
00:53:11,290 --> 00:53:12,640
>> 因此，尽管1。

1095
00:53:12,640 --> 00:53:15,325
这是否意味着里面的代码
WHILE循环将执行？

1096
00:53:15,325 --> 00:53:15,453
>> 学生47：是啊。

1097
00:53:15,453 --> 00:53:16,040
这是真的。

1098
00:53:16,040 --> 00:53:16,290
>> JASON HIRSCHHORN：是的。

1099
00:53:16,290 --> 00:53:17,490
图1是真实的。

1100
00:53:17,490 --> 00:53:18,240
这不是0。

1101
00:53:18,240 --> 00:53:20,360
所以，在这里里面的代码将被执行。

1102
00:53:20,360 --> 00:53:22,300
因此，我们将编写一个。

1103
00:53:22,300 --> 00:53:25,340
我们将回迁到这个
行一次。

1104
00:53:25,340 --> 00:53:26,850
现在，我们有 - 

1105
00:53:26,850 --> 00:53:28,550
我们是在我们的文件的末尾。

1106
00:53:28,550 --> 00:53:30,980
我们从文件末尾读，
因为我们只有一个字节在里面。

1107
00:53:30,980 --> 00:53:34,270
>> 用fread返回0，门店
东西在缓冲区中。

1108
00:53:34,270 --> 00:53:35,890
老实说，我不知道是什么
它存储在缓冲区中。

1109
00:53:35,890 --> 00:53:38,380
我们也许可以仰望
来看看它做什么。

1110
00:53:38,380 --> 00:53:40,130
我真的不知道。

1111
00:53:40,130 --> 00:53:43,090
我们不知道，谁在乎什么
它在缓冲存储？

1112
00:53:43,090 --> 00:53:44,010
但它确实返回0。

1113
00:53:44,010 --> 00:53:45,440
并同时0执行？

1114
00:53:45,440 --> 00:53:49,950

1115
00:53:49,950 --> 00:53:51,180
>> WHILE 0将不会执行。

1116
00:53:51,180 --> 00:53:54,030
所以后来我们就搬到这里了。

1117
00:53:54,030 --> 00:53:58,870
因此，让我们一举手，如果这
是我们应该运行，或者如果我们的代码

1118
00:53:58,870 --> 00:54:00,140
首先应该做的改变。

1119
00:54:00,140 --> 00:54:02,180
所以，如果你想 - 你必须投票。

1120
00:54:02,180 --> 00:54:06,885
如果您认为我们应该运行这个代码
原样，请举手。

1121
00:54:06,885 --> 00:54:12,440

1122
00:54:12,440 --> 00:54:13,400
>> 确定。

1123
00:54:13,400 --> 00:54:14,315
还有一个 - 

1124
00:54:14,315 --> 00:54:17,260
你有一个问题，关注？

1125
00:54:17,260 --> 00:54:18,080
是啊。

1126
00:54:18,080 --> 00:54:21,240
>> 学生48：当我们移动缓冲区
在循环之外，我们做

1127
00:54:21,240 --> 00:54:22,670
必须用malloc呢？

1128
00:54:22,670 --> 00:54:23,310
>> JASON HIRSCHHORN：大问题。

1129
00:54:23,310 --> 00:54:26,670
当我们移动的外部缓冲
循环，我们必须用malloc呢？

1130
00:54:26,670 --> 00:54:28,400
这是一个范围的问题。

1131
00:54:28,400 --> 00:54:32,130
如果我们初始化缓冲区外
这个循环的，将它存在

1132
00:54:32,130 --> 00:54:33,534
内循环的？

1133
00:54:33,534 --> 00:54:35,230
>> 多名学生：是的。

1134
00:54:35,230 --> 00:54:35,580
>> JASON HIRSCHHORN：是的。

1135
00:54:35,580 --> 00:54:40,100
其范围涵盖了循环内，
和，真的，里面的东西在它下面

1136
00:54:40,100 --> 00:54:42,460
这个代码，包括中
这里里面的东西。

1137
00:54:42,460 --> 00:54:43,930
所以我们并不需要用malloc它。

1138
00:54:43,930 --> 00:54:47,766
这是一个局部变量，其范围
还包括循环。

1139
00:54:47,766 --> 00:54:49,540
>> 学生49：我们是否需要释放呢？

1140
00:54:49,540 --> 00:54:51,770
>> JASON HIRSCHHORN：我们
需要空闲缓冲区？

1141
00:54:51,770 --> 00:54:53,860
>> 学生49：是的，如果我们不这样做的malloc。

1142
00:54:53,860 --> 00:54:55,750
>> JASON HIRSCHHORN：我们
需要空闲缓冲区？

1143
00:54:55,750 --> 00:54:57,160
我们不知道。

1144
00:54:57,160 --> 00:55:01,280
再次，这是一个局部变量，
所以我们并不需要释放它。

1145
00:55:01,280 --> 00:55:02,170
确定。

1146
00:55:02,170 --> 00:55:03,480
让我们看看会发生什么。

1147
00:55:03,480 --> 00:55:17,290

1148
00:55:17,290 --> 00:55:18,220
因此，它是未初始化的。

1149
00:55:18,220 --> 00:55:20,830
那是什么东西，
马库斯较早前建议。

1150
00:55:20,830 --> 00:55:25,340
因此，我们有这个错误，变量缓冲区
这里使用的时候被初始化。

1151
00:55:25,340 --> 00:55:26,590
>> 怎样才能解决这个问题？

1152
00:55:26,590 --> 00:55:29,460

1153
00:55:29,460 --> 00:55:30,960
>> 学生5​​0：malloc的呢？

1154
00:55:30,960 --> 00:55:31,770
>> 学生5​​1：等于null？

1155
00:55:31,770 --> 00:55:33,000
>> 学生5​​2：假设缓冲区的值等于NULL。

1156
00:55:33,000 --> 00:55:34,250
>> JASON HIRSCHHORN：确定。

1157
00:55:34,250 --> 00:55:40,040

1158
00:55:40,040 --> 00:55:40,770
看起来不错。

1159
00:55:40,770 --> 00:55:42,410
我们现在拥有它。

1160
00:55:42,410 --> 00:55:45,630
让我们创建一些尝试复制。

1161
00:55:45,630 --> 00:56:08,990

1162
00:56:08,990 --> 00:56:10,490
因此，我们有我们的文本文件。

1163
00:56:10,490 --> 00:56:11,740
我们怎样才能运行这个程序？

1164
00:56:11,740 --> 00:56:14,140

1165
00:56:14,140 --> 00:56:15,472
是啊。

1166
00:56:15,472 --> 00:56:22,230
>> 学生5​​3：你可以做点
斜线CP，test.txt的。

1167
00:56:22,230 --> 00:56:25,140
然后你就可以指定任何其他文件
它会存储到。

1168
00:56:25,140 --> 00:56:25,510
>> JASON HIRSCHHORN：确定。

1169
00:56:25,510 --> 00:56:27,380
我们叫它out.txt的。

1170
00:56:27,380 --> 00:56:28,630
酷？

1171
00:56:28,630 --> 00:56:31,700

1172
00:56:31,700 --> 00:56:34,320
赛格故障。

1173
00:56:34,320 --> 00:56:35,570
思考的赛格故障？

1174
00:56:35,570 --> 00:56:40,900

1175
00:56:40,900 --> 00:56:41,390
这是伟大的。

1176
00:56:41,390 --> 00:56:45,040
我们怎样才能找出
赛格故障？

1177
00:56:45,040 --> 00:56:45,680
什么？

1178
00:56:45,680 --> 00:56:45,990
>> 学生5​​4：GDB。

1179
00:56:45,990 --> 00:56:47,240
>> JASON HIRSCHHORN：GDB。

1180
00:56:47,240 --> 00:56:51,400

1181
00:56:51,400 --> 00:56:55,300
我们运行gdb的写点gdb的斜线，
我们的程序的名称。

1182
00:56:55,300 --> 00:56:57,020
没有命令行参数那里。

1183
00:56:57,020 --> 00:56:59,570
我们将设置一个
断点为主。

1184
00:56:59,570 --> 00:57:02,190
如果我想启动gdb，我该怎么办？

1185
00:57:02,190 --> 00:57:02,730
>> 学生5​​5：R。

1186
00:57:02,730 --> 00:57:08,910
>> JASON HIRSCHHORN：R.然后呢？

1187
00:57:08,910 --> 00:57:09,400
>> 学生5​​5：该参数呢？

1188
00:57:09,400 --> 00:57:10,650
>> JASON HIRSCHHORN：然后，
命令行参数。

1189
00:57:10,650 --> 00:57:15,890

1190
00:57:15,890 --> 00:57:17,120
让我们通过。

1191
00:57:17,120 --> 00:57:19,090
N的只是把我一行一行。

1192
00:57:19,090 --> 00:57:21,450
我会去，直到
我让我的赛格故障。

1193
00:57:21,450 --> 00:57:22,700
还有我的赛格故障。

1194
00:57:22,700 --> 00:57:24,960

1195
00:57:24,960 --> 00:57:27,875
它看起来像用fread引起
我的赛格故障。

1196
00:57:27,875 --> 00:57:30,570

1197
00:57:30,570 --> 00:57:32,770
我知道用fread引起我的赛格故障，
因为这是

1198
00:57:32,770 --> 00:57:34,950
行，我们只是执行。

1199
00:57:34,950 --> 00:57:36,530
>> 而那是唯一
发生在该行 - 

1200
00:57:36,530 --> 00:57:37,520
两件事情都发生了。

1201
00:57:37,520 --> 00:57:40,610
FREAD要去，然后我们
做一些检查时。

1202
00:57:40,610 --> 00:57:44,820
我敢打赌，在WHILE
检查并没有引起我的赛格故障。

1203
00:57:44,820 --> 00:57:46,950
最有可能的，是FREAD
造成我的赛格故障。

1204
00:57:46,950 --> 00:57:49,260
我也看到一些东西在这里，存储器复制。

1205
00:57:49,260 --> 00:57:50,500
>> 内存拷贝。

1206
00:57:50,500 --> 00:57:53,820
听起来像移动存储
一个位置移动到另一个。

1207
00:57:53,820 --> 00:57:56,890
听起来似乎会发生
在用fread，也许有些记忆

1208
00:57:56,890 --> 00:57:58,910
从这里搬到这里。

1209
00:57:58,910 --> 00:58:01,740

1210
00:58:01,740 --> 00:58:03,860
让我们通过这一次。

1211
00:58:03,860 --> 00:58:06,900
我如何在启动它
并再次运行它？

1212
00:58:06,900 --> 00:58:08,092
是啊。

1213
00:58:08,092 --> 00:58:15,140
>> 学生5​​6：你需要把
缓冲区之前的符号？

1214
00:58:15,140 --> 00:58:17,800
>> JASON HIRSCHHORN：所以在与符号
缓冲会给我的地址

1215
00:58:17,800 --> 00:58:22,330
缓冲，这是一个char *。

1216
00:58:22,330 --> 00:58:25,250
让我们通过这一次运行。

1217
00:58:25,250 --> 00:58:28,248
我如何通过它运行一次吗？

1218
00:58:28,248 --> 00:58:29,210
>> 学生5​​7：你能刚
再键入run？

1219
00:58:29,210 --> 00:58:32,050
>> JASON HIRSCHHORN：只需再次键入运行。

1220
00:58:32,050 --> 00:58:33,415
因此，我们不打算
执行这条线。

1221
00:58:33,415 --> 00:58:36,250

1222
00:58:36,250 --> 00:58:39,240
因此，缓冲区是一个NULL指针。

1223
00:58:39,240 --> 00:58:40,490
正确吗？

1224
00:58:40,490 --> 00:58:45,870

1225
00:58:45,870 --> 00:58:47,060
它指向 - 让我们来看看。

1226
00:58:47,060 --> 00:58:48,500
如果我们有我们 - 

1227
00:58:48,500 --> 00:58:50,430
画出这是一个快速的画面。

1228
00:58:50,430 --> 00:58:53,500
大家可以看看
我写在这里？

1229
00:58:53,500 --> 00:59:02,890
>> 因此堆栈中，我们有一个本地
变量，它被称为缓冲液，并

1230
00:59:02,890 --> 00:59:08,230
它是一个指针，指向一个char。

1231
00:59:08,230 --> 00:59:10,325
什么地址是这个字符的？

1232
00:59:10,325 --> 00:59:12,550
>> 学生5​​8：0X0。

1233
00:59:12,550 --> 00:59:13,400
>> JASON HIRSCHHORN：对。

1234
00:59:13,400 --> 00:59:14,200
那这是什么。

1235
00:59:14,200 --> 00:59:17,600
在这里，内部缓冲区，存储0X0。

1236
00:59:17,600 --> 00:59:20,480
这就是我们所拥有的 - 的
安装我们现在所拥有的。

1237
00:59:20,480 --> 00:59:27,540
所以这条线，用fread，把东西
从源代码在哪里？

1238
00:59:27,540 --> 00:59:30,560
这个框或此框？

1239
00:59:30,560 --> 00:59:31,060
这盒？

1240
00:59:31,060 --> 00:59:33,290
左框或右边的框中？

1241
00:59:33,290 --> 00:59:34,750
这项权利箱。

1242
00:59:34,750 --> 00:59:38,440
>> 它遵循的指针，
并把它放在这里。

1243
00:59:38,440 --> 00:59:42,620
当我们在尝试和触摸记忆
位置0，我们得到什么？

1244
00:59:42,620 --> 00:59:45,050
分段错误。

1245
00:59:45,050 --> 00:59:46,550
这就是我们现在所拥有的错误。

1246
00:59:46,550 --> 00:59:46,970
是啊。

1247
00:59:46,970 --> 00:59:48,410
>> 学生5​​9：你不是有
把明星缓冲？

1248
00:59:48,410 --> 00:59:49,180
还是没有？

1249
00:59:49,180 --> 00:59:50,050
对于FREAD？

1250
00:59:50,050 --> 00:59:51,450
>> JASON HIRSCHHORN：所以用fread
需要一个指针。

1251
00:59:51,450 --> 00:59:54,920

1252
00:59:54,920 --> 00:59:55,900
因此它在缓冲传递。

1253
00:59:55,900 --> 00:59:58,980
然后它会去参考
它里面的某个地方的fread。

1254
00:59:58,980 --> 01:00:00,700
但是再一次，我们看到，它需要一个指针。

1255
01:00:00,700 --> 01:00:02,560
我们并不需要把它star缓冲。

1256
01:00:02,560 --> 01:00:05,350
这将是路过
它无论是在这里。

1257
01:00:05,350 --> 01:00:07,980
而这将可能给我们一个错误
因为我们去引用它。

1258
01:00:07,980 --> 01:00:08,150
>> 对不对？

1259
01:00:08,150 --> 01:00:10,690
当我们去引用这个指针，当
我们试图访问这个位置，

1260
01:00:10,690 --> 01:00:13,140
我们得到一个错误 - 
我们的分段错误。

1261
01:00:13,140 --> 01:00:15,800
所以 - 

1262
01:00:15,800 --> 01:00:16,690
哎呀。

1263
01:00:16,690 --> 01:00:19,090
我们要退出了GDB的。

1264
01:00:19,090 --> 01:00:20,160
我们的产品线 - 

1265
01:00:20,160 --> 01:00:22,990
我们的问题 - 是正确的
这里在这条线。

1266
01:00:22,990 --> 01:00:26,410
这是一个问题，因为
的这一行。

1267
01:00:26,410 --> 01:00:31,780
>> 我们怎样才能创建一个框，
访问中的fread。

1268
01:00:31,780 --> 01:00:31,980
对不对？

1269
01:00:31,980 --> 01:00:35,190
我们需要创建一个框的One
字节大，一个char的大小。

1270
01:00:35,190 --> 01:00:38,590
但是，我们需要这个盒子是可访问
当这个函数执行。

1271
01:00:38,590 --> 01:00:39,390
那么， - 

1272
01:00:39,390 --> 01:00:39,640
是的。

1273
01:00:39,640 --> 01:00:40,440
任何想法？

1274
01:00:40,440 --> 01:00:43,615
>> 学生60：只需将其设置为
任何随机字符。

1275
01:00:43,615 --> 01:00:49,150

1276
01:00:49,150 --> 01:00:51,640
只是做字符缓冲区的equals
的字符。

1277
01:00:51,640 --> 01:00:53,795
然后，当你已经缓冲那里 - 

1278
01:00:53,795 --> 01:00:54,110
>> JASON HIRSCHHORN：等待。

1279
01:00:54,110 --> 01:00:55,110
字符缓冲区？

1280
01:00:55,110 --> 01:00:55,880
因此，没有明星？

1281
01:00:55,880 --> 01:00:56,390
>> 学生60：是啊。

1282
01:00:56,390 --> 01:00:58,560
取出的明星。

1283
01:00:58,560 --> 01:01:00,690
等于一个随机字符。

1284
01:01:00,690 --> 01:01:01,460
>> JASON HIRSCHHORN：确定。

1285
01:01:01,460 --> 01:01:02,420
所以给我一个。

1286
01:01:02,420 --> 01:01:03,170
>> 学生60：像什么的。

1287
01:01:03,170 --> 01:01:06,160
然后当你有缓冲
在那里，你用 - 

1288
01:01:06,160 --> 01:01:06,420
>> 学生61：星？

1289
01:01:06,420 --> 01:01:07,650
哦，不，连字符。

1290
01:01:07,650 --> 01:01:09,000
>> 学生60：使用符号。

1291
01:01:09,000 --> 01:01:09,470
>> JASON HIRSCHHORN：确定。

1292
01:01:09,470 --> 01:01:11,320
和什么有关fwrite的？

1293
01:01:11,320 --> 01:01:14,150
>> 学生60：再次使用该符号。

1294
01:01:14,150 --> 01:01:14,320
>> JASON HIRSCHHORN：好吧。

1295
01:01:14,320 --> 01:01:20,970
所以，你的想法是，我们创建了一个char和
装上去，然后

1296
01:01:20,970 --> 01:01:22,612
写入该字符。

1297
01:01:22,612 --> 01:01:23,760
>> 学生60：是啊。

1298
01:01:23,760 --> 01:01:25,916
>> JASON HIRSCHHORN：什么
人们认为呢？

1299
01:01:25,916 --> 01:01:27,770
>> 学生62：这是令人费解。

1300
01:01:27,770 --> 01:01:28,460
>> JASON HIRSCHHORN：确定。

1301
01:01:28,460 --> 01:01:29,760
让我们把它画出来。

1302
01:01:29,760 --> 01:01:35,720
所以这一次，我要在此画
红色栈这里，然后我们

1303
01:01:35,720 --> 01:01:36,410
将有 - 

1304
01:01:36,410 --> 01:01:36,822
哦！

1305
01:01:36,822 --> 01:01:38,060
抱歉。

1306
01:01:38,060 --> 01:01:45,930
所以这个时候，我们有一些所谓
缓冲器，它是在栈上。

1307
01:01:45,930 --> 01:01:48,430
正确吗？

1308
01:01:48,430 --> 01:01:51,520
而我们在保存它，最初。

1309
01:01:51,520 --> 01:01:53,830
>> 然后，我们有我们要的fread调用。

1310
01:01:53,830 --> 01:02:01,300
它是需要一个字节从什么用fread
我们的文件，并把它的地方。

1311
01:02:01,300 --> 01:02:04,570
它把它在无论
事情的指向。

1312
01:02:04,570 --> 01:02:09,130
好了，我们有这个地址之前 - 

1313
01:02:09,130 --> 01:02:10,250
0X0。

1314
01:02:10,250 --> 01:02:13,349
现在，我们有什么地址？

1315
01:02:13,349 --> 01:02:14,650
>> 学生63：无论
地址缓冲区。

1316
01:02:14,650 --> 01:02:15,970
>> JASON HIRSCHHORN：无论
地址缓冲区。

1317
01:02:15,970 --> 01:02:22,370
它可能会是
类似的东西。

1318
01:02:22,370 --> 01:02:26,950
可能将开始与b和
一个f，然后让其他六个

1319
01:02:26,950 --> 01:02:27,970
十六进制数字。

1320
01:02:27,970 --> 01:02:28,480
没关系。

1321
01:02:28,480 --> 01:02:29,470
一些地址。

1322
01:02:29,470 --> 01:02:31,410
我们正在通过该地址英寸

1323
01:02:31,410 --> 01:02:34,790
>> 我们打​​算把我们的单
字节的东西在那个地址。

1324
01:02:34,790 --> 01:02:38,470
因此，我们打算把我们的单
字节里面的东西在这里。

1325
01:02:38,470 --> 01:02:40,800
然后我们要去从写
什么是内部过这里。

1326
01:02:40,800 --> 01:02:43,425

1327
01:02:43,425 --> 01:02:45,380
没有任何人有任何疑问，
有关？

1328
01:02:45,380 --> 01:02:50,990

1329
01:02:50,990 --> 01:02:54,690
谁认为这代码将工作？

1330
01:02:54,690 --> 01:02:56,020
>> 举起你的手，如果你认为
这段代码将正常工作。

1331
01:02:56,020 --> 01:02:57,270
你必须采取的立场。

1332
01:02:57,270 --> 01:03:00,670

1333
01:03:00,670 --> 01:03:02,500
和谁认为这代码将无法正常工作？

1334
01:03:02,500 --> 01:03:04,610
举起你的手。

1335
01:03:04,610 --> 01:03:06,750
其他人都应该
提高他们的手。

1336
01:03:06,750 --> 01:03:07,670
确定。

1337
01:03:07,670 --> 01:03:09,390
迈克尔，你在哪里站着？

1338
01:03:09,390 --> 01:03:10,680
>> 迈克尔：我不能决定。

1339
01:03:10,680 --> 01:03:12,070
样的在中间。

1340
01:03:12,070 --> 01:03:12,736
>> JASON HIRSCHHORN：你
在中间。

1341
01:03:12,736 --> 01:03:13,092
挑一。

1342
01:03:13,092 --> 01:03:14,400
>> 迈克尔：我有信心
并说，它会奏效。

1343
01:03:14,400 --> 01:03:14,660
>> JASON HIRSCHHORN：确定。

1344
01:03:14,660 --> 01:03:16,047
你有信心，说出来的作品？

1345
01:03:16,047 --> 01:03:26,490

1346
01:03:26,490 --> 01:03:27,020
发生了什么事？

1347
01:03:27,020 --> 01:03:28,270
>> [插VOICES]

1348
01:03:28,270 --> 01:03:35,170

1349
01:03:35,170 --> 01:03:35,950
>> JASON HIRSCHHORN：无赛格故障。

1350
01:03:35,950 --> 01:03:40,320
我们怎样才能检查，看看是否
两件事情都是平等的？

1351
01:03:40,320 --> 01:03:42,060
两个文件都是平等的。

1352
01:03:42,060 --> 01:03:43,300
>> 学生64：没有变化。

1353
01:03:43,300 --> 01:03:45,490
>> JASON HIRSCHHORN：没有变化。

1354
01:03:45,490 --> 01:03:51,630
的diff检查之间的差异
两个文件，​​并且如果它返回

1355
01:03:51,630 --> 01:03:52,890
什么都没有，他们是一致的。

1356
01:03:52,890 --> 01:03:59,030
如果我们打开了，我们得到的文件。

1357
01:03:59,030 --> 01:04:00,490
所以这是正确的解决方案。

1358
01:04:00,490 --> 01:04:01,780
让我们来回顾一下它一次。

1359
01:04:01,780 --> 01:04:04,080
事实上，我们甚至没有
需要对它进行初始化。

1360
01:04:04,080 --> 01:04:05,520
>> 它可能看起来有点
清洁剂，如果你没有把

1361
01:04:05,520 --> 01:04:07,680
随机的东西在里面。

1362
01:04:07,680 --> 01:04:13,070
问题的关键是，你需要创建
一些空间来存放东西从

1363
01:04:13,070 --> 01:04:15,530
fread和拿东西
fwrite的出来的。

1364
01:04:15,530 --> 01:04:18,400
而这件事必须是本地
变量在堆栈上 - 你

1365
01:04:18,400 --> 01:04:19,890
可能已经malloc'd一些空间。

1366
01:04:19,890 --> 01:04:23,030
>> 所以，我们其实可以有
这里写的malloc和

1367
01:04:23,030 --> 01:04:25,420
这将有工作。

1368
01:04:25,420 --> 01:04:28,660
然后我们会一直存储
我们的东西在某处堆上。

1369
01:04:28,660 --> 01:04:31,940
但其实这是，也许，
最优雅的解决方案。

1370
01:04:31,940 --> 01:04:34,490
只是在栈上创建一些空间
为这些事情去了。

1371
01:04:34,490 --> 01:04:37,690

1372
01:04:37,690 --> 01:04:38,990
>> 我有两个其他意见。

1373
01:04:38,990 --> 01:04:44,650
如果你要轮流在这一点，
然后得到得分在此，我的意见

1374
01:04:44,650 --> 01:04:47,400
将如下所示。

1375
01:04:47,400 --> 01:04:54,300
这些1在这里，对我来说，看
像幻数。

1376
01:04:54,300 --> 01:04:56,860
这个1的方法，用fread而言，
有道理。

1377
01:04:56,860 --> 01:04:59,580
这是事物的数量
要读取或写入。

1378
01:04:59,580 --> 01:05:03,740
>> 但是这一次在这里应
也许是别的东西。

1379
01:05:03,740 --> 01:05:05,180
那么，什么是一个解决方案？

1380
01:05:05,180 --> 01:05:06,545
>> 学生65：字节大小。

1381
01:05:06,545 --> 01:05:10,100

1382
01:05:10,100 --> 01:05:11,080
>> JASON HIRSCHHORN：像这样？

1383
01:05:11,080 --> 01:05:13,130
>> 学生65：字符的大小。

1384
01:05:13,130 --> 01:05:13,820
>> JASON HIRSCHHORN：字符的大小。

1385
01:05:13,820 --> 01:05:15,290
是啊，字节是不是一个类型。

1386
01:05:15,290 --> 01:05:16,320
所以，大小字符的作品。

1387
01:05:16,320 --> 01:05:30,270
我们可以有，在顶部
我们的代码，＃定义。

1388
01:05:30,270 --> 01:05:33,410
叫什么BYTE和
这真是一个字符。

1389
01:05:33,410 --> 01:05:37,675
其实，一个更好的办法
可能是这一点 - 

1390
01:05:37,675 --> 01:05:39,391
UINT。

1391
01:05:39,391 --> 01:05:40,780
任何人都知道是什么吗？

1392
01:05:40,780 --> 01:05:44,388

1393
01:05:44,388 --> 01:05:44,840
>> 抱歉。

1394
01:05:44,840 --> 01:05:46,090
我弄错了。

1395
01:05:46,090 --> 01:05:51,620

1396
01:05:51,620 --> 01:05:52,200
等待，没有。

1397
01:05:52,200 --> 01:05:53,450
哪一种方式它走？

1398
01:05:53,450 --> 01:05:58,071

1399
01:05:58,071 --> 01:05:59,660
任何人都知道是什么吗？

1400
01:05:59,660 --> 01:06:00,950
是啊。

1401
01:06:00,950 --> 01:06:05,650
>> 学生67：应该帮助规范
跨系统的东西，

1402
01:06:05,650 --> 01:06:08,760
有 - 像无符号整数
有8个字节？

1403
01:06:08,760 --> 01:06:11,785
>> JASON HIRSCHHORN：这是
完全正确。

1404
01:06:11,785 --> 01:06:14,310
在不同的机器，
一个char的大小 - 

1405
01:06:14,310 --> 01:06:15,180
通常不是一个字符。

1406
01:06:15,180 --> 01:06:16,100
chars通常是一个字节。

1407
01:06:16,100 --> 01:06:19,590
但其他数据类型的大小是
在32位机器上不同大小

1408
01:06:19,590 --> 01:06:21,370
对一个64位的机器。

1409
01:06:21,370 --> 01:06:25,180
一个uint8_t有始终是8位 - 

1410
01:06:25,180 --> 01:06:27,210
总是一个字节。

1411
01:06:27,210 --> 01:06:29,580
>> 我需要包括
标准整型的头文件。

1412
01:06:29,580 --> 01:06:35,040
所以，现在，这将有可能被
写这段代码的最佳方式。

1413
01:06:35,040 --> 01:06:40,160

1414
01:06:40,160 --> 01:06:41,450
所以我摆脱幻数。

1415
01:06:41,450 --> 01:06:44,690
而且我也有一个更符合逻辑
键入缓冲区。

1416
01:06:44,690 --> 01:06:49,450
这不是一个简单的字符，它是一个字节，
这正是我们所期望的那样。

1417
01:06:49,450 --> 01:06:53,400
>> 而在这里，我们实际上已经
一直有点更强大。

1418
01:06:53,400 --> 01:06:55,190
我们不认为它是一个字符，而 - 

1419
01:06:55,190 --> 01:06:58,630
也许，谁知道 - 可能是一个不同的
大小不同的机器上。

1420
01:06:58,630 --> 01:07:02,025
实际上我们说这正是
一个字节，总是，不管是什么。

1421
01:07:02,025 --> 01:07:05,810
如果我们看看在这里，我们做CP。

1422
01:07:05,810 --> 01:07:08,340
嗯，哦。

1423
01:07:08,340 --> 01:07:09,590
发生了什么事？

1424
01:07:09,590 --> 01:07:14,470

1425
01:07:14,470 --> 01:07:16,170
>> 学生68：它可能被切换。

1426
01:07:16,170 --> 01:07:17,880
>> JASON HIRSCHHORN：什么？

1427
01:07:17,880 --> 01:07:19,130
>> 学生69：是吗？

1428
01:07:19,130 --> 01:07:21,940

1429
01:07:21,940 --> 01:07:25,080
>> 学生70：你没有
把它定义为一个类型。

1430
01:07:25,080 --> 01:07:28,684
>> 学生71：但应
在标准中定义。

1431
01:07:28,684 --> 01:07:29,934
>> 学生72：这是怎么回事？

1432
01:07:29,934 --> 01:07:37,660

1433
01:07:37,660 --> 01:07:40,210
>> 学生73：应该定义为是全部大写？

1434
01:07:40,210 --> 01:07:41,370
>> JASON HIRSCHHORN：所以它不是＃定义。

1435
01:07:41,370 --> 01:07:45,490
实际上，在这种情况下，我
要使用typedef。

1436
01:07:45,490 --> 01:07:48,590
因为我们使用它作为
一种类型在一个位置。

1437
01:07:48,590 --> 01:07:51,990
因此，在这种情况下，我们实际上要
的typedef像我们印刷的新型

1438
01:07:51,990 --> 01:07:54,490
字节，并且它实质上是这样。

1439
01:07:54,490 --> 01:07:56,590
这是一个有点不同的比＃定义。

1440
01:07:56,590 --> 01:08:02,740
>> 而现在，我们的代码完美的作品。

1441
01:08:02,740 --> 01:08:05,230
所以，再一次，＃定义需要的东西，
无处不在取代它

1442
01:08:05,230 --> 01:08:06,780
与其他的事情。

1443
01:08:06,780 --> 01:08:07,920
这只是一个宏观 - 

1444
01:08:07,920 --> 01:08:09,420
速记摆脱幻数。

1445
01:08:09,420 --> 01:08:11,360
但在这种情况下，因为我们
使用它作为一个类型 - 

1446
01:08:11,360 --> 01:08:12,180
就在这里 - 

1447
01:08:12,180 --> 01:08:19,880
为了实现这一工作，我们需要
于typedef任何字节。

1448
01:08:19,880 --> 01:08:21,840
>> 而我们定义它在这里。

1449
01:08:21,840 --> 01:08:24,750
这不是一个结构，它实际上
只是一个无符号整数。

1450
01:08:24,750 --> 01:08:27,680
这是一个字节长。

1451
01:08:27,680 --> 01:08:31,910
此代码将在网上和
你们都应该有它现在。

1452
01:08:31,910 --> 01:08:33,830
>> 因此，我们有 - 

1453
01:08:33,830 --> 01:08:34,250
完美 - 

1454
01:08:34,250 --> 01:08:41,359
13分钟向左走
在问题设置5。

1455
01:08:41,359 --> 01:08:44,270
我想通过copy.c一起走，
然后我们将简单地谈一谈

1456
01:08:44,270 --> 01:08:47,120
关于其他部分
问题的设置。

1457
01:08:47,120 --> 01:08:48,899
因此，让我拉起来copy.c.

1458
01:08:48,899 --> 01:09:03,930

1459
01:09:03,930 --> 01:09:08,810
和很酷的事情是，我们实际上已经
已经写了很多这样的代码。

1460
01:09:08,810 --> 01:09:11,180
>> 我们从字面上写的代码只是
来到离开这里时，我是

1461
01:09:11,180 --> 01:09:13,120
我自己写的。

1462
01:09:13,120 --> 01:09:16,990
但是，这是copy.c，形成了基础
对于前两部分

1463
01:09:16,990 --> 01:09:22,340
这个问题对于whodunit.c，设置哪些
你需要写，和resize.c。

1464
01:09:22,340 --> 01:09:27,050
Recover.c，这是第三个和最后
问题集的一部分，是不是

1465
01:09:27,050 --> 01:09:29,529
根据关闭这个文件的。

1466
01:09:29,529 --> 01:09:32,200
>> 你将需要编写一个文件，
我们给你一个模板

1467
01:09:32,200 --> 01:09:34,620
文件中，但它没有任何
做copy.c.

1468
01:09:34,620 --> 01:09:38,675
但是因为copy.c是基础
前两部分中，我们将

1469
01:09:38,675 --> 01:09:42,000
通过它走了，所以你必须
一个良好的感觉是做什么的。

1470
01:09:42,000 --> 01:09:43,640
>> 和意见给予一定的它拿走。

1471
01:09:43,640 --> 01:09:45,120
我们已经写了一些了这一点。

1472
01:09:45,120 --> 01:09:49,220
首先，我们要确保
我们得到三个参数。

1473
01:09:49,220 --> 01:09:50,560
下一步，我们记住的文件名。

1474
01:09:50,560 --> 01:09:52,960
所以我们跳过这一步时，
我们编码我们的事 - 

1475
01:09:52,960 --> 01:09:54,700
当我们的CP。

1476
01:09:54,700 --> 01:09:56,750
但在这里，他们正在做
它有点清洁。

1477
01:09:56,750 --> 01:09:59,350
>> 他们正在检查，以确保
这两个文件都不错，在

1478
01:09:59,350 --> 01:10:00,450
除了打开它们。

1479
01:10:00,450 --> 01:10:04,760
我们写这些代码只是现在，所以我
不会纠缠于这些代码。

1480
01:10:04,760 --> 01:10:09,670
接下来是一些东西，那是专门针对
文件中我们使用的类型而

1481
01:10:09,670 --> 01:10:12,240
是位图文件。

1482
01:10:12,240 --> 01:10:15,660
位图文件有一些元数据
与它们相关联。

1483
01:10:15,660 --> 01:10:20,190
>> 因此，第一个字节计
告诉你有关文件。

1484
01:10:20,190 --> 01:10:23,460
他们不是的颜色
像素中的图像。

1485
01:10:23,460 --> 01:10:25,120
他们告诉你有关文件。

1486
01:10:25,120 --> 01:10:28,220
而如果你通过问题集阅读，
你将有更多的信息

1487
01:10:28,220 --> 01:10:33,100
什么类型的元数据结构
所包含的位图。

1488
01:10:33,100 --> 01:10:39,350
>> 但是，这就是为什么我们有这个第一
设置 - 该代码就在这里。

1489
01:10:39,350 --> 01:10:42,490
我们正在阅读的元数据 - 

1490
01:10:42,490 --> 01:10:45,800
两件元数据 - 文件
头和信息头。

1491
01:10:45,800 --> 01:10:51,030
我们正在检查它的某些部分
确保它是一个真正的位图文件

1492
01:10:51,030 --> 01:10:52,420
然后再继续。

1493
01:10:52,420 --> 01:10:55,470
>> 再次，这些都是细节，我们
现在不需要进入。

1494
01:10:55,470 --> 01:10:57,720
如果你通过问题集阅读，
你就会理解这些。

1495
01:10:57,720 --> 01:11:01,370
长话短说，这些都只是说，
这是一个位图文件，并

1496
01:11:01,370 --> 01:11:02,810
确认。

1497
01:11:02,810 --> 01:11:05,180
>> 接下来，我们正在写那些
到了文件中。

1498
01:11:05,180 --> 01:11:05,660
我们看到，在这里。

1499
01:11:05,660 --> 01:11:06,910
我们正在编写到了指针。

1500
01:11:06,910 --> 01:11:09,260

1501
01:11:09,260 --> 01:11:11,320
下一步，我们确定填充。

1502
01:11:11,320 --> 01:11:15,240
所以，再一次，为的是与特殊性
一个位图文件，一些线路包括

1503
01:11:15,240 --> 01:11:16,840
填充底。

1504
01:11:16,840 --> 01:11:19,000
而如果你通过问题集阅读，
您将了解更多有关填充。

1505
01:11:19,000 --> 01:11:22,330
这是式找到填充。

1506
01:11:22,330 --> 01:11:23,610
>> 重要的是要记住 - 

1507
01:11:23,610 --> 01:11:29,720
当你改变一个位图的大小
文件，填充改变。

1508
01:11:29,720 --> 01:11:31,970
当你改变的大小
文件，填充改变。

1509
01:11:31,970 --> 01:11:34,310
它永远不会是
大于3  - 

1510
01:11:34,310 --> 01:11:36,510
这将是0到3，包容性。

1511
01:11:36,510 --> 01:11:38,930
但是，当你改变的大小
东西，填充改变。

1512
01:11:38,930 --> 01:11:47,100
>> 如果我只有一个像素在该行，我
需要三个填充字节，因为

1513
01:11:47,100 --> 01:11:51,190
每一行必须是四的倍数
在一个位图文件字节长。

1514
01:11:51,190 --> 01:11:56,120
但是，如果我加倍，从一个像素去
其中每两个像素，

1515
01:11:56,120 --> 01:11:59,510
让我们说，是一个字节，那么我需要
两个字节填充，使

1516
01:11:59,510 --> 01:12:00,970
即等于4。

1517
01:12:00,970 --> 01:12:04,200
>> 所以，当我改变的东西的大小，
我需要改变的金额

1518
01:12:04,200 --> 01:12:06,551
填充我有。

1519
01:12:06,551 --> 01:12:08,100
这是否有意义给大家？

1520
01:12:08,100 --> 01:12:12,020

1521
01:12:12,020 --> 01:12:18,720
接下来，我们遍历每一行，
或通过所有行。

1522
01:12:18,720 --> 01:12:21,400
然后我们通过遍历
每行中的每个列。

1523
01:12:21,400 --> 01:12:25,330
我们对待这个点阵图样
一个网格，就像我们对待

1524
01:12:25,330 --> 01:12:26,490
董事会15。

1525
01:12:26,490 --> 01:12:29,200
>> 就像我们对待砖时
我们印在屏幕上。

1526
01:12:29,200 --> 01:12:31,350
行和列的网格。

1527
01:12:31,350 --> 01:12:32,350
那么 - 我们看到了这一点。

1528
01:12:32,350 --> 01:12:33,840
实际上，我们只是编码的。

1529
01:12:33,840 --> 01:12:35,780
我们创造了一些临时存储。

1530
01:12:35,780 --> 01:12:38,710
我们读到在那里，然后
我们写出来。

1531
01:12:38,710 --> 01:12:42,680
这正是我们只是做了。

1532
01:12:42,680 --> 01:12:46,760
>> 接下来，因为我说的每一行
结束在一些填充，我们

1533
01:12:46,760 --> 01:12:48,260
跳过该填充 - 

1534
01:12:48,260 --> 01:12:51,000
旧的填充。

1535
01:12:51,000 --> 01:12:52,630
然后我们重新添加。

1536
01:12:52,630 --> 01:12:55,140
在这种情况下，我们要创建
完全相同的文件。

1537
01:12:55,140 --> 01:12:56,180
我们只是复制它。

1538
01:12:56,180 --> 01:12:57,700
所以，这条线是有点傻。

1539
01:12:57,700 --> 01:12:59,660
我们可以从字面上只是
把填充英寸

1540
01:12:59,660 --> 01:13:04,290
>> 但是，如果你改变了文件的大小，
你还想要这条线？

1541
01:13:04,290 --> 01:13:08,510

1542
01:13:08,510 --> 01:13:11,560
因此，如果我们改变一个文件的大小，
我们仍想跳过

1543
01:13:11,560 --> 01:13:12,810
在旧的填充？

1544
01:13:12,810 --> 01:13:15,170

1545
01:13:15,170 --> 01:13:15,970
>> 学生74：是的。

1546
01:13:15,970 --> 01:13:17,090
>> JASON HIRSCHHORN：所以我们做的。

1547
01:13:17,090 --> 01:13:19,290
正因为如此，同样，优惠
与源文件。

1548
01:13:19,290 --> 01:13:21,570
我们不关心填充
从源文件。

1549
01:13:21,570 --> 01:13:23,410
我们想要去到下一行。

1550
01:13:23,410 --> 01:13:28,850
但是，我们不能简单地把背
老金额填充。

1551
01:13:28,850 --> 01:13:31,540
我们需要把后面的
新的量填充。

1552
01:13:31,540 --> 01:13:35,810
>> 所以，当我们正在改变的大小
文件，我们还是想略过

1553
01:13:35,810 --> 01:13:38,270
填充在旧文件 - 什么
我们从阅读中。

1554
01:13:38,270 --> 01:13:40,370
但是，我们特此，我们将
需要放回一些不同的

1555
01:13:40,370 --> 01:13:41,890
填充数
我们已经确定。

1556
01:13:41,890 --> 01:13:42,780
是啊。

1557
01:13:42,780 --> 01:13:44,550
>> 学生75：这两个的顺序
线不要紧吧？

1558
01:13:44,550 --> 01:13:46,160
因为你处理
不同的文件。

1559
01:13:46,160 --> 01:13:46,620
>> JASON HIRSCHHORN：没错。

1560
01:13:46,620 --> 01:13:48,220
这两条线的顺序
没关系。

1561
01:13:48,220 --> 01:13:49,790
我们写这条线。

1562
01:13:49,790 --> 01:13:51,430
这是这里的文件
我们正在写。

1563
01:13:51,430 --> 01:13:54,370
这一点很重要，所以我们得到的
适量的填充。

1564
01:13:54,370 --> 01:13:57,560
这要处理的文件中。

1565
01:13:57,560 --> 01:13:58,560
我们想跳过权利
在填充。

1566
01:13:58,560 --> 01:13:59,470
>> 我们不想读 - 

1567
01:13:59,470 --> 01:14:01,500
如果我们读一字节的时间，我们
不关心这些填充字节。

1568
01:14:01,500 --> 01:14:04,070
我们想要移动到下一行。

1569
01:14:04,070 --> 01:14:11,800
最后，就像露西给了我们，
我们关闭文件并返回0。

1570
01:14:11,800 --> 01:14:13,890
因此，这是copy.c.

1571
01:14:13,890 --> 01:14:17,850
而我们实际上写 - 我们大部分的
部分写这个，基本上。

1572
01:14:17,850 --> 01:14:18,740
>> 是你们成就了。

1573
01:14:18,740 --> 01:14:22,440
所以希望你有一个良好的感觉
什么的在这里发生了。

1574
01:14:22,440 --> 01:14:25,890
最大的区别，说实话，只是
与交易第一部分

1575
01:14:25,890 --> 01:14:29,970
位图文件的特殊性。

1576
01:14:29,970 --> 01:14:33,570
所以，我有我的下一张幻灯片，
什么我们需要做什么？

1577
01:14:33,570 --> 01:14:35,510
好吧，让我们想想侦探小说。

1578
01:14:35,510 --> 01:14:38,080
>> 而对于有人谁读通过
问题设置，有什么事我们

1579
01:14:38,080 --> 01:14:41,410
需要做的侦探小说？

1580
01:14:41,410 --> 01:14:42,080
简单。

1581
01:14:42,080 --> 01:14:42,460
位于Aleja。

1582
01:14:42,460 --> 01:14:48,570
>> ALEJA：你能不能拿出一部分
每个表示红色像素的。

1583
01:14:48,570 --> 01:14:49,730
然后 - 

1584
01:14:49,730 --> 01:14:50,730
样的？

1585
01:14:50,730 --> 01:14:51,860
>> JASON HIRSCHHORN：确定。

1586
01:14:51,860 --> 01:14:54,460
因此，采取了各部分
像素是指红色。

1587
01:14:54,460 --> 01:14:57,234
这是接近，但不是全部。

1588
01:14:57,234 --> 01:14:59,780
>> 学生76：嗯，有
不同的方法来做到这一点。

1589
01:14:59,780 --> 01:14:59,870
>> JASON HIRSCHHORN：确定。

1590
01:14:59,870 --> 01:15:03,070
给我一个方法。

1591
01:15:03,070 --> 01:15:08,240
>> 学生76：取出所有的红色，和
再强调蓝色和绿色。

1592
01:15:08,240 --> 01:15:10,010
>> JASON HIRSCHHORN：确定。

1593
01:15:10,010 --> 01:15:11,830
因此，考虑这两个方面 - 

1594
01:15:11,830 --> 01:15:15,210
这听起来像我们给它一个像素，它
具有红色，蓝色和绿色的层次。

1595
01:15:15,210 --> 01:15:19,350
我们要改变的相对水平
红色，蓝色和绿色的，这取决于

1596
01:15:19,350 --> 01:15:20,740
该像素。

1597
01:15:20,740 --> 01:15:28,380
凡在此代码应修改
相对红，蓝和绿

1598
01:15:28,380 --> 01:15:29,720
给定像素的水平。

1599
01:15:29,720 --> 01:15:30,600
之后我们读它 - 

1600
01:15:30,600 --> 01:15:32,520
我们写它呢？

1601
01:15:32,520 --> 01:15:34,564
给我的行号。

1602
01:15:34,564 --> 01:15:35,950
>> 多名学生：83。

1603
01:15:35,950 --> 01:15:37,320
>> JASON HIRSCHHORN：83。

1604
01:15:37,320 --> 01:15:38,570
所以就在这里。

1605
01:15:38,570 --> 01:15:40,830

1606
01:15:40,830 --> 01:15:45,710
对于侦探小说，你的代码需要
写都应该去那里。

1607
01:15:45,710 --> 01:15:47,640
而这唯一的代码
你需要写。

1608
01:15:47,640 --> 01:15:51,520
因为，就像我们听到的，所有你需要
做的是改变这些相对蓝色，

1609
01:15:51,520 --> 01:15:54,420
红色和绿色的水平从每个像素。

1610
01:15:54,420 --> 01:15:58,250
>> 你读过它，现在你
会写出来。

1611
01:15:58,250 --> 01:16:03,100
我如何获得 - 如果我有这个东西
所谓三合一，就在这里，它的的

1612
01:16:03,100 --> 01:16:04,570
输入RGBTRIPLE  - 

1613
01:16:04,570 --> 01:16:08,650
好了，如果我们看着在bmp.h，
什么是RGBTRIPLE？

1614
01:16:08,650 --> 01:16:11,450

1615
01:16:11,450 --> 01:16:12,700
>> 学生77：这是一个结构。

1616
01:16:12,700 --> 01:16:17,440

1617
01:16:17,440 --> 01:16:18,900
>> JASON HIRSCHHORN：RGBTRIPLE
是一个结构。

1618
01:16:18,900 --> 01:16:22,330
我们看到，就在这里。

1619
01:16:22,330 --> 01:16:26,600
所以，如果我想访问，比方说，
该结构的红色级别，我该怎么办

1620
01:16:26,600 --> 01:16:30,005
访问此结构的红色级别？

1621
01:16:30,005 --> 01:16:37,280
>> [CLASS杂音]

1622
01:16:37,280 --> 01:16:38,530
>> 学生78：RGBTRIPLE.rgbtred？

1623
01:16:38,530 --> 01:16:47,250

1624
01:16:47,250 --> 01:16:48,856
>> JASON HIRSCHHORN：这是否正确？

1625
01:16:48,856 --> 01:16:53,040
>> 学生79：应该是三
点，而不是RGBTRIPLE点，？

1626
01:16:53,040 --> 01:16:54,120
>> JASON HIRSCHHORN：三重。

1627
01:16:54,120 --> 01:16:56,700
三重是局部变量，所以
在这里，这里没有指针。

1628
01:16:56,700 --> 01:16:58,400
所以我们只需要使用点符号。

1629
01:16:58,400 --> 01:17:00,480
这会给我的红​​色级别。

1630
01:17:00,480 --> 01:17:06,180
如果我想改变它，我只设置
它等于不同的东西。

1631
01:17:06,180 --> 01:17:13,190
如此反复，这行代码访问
这个变量这个结构里面，

1632
01:17:13,190 --> 01:17:15,070
我们可以将其设置为新的东西。

1633
01:17:15,070 --> 01:17:20,040
>> 因此对于推理小说，再次，这是
在本质上，我们需要做的。

1634
01:17:20,040 --> 01:17:21,170
很简单。

1635
01:17:21,170 --> 01:17:25,020
只要改变一些相对水平，并
这是哪里的代码去。

1636
01:17:25,020 --> 01:17:27,720
调整大小，另一方面，
是有点棘手。

1637
01:17:27,720 --> 01:17:30,900
事实上，调整大小大概是
这个问题最棘手的部分设置。

1638
01:17:30,900 --> 01:17:32,720
我们有三分钟就到了它。

1639
01:17:32,720 --> 01:17:34,910
>> 但是再一次，我们已经写
大部分代码，因此我们

1640
01:17:34,910 --> 01:17:36,500
应该是相当熟悉的。

1641
01:17:36,500 --> 01:17:40,750
有哪些事情是我们想要做的
调整大小，如果你读一下

1642
01:17:40,750 --> 01:17:43,470
问题设置？

1643
01:17:43,470 --> 01:17:45,290
如果你给我吧，我们
可以谈论他们。

1644
01:17:45,290 --> 01:17:47,340
有哪些事情是我们想干什么？

1645
01:17:47,340 --> 01:17:47,970
>> 学生80：垂直 - 

1646
01:17:47,970 --> 01:17:52,360
所以你必须在水平方向调整其大小，
但垂直调整它的大小呢？

1647
01:17:52,360 --> 01:17:58,475
>> JASON HIRSCHHORN：所以，如果我们给出一个
像素，并且我们希望通过调整其大小

1648
01:17:58,475 --> 01:18:03,460
两个因素，它现在需要
调整水平和调整大小

1649
01:18:03,460 --> 01:18:05,220
垂直。

1650
01:18:05,220 --> 01:18:06,640
这是否有道理？

1651
01:18:06,640 --> 01:18:07,060
是啊。

1652
01:18:07,060 --> 01:18:09,300
所以这是可能的
最大的挑战。

1653
01:18:09,300 --> 01:18:10,430
和我们谈谈，在几秒钟之内。

1654
01:18:10,430 --> 01:18:11,065
是啊。

1655
01:18:11,065 --> 01:18:15,270
>> 学生81：我想它的方式
是你需要打印出来 - 

1656
01:18:15,270 --> 01:18:15,490
>> JASON HIRSCHHORN：等待。

1657
01:18:15,490 --> 01:18:17,580
不要告诉我们你做了什么。

1658
01:18:17,580 --> 01:18:20,620
我们要谈的逻辑。

1659
01:18:20,620 --> 01:18:21,870
>> 学生81：确定。

1660
01:18:21,870 --> 01:18:25,090

1661
01:18:25,090 --> 01:18:27,410
究竟是什么问题？

1662
01:18:27,410 --> 01:18:28,892
>> JASON HIRSCHHORN：你刚才
提出你的手。

1663
01:18:28,892 --> 01:18:31,600
毫无疑问。

1664
01:18:31,600 --> 01:18:32,520
让我来介绍它。

1665
01:18:32,520 --> 01:18:34,560
让我讨论这个短暂。

1666
01:18:34,560 --> 01:18:38,400
因此，我们的一个像素，我们要
复制它，横向和

1667
01:18:38,400 --> 01:18:39,360
垂直。

1668
01:18:39,360 --> 01:18:48,920
因此，理想情况下我们在这里做的是什么，我们
阅读我们的象素，我们把它写

1669
01:18:48,920 --> 01:18:51,690
然而许多倍。

1670
01:18:51,690 --> 01:18:54,720
>> 但是，我们有我们的绝招在这里，因为
那么我们要跳到

1671
01:18:54,720 --> 01:18:57,660
下一行，并在写
开始下一行的。

1672
01:18:57,660 --> 01:19:02,960
因此，如果我们想复制这两个
水平和垂直方向是什么

1673
01:19:02,960 --> 01:19:05,050
一个很好的方法来做到这一点 - 

1674
01:19:05,050 --> 01:19:06,780
一款不错的，虽然这样做呢？

1675
01:19:06,780 --> 01:19:11,950
所以我们并不需要时时寻求
围绕我们的文件放置的东西。

1676
01:19:11,950 --> 01:19:14,360
>> 这个问题可能没有
是有道理的，但我认为一个

1677
01:19:14,360 --> 01:19:15,800
答案是会有所帮助。

1678
01:19:15,800 --> 01:19:17,210
>> 学生82：创建一个数组？

1679
01:19:17,210 --> 01:19:20,090
>> JASON HIRSCHHORN：所以，让我们觉得
每个文件为一排。

1680
01:19:20,090 --> 01:19:22,550
让我们觉得行方面。

1681
01:19:22,550 --> 01:19:26,670
如果我们有我们的第一行从我们的小
图片中，我们可以作出这样的行

1682
01:19:26,670 --> 01:19:30,640
从成一张大图片大排，
然后复制但该行

1683
01:19:30,640 --> 01:19:34,250
很多时候它需要被复制，
而不是通过象素去象素

1684
01:19:34,250 --> 01:19:37,260
它得到混乱的时候
处理文件。

1685
01:19:37,260 --> 01:19:38,730
>> 因为如果我们有 - 

1686
01:19:38,730 --> 01:19:41,260
我跑出来的空间。

1687
01:19:41,260 --> 01:19:46,490
如果这是我们的文件，我们有
一个像素在那里，我们希望把它

1688
01:19:46,490 --> 01:19:49,840
在那里，我们仍然有一些事情
那需要到那边去，当我们

1689
01:19:49,840 --> 01:19:51,450
写作和创造我们的新文件 - 

1690
01:19:51,450 --> 01:19:53,250
我们的文件，该文件的两倍大。

1691
01:19:53,250 --> 01:19:56,820
>> 但它真的很难用文件功能
跳过各地新线

1692
01:19:56,820 --> 01:20:00,260
这样，然后回去在这里
并把东西在里面。

1693
01:20:00,260 --> 01:20:04,500
这几乎是不可能做到的事情
这样，如果是有道理的。

1694
01:20:04,500 --> 01:20:10,180
因此，如果我们认为行方面，我们可以
把我们的行，然后把它放在 - 

1695
01:20:10,180 --> 01:20:11,720
垂直重复的行。

1696
01:20:11,720 --> 01:20:15,860
>> 这就是我们如何处理调整大小
垂直而不是水平。

1697
01:20:15,860 --> 01:20:18,810
这是那种快，
有点混乱。

1698
01:20:18,810 --> 01:20:22,375
不幸的是我们的时间到了。

1699
01:20:22,375 --> 01:20:27,340
我会站在外面那些你
谁在这里有关于问题

1700
01:20:27,340 --> 01:20:30,500
习题集，包括恢复。

1701
01:20:30,500 --> 01:20:32,320
>> 因此，让我们休会了。

1702
01:20:32,320 --> 01:20:34,480
再次，如果您有任何疑问，
我们可以聊天之外。

1703
01:20:34,480 --> 01:20:38,294