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

2
00:00:05,830 --> 00:00:08,650
>> JASON HIRSCHHORN：欢迎到
CS50节，每个人。

3
00:00:08,650 --> 00:00:11,430
我的名字是贾森·赫塞豪恩。

4
00:00:11,430 --> 00:00:15,850
我是你的转录因子很多，但很多
人们会希望能够加入我们

5
00:00:15,850 --> 00:00:20,420
在线扩展学生或学生
试图通过部分看，如果他们

6
00:00:20,420 --> 00:00:22,830
那一周或错过了他们的部分
正好赶上，如果他们想

7
00:00:22,830 --> 00:00:24,510
回顾一些材料。

8
00:00:24,510 --> 00:00:30,060
>> 因此，按照教学大纲，所有
你们都读过，纠正吗？

9
00:00:30,060 --> 00:00:31,390
我看到了很多的点头。

10
00:00:31,390 --> 00:00:34,220
节为您提供的机会
探索课程

11
00:00:34,220 --> 00:00:37,420
材料在一个更亲密的环境，
以及潜入

12
00:00:37,420 --> 00:00:38,810
实践活动。

13
00:00:38,810 --> 00:00:41,230
>> 所以，基本上我们什么
会做每周。

14
00:00:41,230 --> 00:00:45,090
我们通过我们有什么打算去
确定为最重要的

15
00:00:45,090 --> 00:00:49,170
涵盖的主题演讲，和那些
大概也是最有用和最

16
00:00:49,170 --> 00:00:52,780
最有可能想出问题集
和测验，并在您的编码

17
00:00:52,780 --> 00:00:53,970
CS50之外的生活。

18
00:00:53,970 --> 00:00:57,260
因此，我们要进入这些主题，
讨论这些问题，他们走了过来，

19
00:00:57,260 --> 00:01:00,660
回答你们有任何问题，
然后我们做了很多

20
00:01:00,660 --> 00:01:02,250
在编码的实际问题。

21
00:01:02,250 --> 00:01:04,239
>> 你们都带来了笔记本电脑，
这是梦幻般的。

22
00:01:04,239 --> 00:01:05,710
这是一个计算机科学类。

23
00:01:05,710 --> 00:01:10,070
但是，我们做了很多的练习，
你不会需要你的笔记本电脑。

24
00:01:10,070 --> 00:01:11,720
你可以做他们在片材上的纸张。

25
00:01:11,720 --> 00:01:13,580
这就是你要
做他们的测验。

26
00:01:13,580 --> 00:01:16,450
而事实上，这是一个伟大的方式来
真的知道，你该怎么办

27
00:01:16,450 --> 00:01:19,720
如果你没有的东西检查50〜
依赖或依靠，告诉

28
00:01:19,720 --> 00:01:20,620
你做了任何错误。

29
00:01:20,620 --> 00:01:25,670
>> 因此，欢迎你在代码
装置或run.cs50.net，这是

30
00:01:25,670 --> 00:01:29,770
另一种工具，允许您编写
在线，但我也建议，如果

31
00:01:29,770 --> 00:01:32,280
你有没有试过，使用表
纸和尝试这些做法

32
00:01:32,280 --> 00:01:33,640
一张纸的问题。

33
00:01:33,640 --> 00:01:35,330
这还是因为同样的原因，这是最终
你要什么

34
00:01:35,330 --> 00:01:37,430
要求做测验。

35
00:01:37,430 --> 00:01:44,080
>> 因此，让我们开始我们的
今天的议程。

36
00:01:44,080 --> 00:01:47,710
我们打​​算去了一些规范
我们的部分，然后我们要去潜水

37
00:01:47,710 --> 00:01:51,180
成数组，函数和命令行
参数，这是你们

38
00:01:51,180 --> 00:01:56,200
过去的这一周，已覆盖讲座
然后在周一，你会覆盖

39
00:01:56,200 --> 00:01:57,330
更多的明天。

40
00:01:57,330 --> 00:01:59,060
最后，我们要
谈论pset2。

41
00:01:59,060 --> 00:02:03,640
如果我能得到一个举手，如果你
没有看着两个问题集

42
00:02:03,640 --> 00:02:04,890
规范。

43
00:02:04,890 --> 00:02:07,060

44
00:02:07,060 --> 00:02:08,120
我们大家会说。

45
00:02:08,120 --> 00:02:09,419
太棒了。

46
00:02:09,419 --> 00:02:12,070
>> 我们将谈论问题套在一个位，
但如果你阅读问题集

47
00:02:12,070 --> 00:02:14,340
规范，这是
所有你需要做的。

48
00:02:14,340 --> 00:02:18,370
如果你读之前，你来
类和部分在周二，你会

49
00:02:18,370 --> 00:02:19,220
是一个伟大的位置。

50
00:02:19,220 --> 00:02:21,680
我们可以去通过习题集，
这就是我们要去

51
00:02:21,680 --> 00:02:22,090
做底。

52
00:02:22,090 --> 00:02:23,500
我们要经过
逻辑，确保

53
00:02:23,500 --> 00:02:24,710
每个人都在同一页上。

54
00:02:24,710 --> 00:02:28,650
>> 我希望你能够离开周二
你感觉很舒服

55
00:02:28,650 --> 00:02:31,560
需要做的这个星期的问题集，
如果你不这样做，我会很高兴

56
00:02:31,560 --> 00:02:33,050
留后，并与您合作。

57
00:02:33,050 --> 00:02:36,850
但是，这是一件事，你必须
做，但我认为很聪明，

58
00:02:36,850 --> 00:02:40,500
只是阅读问题集
规范类星期二

59
00:02:40,500 --> 00:02:42,640
这听起来像一个
你们做的很多。

60
00:02:42,640 --> 00:02:45,810
>> 我将开始与每类议程
所以你知道我们要去的地方。

61
00:02:45,810 --> 00:02:49,520
这也是有帮助的人看
在网上，因为每个节

62
00:02:49,520 --> 00:02:53,540
颜色编码，所以如果你要来
，只是看10分钟，而

63
00:02:53,540 --> 00:02:56,950
比整个90分钟的部分，
刚去的颜色编码部分

64
00:02:56,950 --> 00:02:57,890
并期待在这一部分。

65
00:02:57,890 --> 00:03:01,510
因此，我一直试图将它们分开成漂亮的
模块将允许你 - 

66
00:03:01,510 --> 00:03:03,960
如果你想回来，并检讨，
或其他学生只是

67
00:03:03,960 --> 00:03:05,350
看一段检讨 - 

68
00:03:05,350 --> 00:03:08,130
找到具体的事情，他们
要注意的

69
00:03:08,130 --> 00:03:10,480
并进一步了解。

70
00:03:10,480 --> 00:03:11,390
甜。

71
00:03:11,390 --> 00:03:12,180
>> 规范。

72
00:03:12,180 --> 00:03:13,680
我是一个FOP在校园里的领导者。

73
00:03:13,680 --> 00:03:14,900
我不知道，如果有人做FOP。

74
00:03:14,900 --> 00:03:16,280
有没有人做FOP？

75
00:03:16,280 --> 00:03:17,100
一个人做FOP。

76
00:03:17,100 --> 00:03:18,430
两个人做FOP。

77
00:03:18,430 --> 00:03:19,250
真棒。

78
00:03:19,250 --> 00:03:22,360
因此，FOP是第一年户外
迎新活动。

79
00:03:22,360 --> 00:03:27,240
我们进了树林，使新生
最神奇的经历

80
00:03:27,240 --> 00:03:28,830
他们的生活，是否正确？

81
00:03:28,830 --> 00:03:29,220
嗯。

82
00:03:29,220 --> 00:03:30,080
听起来是正确的。

83
00:03:30,080 --> 00:03:36,360
>> 所以，我只是想开始我们的第一个
通过讨论一些规范部分

84
00:03:36,360 --> 00:03:38,860
类和我们之间的关系
因为我觉得

85
00:03:38,860 --> 00:03:40,010
他们是非常重要的。

86
00:03:40,010 --> 00:03:43,630
首先，那些你们谁
我的部分已收到并

87
00:03:43,630 --> 00:03:47,150
中讨论的
电子邮件，我喜欢这个。

88
00:03:47,150 --> 00:03:48,130
这是今年我最喜欢的部分。

89
00:03:48,130 --> 00:03:49,100
我一直很兴奋。

90
00:03:49,100 --> 00:03:50,040
我在这里已经好几个小时。

91
00:03:50,040 --> 00:03:54,560
我还没有离开这栋楼除了
去吃饭，因为我爱CS50节，我

92
00:03:54,560 --> 00:03:58,620
爱教学，我爱工作
你们。

93
00:03:58,620 --> 00:04:02,000
>> 我的最高优先事项之一，如果不是我
头号优先，不仅为

94
00:04:02,000 --> 00:04:05,130
这一类，但包括我的其他
类和课外活动，是

95
00:04:05,130 --> 00:04:09,350
支持你们，帮助你们，
尽我所能，确保您

96
00:04:09,350 --> 00:04:13,780
你们有一个美好的，有趣的，多产，
引人入胜，令人振奋

97
00:04:13,780 --> 00:04:15,250
在这个类中的经验。

98
00:04:15,250 --> 00:04:16,190
这就是我的承诺。

99
00:04:16,190 --> 00:04:17,959
这就是为什么我喜欢这样做。

100
00:04:17,959 --> 00:04:20,190
这是我的一件事，
支持你们。

101
00:04:20,190 --> 00:04:25,110
如果您有任何关于讲座的问题，
问题集，节，

102
00:04:25,110 --> 00:04:28,830
生活中，即使你想谈谈
生活中，请随时伸手。

103
00:04:28,830 --> 00:04:31,210
>> 你有我的手机号码，
你有我的电子邮件

104
00:04:31,210 --> 00:04:32,910
地址，你有我的GChat。

105
00:04:32,910 --> 00:04:37,540
你可以联系我的任何或所有
何时何地，但可能不会得到

106
00:04:37,540 --> 00:04:38,720
响应时。

107
00:04:38,720 --> 00:04:41,020
我尝试在24小时内取回。

108
00:04:41,020 --> 00:04:44,760
通常情况下，它会在
20分钟或24分钟。

109
00:04:44,760 --> 00:04:46,110
我应该说，
使其平行。

110
00:04:46,110 --> 00:04:48,840
但是，你会得到一个回应
很快。

111
00:04:48,840 --> 00:04:54,220
>> 如果你给我发短信前一小时
问题集中到期，我会冷静

112
00:04:54,220 --> 00:04:57,660
下来，做深呼吸练习
你，但如果你还没有开始，

113
00:04:57,660 --> 00:05:00,270
你可能不会完成，
我真的不能帮你在那里

114
00:05:00,270 --> 00:05:01,710
尽管我会尽我所能。

115
00:05:01,710 --> 00:05:03,920
所以，我会尽一切
我可以支持你。

116
00:05:03,920 --> 00:05:07,980
请随意是否达到
它在节再次，在办公时间

117
00:05:07,980 --> 00:05:09,150
如果你看到我，甚至在外头。

118
00:05:09,150 --> 00:05:11,800
我很高兴，设立时间，以满足
通过问题和工作

119
00:05:11,800 --> 00:05:14,410
或材料走了过来。

120
00:05:14,410 --> 00:05:15,990
所以这是头号，支持。

121
00:05:15,990 --> 00:05:17,940
我会尽我
可以支持你。

122
00:05:17,940 --> 00:05:21,520
>> 二，会议中间。

123
00:05:21,520 --> 00:05:24,760
就像我想是的，我
不是万能的或强大或

124
00:05:24,760 --> 00:05:28,410
全知的，所以我不知道所有的
时间，如果我在做什么

125
00:05:28,410 --> 00:05:33,410
跨越，如果我教的方式
主题帮助您了解它，或者，如果你

126
00:05:33,410 --> 00:05:36,120
感到困惑的话题，但不
举起你的手，或问我

127
00:05:36,120 --> 00:05:37,390
或发电子邮件给我。

128
00:05:37,390 --> 00:05:42,150
或者，即使你再感到困惑
有关问题上的东西。

129
00:05:42,150 --> 00:05:44,240
如果你不拿出来给我，
我不知道那是肯定的。

130
00:05:44,240 --> 00:05:46,950
我要尽我所能来检查
你们这些家伙，确保一切

131
00:05:46,950 --> 00:05:51,170
顺利，试教的方式的事情
大部分将有利于

132
00:05:51,170 --> 00:05:54,910
您的学习风格，但如果有
我能做些什么，让我知道。

133
00:05:54,910 --> 00:05:58,520
>> 沿着这些线路，如果你想要一些帮助
设置的问题，我更

134
00:05:58,520 --> 00:05:59,700
比竭诚为您服务
问题集。

135
00:05:59,700 --> 00:06:02,300
我们打​​算做了很多
，朝第二

136
00:06:02,300 --> 00:06:03,460
本节的一半。

137
00:06:03,460 --> 00:06:06,040
但是，如果你还没有阅读问题集
备份和没有看过步行

138
00:06:06,040 --> 00:06:09,310
通过和没有看过的短裤
并期待我来教你

139
00:06:09,310 --> 00:06:13,260
一切已经录像
在线或你可以找到CS50

140
00:06:13,260 --> 00:06:16,720
学习，这不是一个真正公平的
我或你的其他同行。

141
00:06:16,720 --> 00:06:20,440

142
00:06:20,440 --> 00:06:25,730
>> 所以，请我更乐意帮助
你，但你们得到了满足我

143
00:06:25,730 --> 00:06:27,230
中间。

144
00:06:27,230 --> 00:06:30,100
我们有资源吨
你CS50。

145
00:06:30,100 --> 00:06:31,230
我提到其中的一些。

146
00:06:31,230 --> 00:06:32,960
请利用它们。

147
00:06:32,960 --> 00:06:35,140
如果你困惑，我更乐意
帮你解释他们在

148
00:06:35,140 --> 00:06:39,290
另一种方式，但它是不公平的，如果
学生在办公时间，

149
00:06:39,290 --> 00:06:42,530
还没有开始任何事情，它是
周四晚上，他们正在期待

150
00:06:42,530 --> 00:06:45,880
他们通过每一个TF走
由于问题的东西设置

151
00:06:45,880 --> 00:06:47,140
第二天中午。

152
00:06:47,140 --> 00:06:48,300
有意义吗？

153
00:06:48,300 --> 00:06:50,890
再次，请配合我们在中间。

154
00:06:50,890 --> 00:06:53,230
>> 最后，很高的期望。

155
00:06:53,230 --> 00:06:58,010
我要分级大家谁
在我的部分，或得分

156
00:06:58,010 --> 00:06:59,020
习题集。

157
00:06:59,020 --> 00:07:01,240
你还没有问题
设置零次或一次。

158
00:07:01,240 --> 00:07:02,250
我们很遗憾。

159
00:07:02,250 --> 00:07:04,970
我们花了一段时间，终于
解决部分，而现在

160
00:07:04,970 --> 00:07:05,560
我们可以开始分级。

161
00:07:05,560 --> 00:07:09,560
>> 我将让他们回到你
尽快。

162
00:07:09,560 --> 00:07:11,890
这些都是我的一些
有advisees。

163
00:07:11,890 --> 00:07:14,150
我将让他们回到你
尽快。

164
00:07:14,150 --> 00:07:18,046
第二个问题集，我们会在
安排，我们将开始让他们

165
00:07:18,046 --> 00:07:20,440
你很快后
你打开它们。

166
00:07:20,440 --> 00:07:24,130
>> 当您重新设置您的问题，
将获得更高的分数，因为你知道，从

167
00:07:24,130 --> 00:07:28,150
阅读大纲 - 正确性，
设计，范围和风格分数。

168
00:07:28,150 --> 00:07:29,760
您还可以得到意见。

169
00:07:29,760 --> 00:07:32,160
更重要的意见
比分数。

170
00:07:32,160 --> 00:07:33,780
我认为它是安全地说。

171
00:07:33,780 --> 00:07:37,930
>> 分数只是一个数字
从一到五。

172
00:07:37,930 --> 00:07:38,930
这是很难读入那些。

173
00:07:38,930 --> 00:07:40,720
这是从那些难以改善。

174
00:07:40,720 --> 00:07:44,460
但评论指出具体
事情，你做得很好或地区

175
00:07:44,460 --> 00:07:48,360
你可以改善，并给你一些
对未来的想法或替代

176
00:07:48,360 --> 00:07:49,160
做事的方法。

177
00:07:49,160 --> 00:07:52,270
>> 所以，请，请，请仔细阅读“
通过的意见。

178
00:07:52,270 --> 00:07:54,190
我把大量的时间到
这些意见。

179
00:07:54,190 --> 00:07:57,190
请仔细阅读并通过他们不只是
向下滚动到的底部

180
00:07:57,190 --> 00:08:01,890
PDF格式，看你的分数，或者去网上
找到你的分数，然后忽略

181
00:08:01,890 --> 00:08:02,800
的意见。

182
00:08:02,800 --> 00:08:03,910
那不是你
会变得更好。

183
00:08:03,910 --> 00:08:06,550
那不是你要增加
你的分数，最终，只是

184
00:08:06,550 --> 00:08:07,340
看上面的分数。

185
00:08:07,340 --> 00:08:08,760
请看看这些意见。

186
00:08:08,760 --> 00:08:13,240
>> 沿线很高的期望，
再次，就像我说的，你

187
00:08:13,240 --> 00:08:14,260
可以砍下从一到五。

188
00:08:14,260 --> 00:08:17,120
三三两两，三分球，四肢
绝大多数分数

189
00:08:17,120 --> 00:08:17,940
你要得到。

190
00:08:17,940 --> 00:08:20,180
和五岁以下儿童的都是真的很罕见。

191
00:08:20,180 --> 00:08:21,720
总是有东西
我们可以做的更好。

192
00:08:21,720 --> 00:08:23,490
每当我编写一个程序，有
总有一些事情我

193
00:08:23,490 --> 00:08:24,800
可以做的更好。

194
00:08:24,800 --> 00:08:28,740
>> 因此，而不是说你得到了五
一切所有的时间，并

195
00:08:28,740 --> 00:08:31,960
一切完美，我不认为任何
我们真的相信我们 - 

196
00:08:31,960 --> 00:08:34,830
希望我们不要做的一切
完善所有的时间。

197
00:08:34,830 --> 00:08:37,010
所以，不要担心，如果你
没有得到一个五。

198
00:08:37,010 --> 00:08:40,470
一个五不映射到一个A，
不映射到一个B，一个三不

199
00:08:40,470 --> 00:08:42,950
不映射到这不是一个C。
的分数是如何工作的。

200
00:08:42,950 --> 00:08:48,140
>> 像大卫已经说过很多次，
学期结束所有你的分数和

201
00:08:48,140 --> 00:08:53,390
从我做起，输入你的TF，走到了一起
并为您确定最终成绩。

202
00:08:53,390 --> 00:08:56,760
但同样，它不是五，
四，B，等等。

203
00:08:56,760 --> 00:09:01,150
所以我要抱有很高的期望
为你们。

204
00:09:01,150 --> 00:09:03,670
我要去预期良好的问题
套，我要去给

205
00:09:03,670 --> 00:09:05,010
您的反馈等。

206
00:09:05,010 --> 00:09:07,430
它不会意味着你
会得到档次更糟。

207
00:09:07,430 --> 00:09:09,760
您而言，分级
你的进步从周

208
00:09:09,760 --> 00:09:11,260
为零，当然结束。

209
00:09:11,260 --> 00:09:17,190
>> 最后，在高
在课堂上的期望，我爱

210
00:09:17,190 --> 00:09:18,460
人参与。

211
00:09:18,460 --> 00:09:23,180
我明白有些人觉得更多的还是
不太舒服的参与。

212
00:09:23,180 --> 00:09:26,050
其他人参与
不是靠提高他们的手，

213
00:09:26,050 --> 00:09:27,320
说话的时候。

214
00:09:27,320 --> 00:09:30,570
但我们在这个类将要
做了很多的小问题，很多

215
00:09:30,570 --> 00:09:33,770
小的问题，然后一些
更大的编码问题。

216
00:09:33,770 --> 00:09:36,760
所以肯定这些工作锻炼出来
当我们这样做，他们在您的计算机上或

217
00:09:36,760 --> 00:09:37,900
一张纸。

218
00:09:37,900 --> 00:09:40,933
>> 但我还会给你前一段时间
有人回答一些

219
00:09:40,933 --> 00:09:42,220
我问的问题。

220
00:09:42,220 --> 00:09:44,930
所以，因为我会给你一些时间
想想吧，因为我们要去

221
00:09:44,930 --> 00:09:49,380
有时合作伙伴做的事情，
我会期待大家

222
00:09:49,380 --> 00:09:52,150
要有点从事。

223
00:09:52,150 --> 00:09:56,030
而对于缺乏一个更好的词，
可能会冷通话，

224
00:09:56,030 --> 00:09:59,045
是每个人都将有机会
思考答案，然后

225
00:09:59,045 --> 00:10:01,150
我会打电话给你，然后
你会说答案。

226
00:10:01,150 --> 00:10:05,200
>> 不要担心或害怕，。

227
00:10:05,200 --> 00:10:08,610
我已经做到了在过去，我们已经找到了
它的成功得多，

228
00:10:08,610 --> 00:10:11,810
阅读教育研究
确定是否它是一个

229
00:10:11,810 --> 00:10:12,640
良好的战术。

230
00:10:12,640 --> 00:10:15,790
这是非常有用的，特别是如果你
让学生有时间去思考

231
00:10:15,790 --> 00:10:20,070
的答案，不要让他们刚进来
出来，说出来了蝙蝠的权利。

232
00:10:20,070 --> 00:10:22,620
但是，如果你感觉不舒服
回答，我还不错

233
00:10:22,620 --> 00:10:25,370
感应到了，我们不打算
把你在现场，尤其是在

234
00:10:25,370 --> 00:10:28,240
摄像头，即使没有
你是在相机现在。

235
00:10:28,240 --> 00:10:32,250
>> 因此，这些都是我的规范。

236
00:10:32,250 --> 00:10:34,670
沿线的一件事
满足在中间。

237
00:10:34,670 --> 00:10:36,490
我去给你们
很多反馈意见。

238
00:10:36,490 --> 00:10:38,310
请给我反馈。

239
00:10:38,310 --> 00:10:46,190
有一个网站，sayat.me/cs50。

240
00:10:46,190 --> 00:10:48,380
所以这是一个诚实的反馈。

241
00:10:48,380 --> 00:10:50,730
如果你想给它一节期间，
我收到一封电子邮件，每当发生。

242
00:10:50,730 --> 00:10:53,820
我们将稍事休息，所以我会在一个位
然后看通过反馈。

243
00:10:53,820 --> 00:10:55,970
如果你有任何意见，
请给我有。

244
00:10:55,970 --> 00:11:01,380
>> 如果你给我反馈，这是在Q
美妙的，但是这是导

245
00:11:01,380 --> 00:11:02,570
你做底。

246
00:11:02,570 --> 00:11:05,690
但是，这将是在学期结束，所以
我不会可以采取任何的

247
00:11:05,690 --> 00:11:08,620
反馈，并把它融入教学
你们更好。

248
00:11:08,620 --> 00:11:11,020
所以，请如果您有任何
反馈，把它给我。

249
00:11:11,020 --> 00:11:12,010
我爱的反馈。

250
00:11:12,010 --> 00:11:14,490
备份FOP，我们得到的反馈
所有的时间。

251
00:11:14,490 --> 00:11:18,610
>> 你可以给我加号，好东西，
三角洲的事情，我可以改善。

252
00:11:18,610 --> 00:11:20,600
你可以评论我的衣服上。

253
00:11:20,600 --> 00:11:24,170
这不会是有帮助，但你
欢迎发表任何评论，

254
00:11:24,170 --> 00:11:24,570
一切。

255
00:11:24,570 --> 00:11:26,280
请，请给我反馈。

256
00:11:26,280 --> 00:11:28,740
我很看重它了很多，这
对我来说意味着很多。

257
00:11:28,740 --> 00:11:31,760

258
00:11:31,760 --> 00:11:33,280
>> 一个规范，乐趣无穷。

259
00:11:33,280 --> 00:11:34,530
我们将有很多的乐趣。

260
00:11:34,530 --> 00:11:36,930
希望在这个过程中，你会
有很多的乐趣。

261
00:11:36,930 --> 00:11:38,780
我们将有糖果部分。

262
00:11:38,780 --> 00:11:40,040
我们就得音乐。

263
00:11:40,040 --> 00:11:45,510
我们会希望去了解一个
另一个有点好，所以我想

264
00:11:45,510 --> 00:11:47,690
这是一个有趣的，引人入胜的体验。

265
00:11:47,690 --> 00:11:50,890
>> 我知道你们有些人睡着
你今天早些时候的演讲，

266
00:11:50,890 --> 00:11:53,750
所以希望这不会
现在的情况。

267
00:11:53,750 --> 00:11:55,960
而如果是现在的情况下，只是
不打呼噜，因为可能

268
00:11:55,960 --> 00:11:57,580
被抓相机。

269
00:11:57,580 --> 00:11:58,770
甜。

270
00:11:58,770 --> 00:12:04,020
有任何疑问，意见或疑虑
之前，我谨什么，我们已经

271
00:12:04,020 --> 00:12:05,270
谈到？

272
00:12:05,270 --> 00:12:08,620

273
00:12:08,620 --> 00:12:11,350
太好了。

274
00:12:11,350 --> 00:12:14,830
>> 因此，我们打算去
先成阵列。

275
00:12:14,830 --> 00:12:17,140
这是你如何使一个数组。

276
00:12:17,140 --> 00:12:18,410
我们已经看到过。

277
00:12:18,410 --> 00:12:21,830
你有一个数据类型，你有一个
名称，然后你有一个大小。

278
00:12:21,830 --> 00:12:24,430
在这里，我创建了两个数组。

279
00:12:24,430 --> 00:12:30,360
第一个是一个字符数组，
它有26个停车位。

280
00:12:30,360 --> 00:12:33,790
第二个是一个数组
分数，它有三个

281
00:12:33,790 --> 00:12:35,390
空间三个整数。

282
00:12:35,390 --> 00:12:35,827
是吗？

283
00:12:35,827 --> 00:12:38,200
>> 学生：所有这些幻灯片
可为我们的地方吗？

284
00:12:38,200 --> 00:12:38,850
>> JASON HIRSCHHORN：大问题。

285
00:12:38,850 --> 00:12:40,650
问题是，所有的
这些滑动？

286
00:12:40,650 --> 00:12:40,920
是。

287
00:12:40,920 --> 00:12:43,420
所有这些幻灯片将是可利用的，
在未来，我会通过电子邮件给

288
00:12:43,420 --> 00:12:44,640
你之前部分。

289
00:12:44,640 --> 00:12:47,340
然而今天，因为这是第一次
本周，我们起步较晚。

290
00:12:47,340 --> 00:12:49,675
所以通常情况下，你会得到这些幻灯片，但
他们将可在网上和

291
00:12:49,675 --> 00:12:52,420
我会通过电子邮件发送给你
下课后权。

292
00:12:52,420 --> 00:12:54,140
任何其他的问题吗？

293
00:12:54,140 --> 00:13:01,330
>> 如此反复，阵列箱，由于缺乏
一个更好的词，有多个

294
00:13:01,330 --> 00:13:06,420
一种数据类型的元素，而且他们
在内存中彼此旁边。

295
00:13:06,420 --> 00:13:11,370
如此反复，这怎么可以
使两种类型的阵列。

296
00:13:11,370 --> 00:13:15,090
>> 所以在你做出阵列
 - 诠释，第一行分数，支架

297
00:13:15,090 --> 00:13:17,430
三，靠近支架 - 
想要初始化它。

298
00:13:17,430 --> 00:13:19,050
你想在那里把一些值。

299
00:13:19,050 --> 00:13:24,660
这是你如何把一些值
在那里，只是选择的指数和

300
00:13:24,660 --> 00:13:25,670
记录的号码。

301
00:13:25,670 --> 00:13:27,130
让我们画在黑板上。

302
00:13:27,130 --> 00:13:28,270
每个人都可以看到吗？

303
00:13:28,270 --> 00:13:29,030
每个人都可以看到。

304
00:13:29,030 --> 00:13:30,790
甜。

305
00:13:30,790 --> 00:13:36,550
>> 所以这将是我的
阵列称为比分。

306
00:13:36,550 --> 00:13:37,730
正如你可以看到的，它的大小为3。

307
00:13:37,730 --> 00:13:39,210
在那里有三个框。

308
00:13:39,210 --> 00:13:43,120
每一个可以容纳什么
类型的数据类型？

309
00:13:43,120 --> 00:13:43,790
>> 学生：整数。

310
00:13:43,790 --> 00:13:45,250
>> JASON HIRSCHHORN：一个整数
在这其中。

311
00:13:45,250 --> 00:13:48,790
我们写INT的分数，并且第一个字
那将是数据类型

312
00:13:48,790 --> 00:13:50,910
该数组中的框。

313
00:13:50,910 --> 00:13:52,160
所以，我能适合三种。

314
00:13:52,160 --> 00:13:54,880

315
00:13:54,880 --> 00:13:57,000
为什么我必须零
板？

316
00:13:57,000 --> 00:13:59,240
为什么它说得分为零等于1？

317
00:13:59,240 --> 00:14:02,090

318
00:14:02,090 --> 00:14:03,180
提醒我你的名字。

319
00:14:03,180 --> 00:14:03,470
>> 学生：库尔特。

320
00:14:03,470 --> 00:14:04,070
>> JASON HIRSCHHORN：库尔特。

321
00:14:04,070 --> 00:14:04,480
>> 学生：是的。

322
00:14:04,480 --> 00:14:04,920
>> JASON HIRSCHHORN：为什么呢？

323
00:14:04,920 --> 00:14:07,230
>> 学生：因为第一个索引
为零，我们开始计数为零。

324
00:14:07,230 --> 00:14:08,480
>> JASON HIRSCHHORN：所以我们开始
在零计数。

325
00:14:08,480 --> 00:14:09,580
这是完全正确的。

326
00:14:09,580 --> 00:14:12,340
这是令人困惑的部分和意志之旅
你，尤其是当你

327
00:14:12,340 --> 00:14:14,900
试图遍历数组，
我们会做一个位。

328
00:14:14,900 --> 00:14:15,980
我们开始计数为零。

329
00:14:15,980 --> 00:14:19,170
所以，如果我想参照第一
盒，它不是箱里。

330
00:14:19,170 --> 00:14:22,290
不幸的是，箱零。

331
00:14:22,290 --> 00:14:26,460
第二个是框中，并在这
的情况下，第三个是箱两种。

332
00:14:26,460 --> 00:14:28,700
>> 关于对话框三是什么？

333
00:14:28,700 --> 00:14:30,670
箱三在哪里呢？

334
00:14:30,670 --> 00:14:34,750
或者，如果我想要做的成绩，支架
三，密切支架，那是什么？

335
00:14:34,750 --> 00:14:37,650

336
00:14:37,650 --> 00:14:39,760
所以你说的空字符。

337
00:14:39,760 --> 00:14:41,600
任何其他的想法？

338
00:14:41,600 --> 00:14:44,590
什么是得分支架三个支架？

339
00:14:44,590 --> 00:14:48,045
>> 学生：它并没有真正存在，因为
你只定义为得分，

340
00:14:48,045 --> 00:14:49,370
支架三。

341
00:14:49,370 --> 00:14:51,400
>> JASON HIRSCHHORN：所以你说
它并没有真正存在。

342
00:14:51,400 --> 00:14:54,230
在某些情况下，当我们正在处理
字符串，一般我们把空

343
00:14:54,230 --> 00:14:54,790
结束字符。

344
00:14:54,790 --> 00:14:56,100
我们会在第二。

345
00:14:56,100 --> 00:15:01,020
但是，在这种情况下，有
这里没有第三个方块。

346
00:15:01,020 --> 00:15:06,390
所以任何数组中的最后一箱
的尺寸减去1。

347
00:15:06,390 --> 00:15:11,310
所以，如果我们有一个大小为n的数组，
第一盒是为零，最后一个是

348
00:15:11,310 --> 00:15:12,700
在n减1。

349
00:15:12,700 --> 00:15:14,970
在这种情况下，它不存在。

350
00:15:14,970 --> 00:15:17,970
也有一些是在这里
内存，但它不是我们的。

351
00:15:17,970 --> 00:15:18,460
我们并不拥有它。

352
00:15:18,460 --> 00:15:19,570
我们并没有要求它。

353
00:15:19,570 --> 00:15:22,606
因此，如果我们尝试访问它，我们将
做在一个位，我们很可能会

354
00:15:22,606 --> 00:15:24,970
惹上麻烦。

355
00:15:24,970 --> 00:15:29,180
>> 在这种情况下，我初始化我
三个变量的数组。

356
00:15:29,180 --> 00:15:36,195
我们把一箱零，两
在箱，三箱二。

357
00:15:36,195 --> 00:15:39,280
没有任何人有任何疑问，
有关初始化的数组？

358
00:15:39,280 --> 00:15:44,540

359
00:15:44,540 --> 00:15:46,970
>> 于是我们过刚才。

360
00:15:46,970 --> 00:15:52,725
比分，支架三，靠近支架，
不存在。

361
00:15:52,725 --> 00:15:58,130
我们从零开始编制索引，计算机科学，
所以我们开始计数为零。

362
00:15:58,130 --> 00:16:01,860
最后一箱提供给我们，这是
第三个框，但是它称为盒

363
00:16:01,860 --> 00:16:03,110
数二。

364
00:16:03,110 --> 00:16:05,790

365
00:16:05,790 --> 00:16:09,710
>> 而在下面，这是一种替代
初始化数组的方式。

366
00:16:09,710 --> 00:16:13,410
因此，而不是创建一个数组
线，灌装的第一个框，然后

367
00:16:13,410 --> 00:16:17,070
第二个框中，然后在第三个框，
在同一行中，你可以做到这一切。

368
00:16:17,070 --> 00:16:19,040
因此，在该行中，两个数组。

369
00:16:19,040 --> 00:16:23,460
这将创建完全相同的阵列
我们在这里，但它

370
00:16:23,460 --> 00:16:24,710
只是它在一行。

371
00:16:24,710 --> 00:16:29,740

372
00:16:29,740 --> 00:16:31,360
>> 现在，我们已经创建了我们的阵列。

373
00:16:31,360 --> 00:16:34,100
通常，一旦你创建一个数组，你
它想要做的事，无论是

374
00:16:34,100 --> 00:16:38,430
填写或得到的东西出来呢
并打印出来在屏幕上。

375
00:16:38,430 --> 00:16:42,270
在这种情况下，我们将通过我们的
分数数组，初始化

376
00:16:42,270 --> 00:16:44,740
的第一行，在这里在灰度。

377
00:16:44,740 --> 00:16:49,600
然后在第二行，我们开始
遍历数组。

378
00:16:49,600 --> 00:16:52,640
没有任何人有任何疑问，
一个for循环的结构？

379
00:16:52,640 --> 00:16:55,250

380
00:16:55,250 --> 00:16:56,400
>> 因此，这是for循环。

381
00:16:56,400 --> 00:16:59,530
我们有我们的初始条件，然后
我们的最终状态，然后我们

382
00:16:59,530 --> 00:17:01,160
迭代，我，每一个循环。

383
00:17:01,160 --> 00:17:05,579
而在此花括号中的
循环，会发生什么，如果我是运行

384
00:17:05,579 --> 00:17:06,290
这个程序？

385
00:17:06,290 --> 00:17:10,410
谁能告诉我，我们会得到什么？

386
00:17:10,410 --> 00:17:11,589
[？成熟度？ ？]

387
00:17:11,589 --> 00:17:13,819
>> MATU：打印所有分数
在每一行上。

388
00:17:13,819 --> 00:17:14,900
这将打印每个分数
在一个单独的行。

389
00:17:14,900 --> 00:17:16,300
>> JASON HIRSCHHORN：究竟
它会打印吗？

390
00:17:16,300 --> 00:17:19,790
>> 学生：它会打印一个，
然后两个，然后三个。

391
00:17:19,790 --> 00:17:20,235
>> JASON HIRSCHHORN：没错。

392
00:17:20,235 --> 00:17:23,490
它会打印一个，然后两个，然后
三，每一个单独的行，因为

393
00:17:23,490 --> 00:17:27,810
我们正在经历的数组，你会
看到第二个，在printf

394
00:17:27,810 --> 00:17:29,275
声明，分数。

395
00:17:29,275 --> 00:17:32,880
因此，在第一轮通过我们的
循环，i等于为零，这意味着我们

396
00:17:32,880 --> 00:17:34,640
获得得分为零的值 - 

397
00:17:34,640 --> 00:17:36,900
其中，如果我们回去
我们的图，是一个 - 

398
00:17:36,900 --> 00:17:38,630
并填写 - 

399
00:17:38,630 --> 00:17:39,700
哦，它说。

400
00:17:39,700 --> 00:17:41,680
这应该为％d。

401
00:17:41,680 --> 00:17:43,970
我会解决这个问题有点
我的手，你们。

402
00:17:43,970 --> 00:17:48,670
但我们呈现一个整数，所以
这里应该为％d，而不是％C。

403
00:17:48,670 --> 00:17:50,340
％c代表是什么？

404
00:17:50,340 --> 00:17:50,790
>> 学生：字符。

405
00:17:50,790 --> 00:17:52,680
>> JASON HIRSCHHORN：性格，正是。

406
00:17:52,680 --> 00:17:53,690
另一种是什么呢？

407
00:17:53,690 --> 00:17:56,260
如果你不想做一个％D
整数，还有什么可以做什么？

408
00:17:56,260 --> 00:17:57,000
>> 学生：我。

409
00:17:57,000 --> 00:17:59,180
>> JASON HIRSCHHORN％，完全相同。

410
00:17:59,180 --> 00:18:01,660
所以任何疑问迭代
通过数组？

411
00:18:01,660 --> 00:18:05,500

412
00:18:05,500 --> 00:18:07,800
所以会发生什么，如果我们做到这一点吗？

413
00:18:07,800 --> 00:18:10,290
而不是做i小于
三，我是少

414
00:18:10,290 --> 00:18:11,390
大于或等于3。

415
00:18:11,390 --> 00:18:13,420
当我们运行这段代码，会发生什么事？

416
00:18:13,420 --> 00:18:17,510

417
00:18:17,510 --> 00:18:18,940
是的，安妮？

418
00:18:18,940 --> 00:18:22,030
>> 学生：他们打算打印出来
第四行的怪异的东西。

419
00:18:22,030 --> 00:18:23,850
>> JASON HIRSCHHORN：所以你说的，是什么
要打印出怪异的东西

420
00:18:23,850 --> 00:18:24,390
第四行吗？

421
00:18:24,390 --> 00:18:25,750
没有任何人有一个答案
她的问题？

422
00:18:25,750 --> 00:18:28,940

423
00:18:28,940 --> 00:18:33,160
所以赔率是当
我们得到的 - 

424
00:18:33,160 --> 00:18:36,700
通过我们为第四轮
循环，就像你想，安妮，

425
00:18:36,700 --> 00:18:39,430
这将是分数支架三，
我们已经想通了，不

426
00:18:39,430 --> 00:18:41,990
存在的，我们要去尝试
和访问，打印

427
00:18:41,990 --> 00:18:43,350
出来，用一些方式。

428
00:18:43,350 --> 00:18:46,060
所以电脑可能会
我们生气。

429
00:18:46,060 --> 00:18:46,760
你说得对。

430
00:18:46,760 --> 00:18:48,830
>> 它可能完全退出程序。

431
00:18:48,830 --> 00:18:52,222
它可能会打印出来的东西
真不可思议。

432
00:18:52,222 --> 00:18:53,420
你不能说是肯定的。

433
00:18:53,420 --> 00:18:56,210
赔率是它可能会生气
你，只是马上退出。

434
00:18:56,210 --> 00:19:00,100
>> 但是，这是一个常见的​​错误，你就会有
你只是在关闭

435
00:19:00,100 --> 00:19:05,110
到底，这是一个错误，将
困扰你整个编码。

436
00:19:05,110 --> 00:19:09,350

437
00:19:09,350 --> 00:19:14,150
我喜欢做的仅仅是在
白板，经过每次迭代

438
00:19:14,150 --> 00:19:18,190
手头上或在纸上看到循环
发生了什么，然后你

439
00:19:18,190 --> 00:19:20,440
普遍意识到，哦，等一下，我不应该
已经小于或

440
00:19:20,440 --> 00:19:20,870
等于三。

441
00:19:20,870 --> 00:19:24,730
，这是我应该停止在两个
会发生什么，如果你的条件

442
00:19:24,730 --> 00:19:26,206
超过三种。

443
00:19:26,206 --> 00:19:29,120
有任何疑问，这么远吗？

444
00:19:29,120 --> 00:19:31,010
甜。

445
00:19:31,010 --> 00:19:33,360
>> 所以你打开你的电脑。

446
00:19:33,360 --> 00:19:36,760
我们要去给你两到三个
分钟写一个程序，

447
00:19:36,760 --> 00:19:40,460
创建一个数组整数
通过五个，然后打印出每个

448
00:19:40,460 --> 00:19:41,720
在新的一行的整数。

449
00:19:41,720 --> 00:19:44,330

450
00:19:44,330 --> 00:19:46,000
如果您有任何疑问，
举起你的手。

451
00:19:46,000 --> 00:19:48,140
我很高兴来的。

452
00:19:48,140 --> 00:19:50,630
就像我说的，让我们采取三种
分钟来写这篇文章。

453
00:19:50,630 --> 00:20:41,300

454
00:20:41,300 --> 00:20:45,110
是所有人都好，如果我去一个
新窗口，并关闭此？

455
00:20:45,110 --> 00:22:13,420

456
00:22:13,420 --> 00:22:15,520
>> 对不起，如果你还没有机会
完成，但我们要做到这一点

457
00:22:15,520 --> 00:22:17,310
现在一起。

458
00:22:17,310 --> 00:22:23,640
所以在屏幕上，我的＃include
cs50.h＃包括stdio.h中。

459
00:22:23,640 --> 00:22:26,090
有人可以告诉我是什么
这两行办？

460
00:22:26,090 --> 00:22:32,250

461
00:22:32,250 --> 00:22:33,155
迈克尔？

462
00:22:33,155 --> 00:22:40,030
>> 学生：他们包括库
CS50和史蒂夫

463
00:22:40,030 --> 00:22:44,210
保存供您使用
使您的生活更轻松。

464
00:22:44,210 --> 00:22:46,820
>> JASON HIRSCHHORN：所以你说他们
包括图书馆，一个CS50

465
00:22:46,820 --> 00:22:51,230
，cs50.h，另一种是
只是标准，自带

466
00:22:51,230 --> 00:22:53,510
C包，stdio.h中。

467
00:22:53,510 --> 00:22:54,890
你是什​​么意思，包括
图书馆，虽然？

468
00:22:54,890 --> 00:22:55,770
你能更具体一点吗？

469
00:22:55,770 --> 00:23:01,180
>> 学生：它使得你可以
使用某些码字有

470
00:23:01,180 --> 00:23:05,710
不必去功能发生
c的功能自己。

471
00:23:05,710 --> 00:23:08,730
>> JASON HIRSCHHORN：你能
给我一个例子吗？

472
00:23:08,730 --> 00:23:11,160
>> 学生：喜欢的printf
是您可以使用。

473
00:23:11,160 --> 00:23:11,860
>> JASON HIRSCHHORN：printf的。

474
00:23:11,860 --> 00:23:14,680
所以，你说的printf是那些
功能而不必

475
00:23:14,680 --> 00:23:19,840
写上自己的printf，printf是
实际上包含stdio.h中，所以你

476
00:23:19,840 --> 00:23:22,010
可以只使用它，并承担
它会奏效。

477
00:23:22,010 --> 00:23:28,270
stdio.h中，如果打开了这个文件，
这包括如何的printf

478
00:23:28,270 --> 00:23:31,620
作品，所有的代码为printf？

479
00:23:31,620 --> 00:23:33,105
你为什么摇头？

480
00:23:33,105 --> 00:23:35,710
>> 学生：因为刚才的头文件
包括函数的声明。

481
00:23:35,710 --> 00:23:36,400
>> JASON HIRSCHHORN：完全正确。

482
00:23:36,400 --> 00:23:39,680
头文件只是包括
在函数声明。

483
00:23:39,680 --> 00:23:42,950
所以基本上，当你编译这个，
打计数，我们将做一个

484
00:23:42,950 --> 00:23:48,070
第二，编译器知道，如果
使用了printf printf的存在。

485
00:23:48,070 --> 00:23:49,370
这是怎么回事某处被定义。

486
00:23:49,370 --> 00:23:51,200
这不是一个问题，你使用它。

487
00:23:51,200 --> 00:23:55,490
再后来，它会包括
实际上包含的和为零

488
00:23:55,490 --> 00:23:58,360
printf的实施和
将其与你的代码。

489
00:23:58,360 --> 00:24:01,935
你如何确保它包括
的和零点，也就是说，得到的字符串？

490
00:24:01,935 --> 00:24:05,670

491
00:24:05,670 --> 00:24:07,210
>> 学生：获取字符串cs50.h.

492
00:24:07,210 --> 00:24:07,830
>> JASON HIRSCHHORN：右。

493
00:24:07,830 --> 00:24:11,110
所以说得到的字符串存在，
在函数声明。

494
00:24:11,110 --> 00:24:15,410
但随后的1和0的二进制
文件实际上包含

495
00:24:15,410 --> 00:24:17,370
实施获取字符串？

496
00:24:17,370 --> 00:24:19,310
你如何确保
与你的程序？

497
00:24:19,310 --> 00:24:23,220
>> 学生：通过连接器
命令行参数。

498
00:24:23,220 --> 00:24:25,430
>> JASON HIRSCHHORN：通过连接器
在命令行参数。

499
00:24:25,430 --> 00:24:26,700
你怎么做到这一点呢？

500
00:24:26,700 --> 00:24:29,730
>> 学生：这是铛-L线

501
00:24:29,730 --> 00:24:30,480
>> JASON HIRSCHHORN：完全正确。

502
00:24:30,480 --> 00:24:32,900
你说CS50-L，对不对？

503
00:24:32,900 --> 00:24:34,940
这包括那些和零。

504
00:24:34,940 --> 00:24:36,460
>> 学生：但要确实
为你，对不对？

505
00:24:36,460 --> 00:24:37,010
>> JASON HIRSCHHORN：没错。

506
00:24:37,010 --> 00:24:40,390
make没有你，但最终，
你不会有厂名，或

507
00:24:40,390 --> 00:24:43,220
你就得做出
你自己的，所以这是一个

508
00:24:43,220 --> 00:24:43,940
好事要记住。

509
00:24:43,940 --> 00:24:47,350
如果你要使用其中的一个
其他图书馆，你不仅有

510
00:24:47,350 --> 00:24:49,490
写＃
然后图书馆。

511
00:24:49,490 --> 00:24:51,420
您还需要与其链接。

512
00:24:51,420 --> 00:24:54,480
而这两件事情是不同的。
-L CS50是不同的

513
00:24:54,480 --> 00:24:59,260
＃cs50.h.

514
00:24:59,260 --> 00:25:02,870
>> 然后我们有INT主要无效花括号，
现在我们要去代码

515
00:25:02,870 --> 00:25:03,590
主内。

516
00:25:03,590 --> 00:25:07,090
我这里有第一行是注释
说，创建一个数组

517
00:25:07,090 --> 00:25:08,820
与int的一到五。

518
00:25:08,820 --> 00:25:12,600
什么是一个很好的词来形容我
现在在屏幕上，只是

519
00:25:12,600 --> 00:25:14,170
里面主要的意见？

520
00:25:14,170 --> 00:25:15,722
我们称之为什么呢？

521
00:25:15,722 --> 00:25:16,820
>> 学生：伪代码。

522
00:25:16,820 --> 00:25:17,840
>> JASON HIRSCHHORN：伪代码。

523
00:25:17,840 --> 00:25:18,420
谢谢你，杰弗里。

524
00:25:18,420 --> 00:25:19,540
这是完全正确的。

525
00:25:19,540 --> 00:25:20,005
伪代码。

526
00:25:20,005 --> 00:25:22,854
有你们之前见过的伪代码？

527
00:25:22,854 --> 00:25:28,340
举起你的手，如果你使用
问题的伪代码之前设置一个。

528
00:25:28,340 --> 00:25:29,400
关于你的一半。

529
00:25:29,400 --> 00:25:32,700
>> 我会强烈建议使用
伪代码问题

530
00:25:32,700 --> 00:25:35,210
更小，更容易咬掉件。

531
00:25:35,210 --> 00:25:38,630
另外，如果你做伪代码，你
您的意见已经在很大程度上

532
00:25:38,630 --> 00:25:40,760
内置的，所以你不要有
回去揣摩

533
00:25:40,760 --> 00:25:42,450
你在做什么。

534
00:25:42,450 --> 00:25:44,730
因此，有人可以给我这个第一线
创建一个数组int类型之一

535
00:25:44,730 --> 00:25:45,980
通过五个？

536
00:25:45,980 --> 00:25:48,700

537
00:25:48,700 --> 00:25:49,130
你呢？

538
00:25:49,130 --> 00:25:53,350
>> 学生：诠释，然后你可以调用
任何号码，然后方

539
00:25:53,350 --> 00:25:54,830
支架五。

540
00:25:54,830 --> 00:25:57,820
>> JASON HIRSCHHORN：所以整型数，
方形支架五个。

541
00:25:57,820 --> 00:25:59,160
>> 学生：等于，
然后大括号。

542
00:25:59,160 --> 00:26:00,830
>> JASON HIRSCHHORN：等于，
大括号。

543
00:26:00,830 --> 00:26:01,830
>> 学生：一，二，三，四。

544
00:26:01,830 --> 00:26:05,566
>> JASON HIRSCHHORN：一，二，
三，四，五。

545
00:26:05,566 --> 00:26:07,390
>> 学生：那么大括号
然后分号。

546
00:26:07,390 --> 00:26:09,240
>> JASON HIRSCHHORN和卷曲
括号和分号。

547
00:26:09,240 --> 00:26:10,330
优秀的。

548
00:26:10,330 --> 00:26:12,210
打印出每个INT在新的一行。

549
00:26:12,210 --> 00:26:17,140
可以给别人
我该代码，好吗？

550
00:26:17,140 --> 00:26:17,530
[？成熟度？ ？]

551
00:26:17,530 --> 00:26:18,560
来吧。

552
00:26:18,560 --> 00:26:20,440
>> 学生：（

553
00:26:20,440 --> 00:26:21,750
>> JASON HIRSCHHORN：（

554
00:26:21,750 --> 00:26:23,740
>> 学生：INT I = 0

555
00:26:23,740 --> 00:26:26,070
>> JASON HIRSCHHORN：INT I = 0

556
00:26:26,070 --> 00:26:28,190
>> 学生：分号我不到五。

557
00:26:28,190 --> 00:26:31,680
>> JASON HIRSCHHORN：分号，
我小于5。

558
00:26:31,680 --> 00:26:33,600
>> 学生：分号，我+ +。

559
00:26:33,600 --> 00:26:35,140
>> JASON HIRSCHHORN：分号，I + +。

560
00:26:35,140 --> 00:26:37,720
>> 学生：休息括号，
然后开括号。

561
00:26:37,720 --> 00:26:39,410
>> JASON HIRSCHHORN：休息括号
两个大括号。

562
00:26:39,410 --> 00:26:40,510
在大括号内？

563
00:26:40,510 --> 00:26:47,640
>> 学生：当时的printf“％D / N”

564
00:26:47,640 --> 00:26:48,695
>> JASON HIRSCHHORN：很抱歉，挺住。

565
00:26:48,695 --> 00:26:52,330
printf的“％D / N，封闭的引号。

566
00:26:52,330 --> 00:26:55,980
>> 学生：那么封闭报价，
逗号，计数，支架I。

567
00:26:55,980 --> 00:26:58,350
>> JASON HIRSCHHORN：逗号，
数，支架í。

568
00:26:58,350 --> 00:26:59,970
>> 学生：对不起，数字支架。

569
00:26:59,970 --> 00:27:01,416
>> 的JASON HIRSCHHORN：数字，支架I。

570
00:27:01,416 --> 00:27:03,200
>> 学生：对不起。

571
00:27:03,200 --> 00:27:04,750
然后关闭括号，
分号。

572
00:27:04,750 --> 00:27:07,156
>> JASON HIRSCHHORN：休息
括号，分号。

573
00:27:07,156 --> 00:27:08,680
我要去拯救。

574
00:27:08,680 --> 00:27:12,670
我们要去计数。

575
00:27:12,670 --> 00:27:14,742
我怎么运行计数？

576
00:27:14,742 --> 00:27:16,470
>> 学生：反斜杠。

577
00:27:16,470 --> 00:27:17,180
>> 学生：点斜杠 - 

578
00:27:17,180 --> 00:27:18,050
>> JASON HIRSCHHORN：。/计数，准确。

579
00:27:18,050 --> 00:27:19,380
谢谢。 /计数。

580
00:27:19,380 --> 00:27:21,060
一，二，三，四，
五个新的生产线。

581
00:27:21,060 --> 00:27:22,110
看起来像它的工作。

582
00:27:22,110 --> 00:27:23,200
是的，诺亚？

583
00:27:23,200 --> 00:27:26,660
>> 学生：你也可以做到小于或
等于4，如i小于

584
00:27:26,660 --> 00:27:27,630
或等于4？

585
00:27:27,630 --> 00:27:31,190
少做有什么优势
五，或只是以不同的方式

586
00:27:31,190 --> 00:27:31,610
写它呢？

587
00:27:31,610 --> 00:27:35,280
>> JASON HIRSCHHORN：所以，问题是你
可以做得i是小于或

588
00:27:35,280 --> 00:27:37,450
等于四，而不是
i是少于五个。

589
00:27:37,450 --> 00:27:38,935
又会有同样的工作吗？

590
00:27:38,935 --> 00:27:39,760
>> 学生：它应该。

591
00:27:39,760 --> 00:27:39,860
>> JASON HIRSCHHORN：是的。

592
00:27:39,860 --> 00:27:41,660
它完全将工作一样。

593
00:27:41,660 --> 00:27:44,780
在文体上，它是一般小于
你会看到在第二个时

594
00:27:44,780 --> 00:27:48,160
我们的字符串，可以使用的东西
调用strlen的，你见过

595
00:27:48,160 --> 00:27:50,380
之前，来取得长度
的字符串。

596
00:27:50,380 --> 00:27:54,090
你不能小于
或等于strlen的。

597
00:27:54,090 --> 00:27:56,500
你可以做到小于或
等于strlen的减一。

598
00:27:56,500 --> 00:27:59,260
所以它只是更好
做小于strlen的。

599
00:27:59,260 --> 00:28:00,240
是吗？

600
00:28:00,240 --> 00:28:03,270
>> 学生：在实际测验，
我们必须提供我们的意见

601
00:28:03,270 --> 00:28:04,620
代码呢？

602
00:28:04,620 --> 00:28:06,130
>> JASON HIRSCHHORN：问题
测验，你

603
00:28:06,130 --> 00:28:07,760
有提供意见？

604
00:28:07,760 --> 00:28:12,050
因此，我们会更多地谈到测验时
他们来了，但一般来说，一个好的

605
00:28:12,050 --> 00:28:14,530
经验法则是，只要你
编写代码，提供意见。

606
00:28:14,530 --> 00:28:18,130
如果你得到的代码错了，但
发表意见的权利，你可能会得到一些

607
00:28:18,130 --> 00:28:22,280
信贷从我，如果我是分级
您的问题集，或交了白卷。

608
00:28:22,280 --> 00:28:24,660
因此，意见总是
好来提供。

609
00:28:24,660 --> 00:28:25,040
甜。

610
00:28:25,040 --> 00:28:25,460
计数。

611
00:28:25,460 --> 00:28:26,720
出色的工作。

612
00:28:26,720 --> 00:28:28,570
让我们继续前进。

613
00:28:28,570 --> 00:28:29,920
>> 字符串。

614
00:28:29,920 --> 00:28:30,630
字符串。

615
00:28:30,630 --> 00:28:31,730
我们已经看到了这个讲座之前。

616
00:28:31,730 --> 00:28:33,390
吹我的脑海里，当我
首先发现了这一点。

617
00:28:33,390 --> 00:28:37,240
它可能没有任何人吹的
想到这里，不过没关系。

618
00:28:37,240 --> 00:28:41,260
>> 字符串是字符数组，
他们最终，正如你自己所说，

619
00:28:41,260 --> 00:28:45,710
空终结者，
这是/ 0个字符。

620
00:28:45,710 --> 00:28:47,740
如果我们要画一个串上
板，我们将它画在这里。

621
00:28:47,740 --> 00:28:53,080

622
00:28:53,080 --> 00:28:56,420
所以，这是字符串有多长？

623
00:28:56,420 --> 00:28:56,680
抱歉。

624
00:28:56,680 --> 00:28:57,660
这是字符串有多长？

625
00:28:57,660 --> 00:28:57,910
>> 学生：[听不清]。

626
00:28:57,910 --> 00:28:59,010
>> JASON HIRSCHHORN：四？

627
00:28:59,010 --> 00:28:59,880
为什么是四个呢？

628
00:28:59,880 --> 00:29:02,240
>> 学生：因为第五位
是空字符。

629
00:29:02,240 --> 00:29:04,070
>> JASON HIRSCHHORN：所以第五位
是空字符。

630
00:29:04,070 --> 00:29:07,130
所以，如果我上运行的strlen
这一点，那就给我4。

631
00:29:07,130 --> 00:29:07,850
正确。

632
00:29:07,850 --> 00:29:11,640
而阵中，不过，如果我是
初始化这个数组，多少个空格

633
00:29:11,640 --> 00:29:13,444
我要问的吗？

634
00:29:13,444 --> 00:29:13,821
>> 学生：五。

635
00:29:13,821 --> 00:29:14,200
>> JASON HIRSCHHORN：五。

636
00:29:14,200 --> 00:29:17,650
我不得不问五，但我可以
在这里只把四个字符

637
00:29:17,650 --> 00:29:19,750
因为我需要把这些空
终结者就结束了。

638
00:29:19,750 --> 00:29:25,260
因此，我们打算写“ohai”
把空终止符结束时。

639
00:29:25,260 --> 00:29:31,820

640
00:29:31,820 --> 00:29:34,940
我们会说这是串
s等于这一点。

641
00:29:34,940 --> 00:29:36,610
什么是支架为零？

642
00:29:36,610 --> 00:29:40,210

643
00:29:40,210 --> 00:29:41,550
Ş支架零，安妮？

644
00:29:41,550 --> 00:29:41,950
>> 学生：O。

645
00:29:41,950 --> 00:29:45,400
>> JASON HIRSCHHORN：O型，正好。
Ş支架？

646
00:29:45,400 --> 00:29:48,200
Ş支架五？

647
00:29:48,200 --> 00:29:52,670

648
00:29:52,670 --> 00:29:53,955
Ş支架五？

649
00:29:53,955 --> 00:29:54,740
>> 学生：不存在。

650
00:29:54,740 --> 00:29:55,040
>> JASON HIRSCHHORN：不存在。

651
00:29:55,040 --> 00:29:57,050
完全正确。

652
00:29:57,050 --> 00:29:57,940
凉爽。

653
00:29:57,940 --> 00:30:03,120
任何理解问题
字符数组，字符串？

654
00:30:03,120 --> 00:30:03,870
OK，然后。

655
00:30:03,870 --> 00:30:05,440
你们更多的程序。

656
00:30:05,440 --> 00:30:09,190
写一个程序，要求用户
一个字符串，然后打印出每个

657
00:30:09,190 --> 00:30:11,880
在新的一行字符。

658
00:30:11,880 --> 00:30:14,160
因此，让我们三分钟的时间写
这个程序，然后，我们将对其进行编码

659
00:30:14,160 --> 00:30:15,410
作为一个群体。

660
00:30:15,410 --> 00:31:04,730

661
00:31:04,730 --> 00:31:04,830
>> 抱歉。

662
00:31:04,830 --> 00:31:06,470
你需要看到这一点吗？

663
00:31:06,470 --> 00:31:07,410
>> 学生：

664
00:31:07,410 --> 00:31:08,660
>> JASON HIRSCHHORN：确定。

665
00:31:08,660 --> 00:31:36,390

666
00:31:36,390 --> 00:31:40,605
让我们多一分钟的代码这一点，
或至少​​开始浏览网页就可以了。

667
00:31:40,605 --> 00:32:13,900

668
00:32:13,900 --> 00:32:17,020
>> 所以，你可以继续工作，但我要去
开始经历它。

669
00:32:17,020 --> 00:32:22,560
像以前一样，我在屏幕上
＃＃cs50.h，包括stdio.h中。

670
00:32:22,560 --> 00:32:24,020
int类型主作废。

671
00:32:24,020 --> 00:32:28,880
主要的大括号内，我有
两点意见，伪代码。

672
00:32:28,880 --> 00:32:30,980
其一是要求一个来自用户的字符串。

673
00:32:30,980 --> 00:32:33,900
二是打印出每个人
在新的一行字符。

674
00:32:33,900 --> 00:32:39,780
所以，安娜，你能不能给我问
一个来自用户的字符串？

675
00:32:39,780 --> 00:32:41,970
>> 学生：printf的。

676
00:32:41,970 --> 00:32:42,720
>> JASON HIRSCHHORN：printf的？

677
00:32:42,720 --> 00:32:45,050
>> 学生：是的。

678
00:32:45,050 --> 00:32:46,165
（

679
00:32:46,165 --> 00:32:47,610
>> JASON HIRSCHHORN：（

680
00:32:47,610 --> 00:32:49,300
>> 学生：“给我一个字符串。

681
00:32:49,300 --> 00:32:52,380
>> JASON HIRSCHHORN：“给
我STR  - 哎呀 - 

682
00:32:52,380 --> 00:32:53,710
字符串。

683
00:32:53,710 --> 00:32:59,980
>> 学生：/ N“）分号。

684
00:32:59,980 --> 00:33:02,300
>> JASON HIRSCHHORN：结束的字符串，
闭合的括号，分号。

685
00:33:02,300 --> 00:33:03,550
>> 学生：是的。

686
00:33:03,550 --> 00:33:09,080
然后，下一行，串
S =得到的字符串。

687
00:33:09,080 --> 00:33:11,240
>> JASON HIRSCHHORN：字符串
S =得到的字符串。

688
00:33:11,240 --> 00:33:11,665
>> 学生：是的。

689
00:33:11,665 --> 00:33:13,080
然后是（）

690
00:33:13,080 --> 00:33:14,365
>> JASON HIRSCHHORN：（）

691
00:33:14,365 --> 00:33:14,720
>> 学生：分号。

692
00:33:14,720 --> 00:33:15,540
>> JASON HIRSCHHORN：分号。

693
00:33:15,540 --> 00:33:16,890
太棒了。

694
00:33:16,890 --> 00:33:19,000
所以我要得到一个字符串
我要保存在什么？

695
00:33:19,000 --> 00:33:21,830
什么是变量
您创建的吗？

696
00:33:21,830 --> 00:33:23,290
>> 学生：String的。

697
00:33:23,290 --> 00:33:24,580
>> JASON HIRSCHHORN：变量
称为s。

698
00:33:24,580 --> 00:33:25,700
字符串类型。

699
00:33:25,700 --> 00:33:27,200
没错。

700
00:33:27,200 --> 00:33:30,080
接下来的事情，我们要的是打印出来
每个字符在新的一行。

701
00:33:30,080 --> 00:33:31,710
谁可以给我代码吗？

702
00:33:31,710 --> 00:33:32,110
[听不清]？

703
00:33:32,110 --> 00:33:33,000
你可以把它给我吗？

704
00:33:33,000 --> 00:33:33,580
>> 学生：当然。

705
00:33:33,580 --> 00:33:35,420
>> JASON HIRSCHHORN：让我们做吧。

706
00:33:35,420 --> 00:33:36,080
对不起。

707
00:33:36,080 --> 00:33:38,896
我不喜欢重复你说的话
因为你得到它的权利，但我

708
00:33:38,896 --> 00:33:42,100
有重复，当他们
抄写这一点，他们可以得到所有

709
00:33:42,100 --> 00:33:44,870
的文本改编出来。

710
00:33:44,870 --> 00:33:47,180
所以，你可以继续说话。

711
00:33:47,180 --> 00:33:48,590
不幸的是，我有
说你。

712
00:33:48,590 --> 00:33:49,510
我很抱歉，但 - 

713
00:33:49,510 --> 00:33:50,610
>> 学生：那很好。

714
00:33:50,610 --> 00:33:53,010
对于INT I = 0

715
00:33:53,010 --> 00:33:54,170
>> JASON HIRSCHHORN：INT I = 0

716
00:33:54,170 --> 00:33:56,740
>> 学生：我小于 - 

717
00:33:56,740 --> 00:33:58,206
>> JASON HIRSCHHORN：分号。

718
00:33:58,206 --> 00:34:00,650
>> 学生：在此之前，我们可以把一个
可变的，所以你得到的int名长度？

719
00:34:00,650 --> 00:34:01,870
>> JASON HIRSCHHORN：哦，你不要
想要把分号？

720
00:34:01,870 --> 00:34:02,310
确定。

721
00:34:02,310 --> 00:34:05,120
所以，你想要什么后做零？

722
00:34:05,120 --> 00:34:09,340
>> 学生：我想要得到的
字符串的长度和

723
00:34:09,340 --> 00:34:10,410
设置到一个变量？

724
00:34:10,410 --> 00:34:11,760
>> JASON HIRSCHHORN：OK，
所以我怎么做呢？

725
00:34:11,760 --> 00:34:17,636
>> 学生：所以你做INT长度=

726
00:34:17,636 --> 00:34:20,010
>> JASON HIRSCHHORN：诠释长度=

727
00:34:20,010 --> 00:34:22,230
>> 学生：S-T-R-L-E-N。

728
00:34:22,230 --> 00:34:24,260
>> JASON HIRSCHHORN：S-T-R-L-E-Ñ - 

729
00:34:24,260 --> 00:34:25,380
>> 学生：的S。

730
00:34:25,380 --> 00:34:25,790
括号内。

731
00:34:25,790 --> 00:34:27,920
>> JASON HIRSCHHORN：（S）。

732
00:34:27,920 --> 00:34:33,040
>> 学生：那么我认为你必须
把两个整数之间用分号隔开。

733
00:34:33,040 --> 00:34:34,590
>> JASON HIRSCHHORN：分号
零后？

734
00:34:34,590 --> 00:34:35,260
>> 学生：是啊。

735
00:34:35,260 --> 00:34:40,670
然后放一个分号后，
你说，我不到长度。

736
00:34:40,670 --> 00:34:43,250
我长度小于
是可变的。

737
00:34:43,250 --> 00:34:44,590
>> 学生：分号。

738
00:34:44,590 --> 00:34:45,790
>> JASON HIRSCHHORN：分号。

739
00:34:45,790 --> 00:34:46,290
>> 学生：我+ +。

740
00:34:46,290 --> 00:34:46,909
>> JASON HIRSCHHORN：我+ +。

741
00:34:46,909 --> 00:34:47,530
还有我们的for循环。

742
00:34:47,530 --> 00:34:48,860
OK，在for循环中。

743
00:34:48,860 --> 00:34:51,670
>> 学生：然后做的printf。

744
00:34:51,670 --> 00:34:53,340
>> JASON HIRSCHHORN：printf的。

745
00:34:53,340 --> 00:34:53,889
>> 学生：括号内。

746
00:34:53,889 --> 00:34:55,130
>> 的JASON HIRSCHHORN：括号，报价。

747
00:34:55,130 --> 00:34:59,930
>> 学生：括号，引号，％C / N。

748
00:34:59,930 --> 00:35:00,760
>> JASON HIRSCHHORN：％C，“确定”。

749
00:35:00,760 --> 00:35:01,670
>> 学生：/ N。

750
00:35:01,670 --> 00:35:03,470
>> JASON HIRSCHHORN / N。

751
00:35:03,470 --> 00:35:04,410
>> 学生：休息的报价。

752
00:35:04,410 --> 00:35:05,270
>> JASON HIRSCHHORN：闭合的引号。

753
00:35:05,270 --> 00:35:05,810
>> 学生：逗号。

754
00:35:05,810 --> 00:35:06,860
>> JASON HIRSCHHORN：逗号。

755
00:35:06,860 --> 00:35:07,800
>> 学生：S.

756
00:35:07,800 --> 00:35:08,070
>> JASON HIRSCHHORN：S。

757
00:35:08,070 --> 00:35:08,690
>> 学生：支架。

758
00:35:08,690 --> 00:35:10,230
>> JASON HIRSCHHORN：支架I。

759
00:35:10,230 --> 00:35:11,520
>> 学生：然后关闭括号。

760
00:35:11,520 --> 00:35:12,540
>> JASON HIRSCHHORN：封闭括号。

761
00:35:12,540 --> 00:35:13,660
>> 学生：分号。

762
00:35:13,660 --> 00:35:13,770
>> JASON HIRSCHHORN：分号。

763
00:35:13,770 --> 00:35:14,380
太棒了。

764
00:35:14,380 --> 00:35:16,890
因此，让我们保存这个。

765
00:35:16,890 --> 00:35:19,770
让拼写。

766
00:35:19,770 --> 00:35:20,040
哦，男孩。

767
00:35:20,040 --> 00:35:22,275
我有一对夫妇的错误。

768
00:35:22,275 --> 00:35:33,120
第11行的第一个错误，它说，
预期表达，它给

769
00:35:33,120 --> 00:35:36,910
我的错误，第二
整型，有错误。

770
00:35:36,910 --> 00:35:38,430
有一些错误围在那里。

771
00:35:38,430 --> 00:35:41,060
有谁知道什么样的错误，是吗？

772
00:35:41,060 --> 00:35:41,640
库尔特？

773
00:35:41,640 --> 00:35:44,108
>> 学生：我认为它应该
是一个逗号，而不是一个分号。

774
00:35:44,108 --> 00:35:46,010
>> ，JASON HIRSCHHORN：OK，逗号
而不是分号。

775
00:35:46,010 --> 00:35:47,340
因此，我们需要修复？

776
00:35:47,340 --> 00:35:47,655
>> 学生：

777
00:35:47,655 --> 00:35:48,930
>> JASON HIRSCHHORN：还有什么
我们需要修正？

778
00:35:48,930 --> 00:35:50,920
>> 学生：我们有包括string.h中。

779
00:35:50,920 --> 00:35:51,680
>> JASON HIRSCHHORN：包括string.h中。

780
00:35:51,680 --> 00:35:53,730
在哪里我需要的是什么？

781
00:35:53,730 --> 00:35:57,085
>> 学生：同一个地方，你包括
其他的东西，右

782
00:35:57,085 --> 00:35:59,560
之后包括stdio.h中。

783
00:35:59,560 --> 00:36:01,610
>> JASON HIRSCHHORN：让我们来看看如果这样运行
首先是因为一般来说，我喜欢

784
00:36:01,610 --> 00:36:06,360
解决一件事第一，然后运行
它，然后看看我们得到的错误。

785
00:36:06,360 --> 00:36:11,620
因此，我们要清除终端
与控制n，让我们做法术。

786
00:36:11,620 --> 00:36:15,190

787
00:36:15,190 --> 00:36:18,770
因此，第11行的另一个错误。

788
00:36:18,770 --> 00:36:20,540
预期分号。

789
00:36:20,540 --> 00:36:22,640
而且我还得到
此线路上的错误。

790
00:36:22,640 --> 00:36:25,270
所以，还没有给我一个错误说
不明白strlen的是，

791
00:36:25,270 --> 00:36:28,980
但它给我的错误
行，所以什么是错的？

792
00:36:28,980 --> 00:36:29,690
马克？

793
00:36:29,690 --> 00:36:30,940
马库斯。

794
00:36:30,940 --> 00:36:32,570
>> 学生：你必须删除
第二个int类型声明？

795
00:36:32,570 --> 00:36:34,990
>> JASON HIRSCHHORN：删除
第二个int。

796
00:36:34,990 --> 00:36:35,710
让我们试试这个。

797
00:36:35,710 --> 00:36:37,600
现在清除的终端。

798
00:36:37,600 --> 00:36:40,130
让拼写。

799
00:36:40,130 --> 00:36:40,490
错误。

800
00:36:40,490 --> 00:36:42,890
隐式声明库
strlen函数。

801
00:36:42,890 --> 00:36:44,270
所以，现在我们看到这个错误。

802
00:36:44,270 --> 00:36:45,760
我们需要包括什么？

803
00:36:45,760 --> 00:36:46,660
>> 学生：string.h中。

804
00:36:46,660 --> 00:36:51,880
>> JASON HIRSCHHORN：包括string.h中，
我们要做的＃include string.h中的顶部

805
00:36:51,880 --> 00:36:52,920
在屏幕上。

806
00:36:52,920 --> 00:36:55,450
让我们保存，拼写。

807
00:36:55,450 --> 00:36:56,970
现在编译。

808
00:36:56,970 --> 00:37:01,970
所以，再一次的事情，我们需要
记得在for循环时，12号线

809
00:37:01,970 --> 00:37:08,010
我们设置它，INT I = 0，
长度= strlen的（）。

810
00:37:08,010 --> 00:37:09,350
>> 这是一个很好的策略。

811
00:37:09,350 --> 00:37:12,590
这样的风格是伟大的，
这是伟大的设计。

812
00:37:12,590 --> 00:37:15,620
我们可以进入这些原因后，
但这样一来，你只需要调用

813
00:37:15,620 --> 00:37:19,040
strlen的一次，而不是每一个
时间运行循环。

814
00:37:19,040 --> 00:37:22,255
但是，您需要使用一个逗号
你不需要重新诠释。

815
00:37:22,255 --> 00:37:24,180
如果你宣布这两个
变量在一起，你

816
00:37:24,180 --> 00:37:26,850
不需要再次诠释。

817
00:37:26,850 --> 00:37:29,820
然后，如果你要使用strlen
这是另一种库

818
00:37:29,820 --> 00:37:33,560
的功能不包括在
stdio.h中或cs50.h的的，使

819
00:37:33,560 --> 00:37:35,310
一定要包括string.h中。

820
00:37:35,310 --> 00:37:35,900
库尔特？

821
00:37:35,900 --> 00:37:39,085
>> 学生：那么，如果你并不需要
说是什么类型的长度，是否

822
00:37:39,085 --> 00:37:40,290
意味着它必须是一个int？

823
00:37:40,290 --> 00:37:41,930
你不能有两个不同的
类型吗？

824
00:37:41,930 --> 00:37:43,290
>> JASON HIRSCHHORN：所以，你可以
有两种不同的类型。

825
00:37:43,290 --> 00:37:45,730
长度是一个int在这里，虽然。

826
00:37:45,730 --> 00:37:48,590
长度是一个int，因为它是逗号
然后同样的事情。

827
00:37:48,590 --> 00:37:50,460
>> 学生：所以它假定它是怎么回事
作为第一个是相同的吗？

828
00:37:50,460 --> 00:37:52,423
>> JASON HIRSCHHORN：没错。

829
00:37:52,423 --> 00:37:54,970
我们不打算现在做到这一点，但你
可以包括两个变量对

830
00:37:54,970 --> 00:37:57,080
同一个联机使用一种数据类型。

831
00:37:57,080 --> 00:38:01,415
所以诠释的x，y将创建
两个变量。

832
00:38:01,415 --> 00:38:05,830

833
00:38:05,830 --> 00:38:10,770
因此，整数X，Y，如果我们做的是，它给
我一个未使用的变量x和y，因为

834
00:38:10,770 --> 00:38:12,020
我们不使用它们。

835
00:38:12,020 --> 00:38:17,950

836
00:38:17,950 --> 00:38:21,650
所以把无效之前，仅仅是一个
花哨的技巧，如果你不使用

837
00:38:21,650 --> 00:38:22,810
的东西，要使用它。

838
00:38:22,810 --> 00:38:26,300
但是，正如你看到的，我创建了x和y
在同一线路上用逗号。

839
00:38:26,300 --> 00:38:28,450
它创建两个整数
就在这里。

840
00:38:28,450 --> 00:38:31,560
所以，是的，完全可以创建
两件事情在同一行上

841
00:38:31,560 --> 00:38:33,720
用逗号分隔。

842
00:38:33,720 --> 00:38:35,470
让我们摆脱这些，虽然。

843
00:38:35,470 --> 00:38:36,370
>> 因此，有法术。

844
00:38:36,370 --> 00:38:39,200
谢谢你们为我们编码。

845
00:38:39,200 --> 00:38:43,040
让我们把它更多的时间，运行它。

846
00:38:43,040 --> 00:38:44,580
给我一个字符串。

847
00:38:44,580 --> 00:38:45,580
[听不清]，你做了大部分。

848
00:38:45,580 --> 00:38:47,910
字符串是什么？

849
00:38:47,910 --> 00:38:48,250
>> 学生：您好。

850
00:38:48,250 --> 00:38:50,110
>> JASON HIRSCHHORN：你好。

851
00:38:50,110 --> 00:38:52,810
H-E-L-L-O，同一行上的每个字符。

852
00:38:52,810 --> 00:38:53,700
看起来不错。

853
00:38:53,700 --> 00:38:54,750
让我们再次运行它。

854
00:38:54,750 --> 00:38:56,050
总是要检查
为一角案件。

855
00:38:56,050 --> 00:38:57,750
有什么好的角落的情况进行检查？

856
00:38:57,750 --> 00:39:00,250

857
00:39:00,250 --> 00:39:00,890
>> 学生：多少？

858
00:39:00,890 --> 00:39:02,240
>> JASON HIRSCHHORN：一个数字。

859
00:39:02,240 --> 00:39:06,580
所以，我会投入1，它打印出1。

860
00:39:06,580 --> 00:39:08,970
它不要求的信件，所以
它看起来像数字工作。

861
00:39:08,970 --> 00:39:09,890
好角落的情况进行检查。

862
00:39:09,890 --> 00:39:11,740
什么是另一个很好的角落
检查的情况？

863
00:39:11,740 --> 00:39:12,420
>> 学生：一个空字符串。

864
00:39:12,420 --> 00:39:12,910
>> JASON HIRSCHHORN：嗯？

865
00:39:12,910 --> 00:39:13,880
>> 学生：喜欢一个空字符串。

866
00:39:13,880 --> 00:39:14,400
>> JASON HIRSCHHORN：空字符串。

867
00:39:14,400 --> 00:39:16,730
所以，让我们不要把任何东西。

868
00:39:16,730 --> 00:39:18,660
什么被打印出来？

869
00:39:18,660 --> 00:39:19,090
>> 学生：没有。

870
00:39:19,090 --> 00:39:19,870
>> JASON HIRSCHHORN：没有。

871
00:39:19,870 --> 00:39:20,555
好像它的工作原理。

872
00:39:20,555 --> 00:39:23,790
你可以尝试更多的角的情况下，但
一般的数字，不同的数据

873
00:39:23,790 --> 00:39:26,160
伟大的尝试，也什么都不是。

874
00:39:26,160 --> 00:39:29,180
没有，零，底片总是
伟大的事情，尝试和活动

875
00:39:29,180 --> 00:39:33,140
测试应该，事情当然我们会测试
和检查50测试。

876
00:39:33,140 --> 00:39:34,720
任何问题spell.c？

877
00:39:34,720 --> 00:39:37,752

878
00:39:37,752 --> 00:39:39,310
>> OK，让我们的后脑勺。

879
00:39:39,310 --> 00:39:42,420
我还有一个程序
你们写。

880
00:39:42,420 --> 00:39:44,700
它称为students.c。

881
00:39:44,700 --> 00:39:49,020
这是一个程序，要求用户
五个名字，然后随机选择

882
00:39:49,020 --> 00:39:51,600
打印出的名字之一。

883
00:39:51,600 --> 00:39:54,840
这个程序是多一点点
参与比过去两年中，我们写道，

884
00:39:54,840 --> 00:39:58,080
那么，为什么我们不采取五分钟
单独代码，然后我们会

885
00:39:58,080 --> 00:40:00,130
代码为一组。

886
00:40:00,130 --> 00:40:03,795
>> 该方案还涉及到一些东西
你可能没有见过，所以如果

887
00:40:03,795 --> 00:40:06,390
你有一个问题，怎么办
我这样做，举起你的手。

888
00:40:06,390 --> 00:40:08,530
我会过来和指向你
在正确的方向。

889
00:40:08,530 --> 00:40:10,820
但我们也这样做，因为这
将是一个很好的方式来介绍一些

890
00:40:10,820 --> 00:40:12,070
是棘手的话题。

891
00:40:12,070 --> 00:44:14,600

892
00:44:14,600 --> 00:44:15,560
>> 因此，它的工作原理，对不对？

893
00:44:15,560 --> 00:44:17,580
>> 学生：是啊。

894
00:44:17,580 --> 00:44:19,180
>> JASON HIRSCHHORN：每当你打开一个
习题集，有很多方法可以做到

895
00:44:19,180 --> 00:44:20,790
，但有些更
优雅的比别人多。

896
00:44:20,790 --> 00:44:29,000

897
00:44:29,000 --> 00:44:31,110
让我们长驱直入

898
00:44:31,110 --> 00:44:32,880
＃包括cs50.h.服务

899
00:44:32,880 --> 00:44:34,250
＃包括stdio.h中。

900
00:44:34,250 --> 00:44:37,240
int主要的空隙中，花括号。

901
00:44:37,240 --> 00:44:39,430
大括号内，
我有两点意见。

902
00:44:39,430 --> 00:44:41,500
第一个问
5名用户。

903
00:44:41,500 --> 00:44:46,580
第二个是，随机选择
打印出来的名字之一。

904
00:44:46,580 --> 00:44:50,250
因此，让我们做的第一个，问
5名用户。

905
00:44:50,250 --> 00:44:53,730
谁已要求用户5名
并能告诉我该怎么办？

906
00:44:53,730 --> 00:44:56,760

907
00:44:56,760 --> 00:44:58,570
只有两个人做的第一部分。

908
00:44:58,570 --> 00:45:00,150
三个人做的第一部分。

909
00:45:00,150 --> 00:45:00,670
四，五。

910
00:45:00,670 --> 00:45:03,140
汤姆，你怎么办呢？

911
00:45:03,140 --> 00:45:09,940
>> 学生：你声明一个字符串
然后将其命名，支架五。

912
00:45:09,940 --> 00:45:12,070
>> JASON HIRSCHHORN：字符串
命名支架五。

913
00:45:12,070 --> 00:45:15,350
那么，什么是做这行，
字符串名称支架五？

914
00:45:15,350 --> 00:45:17,800
>> 学生：你会声明
一个字符串数组。

915
00:45:17,800 --> 00:45:19,000
>> JASON HIRSCHHORN：这是
一个字符串数组。

916
00:45:19,000 --> 00:45:21,590
多少字符串会
适合在这里吗？

917
00:45:21,590 --> 00:45:22,010
>> 学生：五。

918
00:45:22,010 --> 00:45:22,320
>> JASON HIRSCHHORN：五。

919
00:45:22,320 --> 00:45:22,660
优秀的。

920
00:45:22,660 --> 00:45:26,360
我们要调用它的名字，因为
我们要得到多个。

921
00:45:26,360 --> 00:45:27,790
OK，接下来呢？

922
00:45:27,790 --> 00:45:29,270
>> 学生：那么你
有一个for循环 - 

923
00:45:29,270 --> 00:45:30,060
>> JASON HIRSCHHORN：For循环。

924
00:45:30,060 --> 00:45:33,035
>> 学生： - 对于i = 0。

925
00:45:33,035 --> 00:45:37,040
>> JASON HIRSCHHORN：为（int i = 0。

926
00:45:37,040 --> 00:45:38,270
>> 学生：分号。

927
00:45:38,270 --> 00:45:38,880
>> JASON HIRSCHHORN：分号。

928
00:45:38,880 --> 00:45:39,790
>> 学生：我不到五。

929
00:45:39,790 --> 00:45:41,310
>> JASON HIRSCHHORN：我不到五。

930
00:45:41,310 --> 00:45:42,230
>> 学生：分号。

931
00:45:42,230 --> 00:45:42,560
>> JASON HIRSCHHORN：分号。

932
00:45:42,560 --> 00:45:43,380
>> 学生：我+ +。

933
00:45:43,380 --> 00:45:46,050
>> JASON HIRSCHHORN：我+ +。

934
00:45:46,050 --> 00:45:47,100
>> 学生：然后关闭括号。

935
00:45:47,100 --> 00:45:48,600
>> JASON HIRSCHHORN：闭合的括号，
然后一些大括号。

936
00:45:48,600 --> 00:45:50,050
花括号内的？

937
00:45:50,050 --> 00:45:51,423
>> 学生：printf的。

938
00:45:51,423 --> 00:45:52,535
>> JASON HIRSCHHORN：printf的。

939
00:45:52,535 --> 00:45:56,200
>> 学生：开括号，名称为％d。

940
00:45:56,200 --> 00:45:57,090
>> JASON HIRSCHHORN：对不起？

941
00:45:57,090 --> 00:45:57,660
>> 学生：名称。

942
00:45:57,660 --> 00:45:58,200
>> JASON HIRSCHHORN：名称。

943
00:45:58,200 --> 00:46:01,700
>> 学生：空间，然后％D。

944
00:46:01,700 --> 00:46:02,950
>> JASON HIRSCHHORN：名称，空间，％D。

945
00:46:02,950 --> 00:46:05,630

946
00:46:05,630 --> 00:46:10,820
>> 学生：/ N，然后关闭。

947
00:46:10,820 --> 00:46:15,070
>> JASON HIRSCHHORN：所以名称，空间，
％D / N，右括号。

948
00:46:15,070 --> 00:46:17,730
>> 学生：逗号，I + 1。

949
00:46:17,730 --> 00:46:19,390
对不起。

950
00:46:19,390 --> 00:46:21,040
封闭报价，然后逗号，我+1。

951
00:46:21,040 --> 00:46:24,400
>> JASON HIRSCHHORN：休息
引号，逗号，I +1。

952
00:46:24,400 --> 00:46:25,850
>> 学生：是的。

953
00:46:25,850 --> 00:46:27,650
然后下一行 - 

954
00:46:27,650 --> 00:46:29,400
>> JASON HIRSCHHORN：+ 1。

955
00:46:29,400 --> 00:46:31,600
>> 学生：是的。

956
00:46:31,600 --> 00:46:36,440
然后下一张幻灯片
名称支架I。

957
00:46:36,440 --> 00:46:39,000
>> JASON HIRSCHHORN：下一行
名称支架I。

958
00:46:39,000 --> 00:46:41,360
>> 学生：获得字符串。

959
00:46:41,360 --> 00:46:43,460
>> JASON HIRSCHHORN：=  - 

960
00:46:43,460 --> 00:46:44,510
资本G-E-T  - 

961
00:46:44,510 --> 00:46:45,530
字符串。

962
00:46:45,530 --> 00:46:47,800
哎呀，对不起。

963
00:46:47,800 --> 00:46:49,050
>> 学生：开放式，封闭式括号
然后 - 

964
00:46:49,050 --> 00:46:50,940
>> JASON HIRSCHHORN：开放，封闭括号。

965
00:46:50,940 --> 00:46:51,030
>> 学生：分号。

966
00:46:51,030 --> 00:46:52,500
>> JASON HIRSCHHORN：分号。

967
00:46:52,500 --> 00:46:57,545
好了，你初始化数组
字符串，名称，然后经过一个

968
00:46:57,545 --> 00:47:02,720
for循环，并打印出一些五倍
提示给用户，然后存储

969
00:47:02,720 --> 00:47:03,360
五根弦。

970
00:47:03,360 --> 00:47:08,090
没有任何人有任何
调整？

971
00:47:08,090 --> 00:47:10,030
汤姆，我想每个人都
同意你的。

972
00:47:10,030 --> 00:47:10,880
看起来还不错。

973
00:47:10,880 --> 00:47:11,660
确定。

974
00:47:11,660 --> 00:47:14,830
你为什么要这么做i +1的，但？

975
00:47:14,830 --> 00:47:18,000
>> 学生：我的意思是，没有
是的，但我+1，它是

976
00:47:18,000 --> 00:47:19,700
名称命名五。

977
00:47:19,700 --> 00:47:21,930
否则，这将是名
仅举四个零。

978
00:47:21,930 --> 00:47:24,400
>> JASON HIRSCHHORN：所以，你做了我+1
因为否则它将有

979
00:47:24,400 --> 00:47:27,060
通过四个零打印出来，因为
这电脑怎么想的，但人类

980
00:47:27,060 --> 00:47:28,530
真的不读这样的。

981
00:47:28,530 --> 00:47:30,190
这是另一回事
你会遇到的问题。

982
00:47:30,190 --> 00:47:33,210
有时，当你打印出来的东西
给用户，你会想它

983
00:47:33,210 --> 00:47:35,733
有点漂亮，做
i +1的在这种情况下，是一个

984
00:47:35,733 --> 00:47:37,430
方式，使其更漂亮。

985
00:47:37,430 --> 00:47:41,380
>> 我也看到了五进行两次，字符串名称
范围是5，i是小于5。

986
00:47:41,380 --> 00:47:42,430
我知道你从哪里得到的五个。

987
00:47:42,430 --> 00:47:44,890
我告诉你猜对了
五个名字。

988
00:47:44,890 --> 00:47:49,000
但是，如果我们想使代码
有点更强大的，有一件事我们

989
00:47:49,000 --> 00:47:53,110
能做的就出在这里，外面的int，
我们可以做这样的事情，

990
00:47:53,110 --> 00:47:57,070
＃定义，我们可以做名称5。

991
00:47:57,070 --> 00:48:01,580

992
00:48:01,580 --> 00:48:05,390
>> 所以基本上，无论我写的资本
N，资本大写M，A，大写字母E，

993
00:48:05,390 --> 00:48:08,890
大写字母S，则该字符串，它将取代
5代码。

994
00:48:08,890 --> 00:48:11,530

995
00:48:11,530 --> 00:48:13,445
还是让我们只是把它 - 我们将
只需拨打号码。

996
00:48:13,445 --> 00:48:17,190
所以我定义全部大写
号码为5。

997
00:48:17,190 --> 00:48:22,830
>> 所以，现在无论我有5号，我
可以将其替换所有瓶盖号码。

998
00:48:22,830 --> 00:48:26,880
而现在，如果我想改变号码
名字，所有我需要做的是

999
00:48:26,880 --> 00:48:31,350
这一条线，4号线，在那里我有
＃定义5号，改到10，

1000
00:48:31,350 --> 00:48:34,340
或改变4。

1001
00:48:34,340 --> 00:48:37,400
当你的代码越长，你不是
要记住所有的地方，你

1002
00:48:37,400 --> 00:48:41,630
把你想要多少名，并在
为了让你不要错过，这是

1003
00:48:41,630 --> 00:48:45,490
做到这一点，找到一个很好的方式
往上顶，然后只使用该短语

1004
00:48:45,490 --> 00:48:46,400
各地你的代码。

1005
00:48:46,400 --> 00:48:46,780
马库斯？

1006
00:48:46,780 --> 00:48:49,780
>> 学生：那是风格的首选
不是全局定义

1007
00:48:49,780 --> 00:48:51,270
常数n？

1008
00:48:51,270 --> 00:48:53,760
>> JASON HIRSCHHORN：是
文体不是全局的首选

1009
00:48:53,760 --> 00:48:54,980
定义一个常数n？

1010
00:48:54,980 --> 00:48:59,036
所以你说你能
做数= 5？

1011
00:48:59,036 --> 00:49:01,300
>> 学生：他们有辅音
在C或没有？

1012
00:49:01,300 --> 00:49:02,720
>> JASON HIRSCHHORN或const  - 等于。

1013
00:49:02,720 --> 00:49:04,275
所以，你说的只是
一个全局变量？

1014
00:49:04,275 --> 00:49:04,990
>> 学生：是啊。

1015
00:49:04,990 --> 00:49:08,670
>> JASON HIRSCHHORN：文体，
有没有一定的权利

1016
00:49:08,670 --> 00:49:12,050
回答，但那些都更好
不仅仅是扔这些随机

1017
00:49:12,050 --> 00:49:12,960
整个代码中的数字。

1018
00:49:12,960 --> 00:49:14,650
我们称他们为幻数。

1019
00:49:14,650 --> 00:49:16,450
当我看看你的代码或当
任何人的阅读，通过它，他们

1020
00:49:16,450 --> 00:49:18,790
要的不只是这些随机数
没有意义的。

1021
00:49:18,790 --> 00:49:22,420
连号26，它一般是
字母表中的字母数，

1022
00:49:22,420 --> 00:49:28,870
这是更好地定义字母往上顶
并保存在该字符串中的26号，

1023
00:49:28,870 --> 00:49:29,550
如果是有道理的。

1024
00:49:29,550 --> 00:49:33,210
>> 或者问题上设置一个，而不是 - 
再次，我们不谈论这个在

1025
00:49:33,210 --> 00:49:37,020
的时候，但不是仅仅抛出
到处25或10，你可以

1026
00:49:37,020 --> 00:49:41,860
节省25号的季度或10
毛钱，这使得它更容易

1027
00:49:41,860 --> 00:49:44,140
无论是谁，通过阅读你的代码
明白你为什么选择了这个数字。

1028
00:49:44,140 --> 00:49:46,540
，也为你，如果你曾经想要的
更新你的代码，这使得它有点

1029
00:49:46,540 --> 00:49:47,290
更健壮。

1030
00:49:47,290 --> 00:49:48,070
是吗？

1031
00:49:48,070 --> 00:49:50,830
>> 学生：这是代码也将
后为我们提供？

1032
00:49:50,830 --> 00:49:52,453
>> JASON HIRSCHHORN：所有这些代码
我们一起写的是

1033
00:49:52,453 --> 00:49:54,620
将通过电子邮件发送给你
家伙。

1034
00:49:54,620 --> 00:49:55,740
是。

1035
00:49:55,740 --> 00:49:58,040
因此，要求用户5名。

1036
00:49:58,040 --> 00:50:00,280
随机选择和打印
的名称之一。

1037
00:50:00,280 --> 00:50:00,940
谁这样做行吗？

1038
00:50:00,940 --> 00:50:02,230
这是这里最棘手的线。

1039
00:50:02,230 --> 00:50:02,450
对不起，汤姆。

1040
00:50:02,450 --> 00:50:05,510
你做了一个很好的工作，但
这是一个有点棘手。

1041
00:50:05,510 --> 00:50:06,600
马库斯，请便。

1042
00:50:06,600 --> 00:50:10,180
>> 学生：那么首先，你要
需要包含stdlib.h中time.h中

1043
00:50:10,180 --> 00:50:13,200
>> JASON HIRSCHHORN：所以你说在
顶部，包括两个库。

1044
00:50:13,200 --> 00:50:18,830
你要我包括S-T-D-L-I-乙
点H，标准库，

1045
00:50:18,830 --> 00:50:19,760
是另一个人呢？

1046
00:50:19,760 --> 00:50:21,010
>> 学生：time.h中

1047
00:50:21,010 --> 00:50:25,130

1048
00:50:25,130 --> 00:50:27,840
>> JASON HIRSCHHORN：＃包括time.h中

1049
00:50:27,840 --> 00:50:29,470
因此，这些都是两个库。

1050
00:50:29,470 --> 00:50:31,790
我假设现在我们将要使用
在这些中所包含的功能

1051
00:50:31,790 --> 00:50:34,240
二，这就是为什么你需要
包括他们？

1052
00:50:34,240 --> 00:50:36,980
>> 学生：那么，你先
会想要写srand函数。

1053
00:50:36,980 --> 00:50:38,770
>> JASON HIRSCHHORN：函数srand。

1054
00:50:38,770 --> 00:50:42,070
>> 学生：（（0）

1055
00:50:42,070 --> 00:50:42,700
>> JASON HIRSCHHORN：对不起。

1056
00:50:42,700 --> 00:50:45,580
函数srand（时间（

1057
00:50:45,580 --> 00:50:46,890
>> 学生：0。

1058
00:50:46,890 --> 00:50:47,230
>> JASON HIRSCHHORN：0。

1059
00:50:47,230 --> 00:50:49,990
>> 学生：）），分号。

1060
00:50:49,990 --> 00:50:51,320
>> JASON HIRSCHHORN：另一个封闭的括号？

1061
00:50:51,320 --> 00:50:51,650
分号。

1062
00:50:51,650 --> 00:50:53,610
我要去只需更换
您零NULL。

1063
00:50:53,610 --> 00:50:55,980
它会做同样的事情，但
通常，你会看到NULL，

1064
00:50:55,980 --> 00:50:57,720
我们会谈论这个
在第二行。

1065
00:50:57,720 --> 00:50:58,580
>> 学生：文体更好？

1066
00:50:58,580 --> 00:51:02,240
>> JASON HIRSCHHORN：一般来说，人们
右NULL，但同样的事情。

1067
00:51:02,240 --> 00:51:05,010
>> 学生：INT名。

1068
00:51:05,010 --> 00:51:06,490
>> JASON HIRSCHHORN：诠释名。

1069
00:51:06,490 --> 00:51:07,280
>> 学生：=

1070
00:51:07,280 --> 00:51:07,780
>> JASON HIRSCHHORN：=

1071
00:51:07,780 --> 00:51:08,580
>> 学生：兰特。

1072
00:51:08,580 --> 00:51:09,340
>> JASON HIRSCHHORN：兰特。

1073
00:51:09,340 --> 00:51:10,420
>> 学生：（）

1074
00:51:10,420 --> 00:51:11,500
>> JASON HIRSCHHORN：（）

1075
00:51:11,500 --> 00:51:12,850
>> 学生：模数。

1076
00:51:12,850 --> 00:51:14,310
>> JASON HIRSCHHORN：模是什么？

1077
00:51:14,310 --> 00:51:14,970
字符？

1078
00:51:14,970 --> 00:51:16,000
％字符？

1079
00:51:16,000 --> 00:51:17,790
>> 学生：百分比字符。

1080
00:51:17,790 --> 00:51:19,521
模数定义往上顶。

1081
00:51:19,521 --> 00:51:22,030
>> JASON HIRSCHHORN：模数。

1082
00:51:22,030 --> 00:51:24,052
>> 学生：分号。

1083
00:51:24,052 --> 00:51:24,660
>> JASON HIRSCHHORN：分号。

1084
00:51:24,660 --> 00:51:27,820
>> 学生：那么新生产线中，将printf。

1085
00:51:27,820 --> 00:51:28,460
>> JASON HIRSCHHORN：printf的。

1086
00:51:28,460 --> 00:51:29,730
>> 学生：（

1087
00:51:29,730 --> 00:51:30,620
>> JASON HIRSCHHORN：（

1088
00:51:30,620 --> 00:51:31,650
>> 学生：“

1089
00:51:31,650 --> 00:51:32,630
>> JASON HIRSCHHORN：“

1090
00:51:32,630 --> 00:51:35,320
>> 学生：％S / N

1091
00:51:35,320 --> 00:51:37,220
>> JASON HIRSCHHORN：％S / N

1092
00:51:37,220 --> 00:51:38,420
>> 学生：“

1093
00:51:38,420 --> 00:51:40,640
>> JASON HIRSCHHORN：％S / N“

1094
00:51:40,640 --> 00:51:43,540
>> 学生：逗号，空间名称。

1095
00:51:43,540 --> 00:51:44,350
>> JASON HIRSCHHORN：空间 - 

1096
00:51:44,350 --> 00:51:46,300
>> 学生：哦，我猜，
我们在这里？

1097
00:51:46,300 --> 00:51:48,640
>> JASON HIRSCHHORN：我们称它的名字。

1098
00:51:48,640 --> 00:51:52,360
>> 学生：打开支架，名称。

1099
00:51:52,360 --> 00:51:55,090
>> JASON HIRSCHHORN打开支架，姓名。

1100
00:51:55,090 --> 00:51:55,850
>> 学生：休息支架。

1101
00:51:55,850 --> 00:51:56,490
>> JASON HIRSCHHORN：休息支架。

1102
00:51:56,490 --> 00:51:57,460
>> 学生：）

1103
00:51:57,460 --> 00:51:58,800
>> JASON HIRSCHHORN：）

1104
00:51:58,800 --> 00:51:59,440
>> 学生：分号。

1105
00:51:59,440 --> 00:52:00,410
>> JASON HIRSCHHORN：分号。

1106
00:52:00,410 --> 00:52:01,500
OK，让我们保存。

1107
00:52:01,500 --> 00:52:04,410
让我们把这段代码。

1108
00:52:04,410 --> 00:52:06,365
学生。

1109
00:52:06,365 --> 00:52:07,100
让运行该代码。

1110
00:52:07,100 --> 00:52:08,480
学生。

1111
00:52:08,480 --> 00:52:11,630
/学生。 /学生。

1112
00:52:11,630 --> 00:52:12,870
名称之一。

1113
00:52:12,870 --> 00:52:15,490
我们会说大卫。

1114
00:52:15,490 --> 00:52:18,070
名称两种，RJ。

1115
00:52:18,070 --> 00:52:20,561
名称三，罗布。

1116
00:52:20,561 --> 00:52:22,490
名称四，卢卡斯。

1117
00:52:22,490 --> 00:52:26,060
名称五，约瑟夫。

1118
00:52:26,060 --> 00:52:28,850
然后它打印出约瑟夫。

1119
00:52:28,850 --> 00:52:31,730
>> 所以，让我再次运行此。

1120
00:52:31,730 --> 00:52:32,460
让我做相同的名称。

1121
00:52:32,460 --> 00:52:39,760
大卫，RJ，罗布，卢卡斯，约瑟夫。

1122
00:52:39,760 --> 00:52:41,070
它给了我这一次大卫。

1123
00:52:41,070 --> 00:52:43,030
所以我做了同样的事情，但它给
我不同的东西，这就是

1124
00:52:43,030 --> 00:52:45,410
因为，当然，我们要求
一个随机名称。

1125
00:52:45,410 --> 00:52:50,950
所以我认为，根据我徘徊
在房间里，大多数人

1126
00:52:50,950 --> 00:52:55,960
可能得到的第一部分权利，
设立该阵列，然后让

1127
00:52:55,960 --> 00:52:56,430
所有的名字。

1128
00:52:56,430 --> 00:52:59,320
我说的是第10行到16。

1129
00:52:59,320 --> 00:53:02,150
但18至21行可能
有些东西，你以前没有见过，

1130
00:53:02,150 --> 00:53:03,750
让我们通过这些。

1131
00:53:03,750 --> 00:53:10,390
>> 这线，的函数srand时间NULL
本质上是 - 

1132
00:53:10,390 --> 00:53:14,300
对不起，让我们跳过下来
一条线，RAND（）。

1133
00:53:14,300 --> 00:53:17,320
这就给了你一个随机数，
一个随机整数。

1134
00:53:17,320 --> 00:53:19,630
如果你打的人兰特，
很多你做 - 

1135
00:53:19,630 --> 00:53:21,530
M-A-n空间R-A-N-D  - 

1136
00:53:21,530 --> 00:53:25,910
在这样的终端，M-A-N
空间上R-A-N-D，敲回车。

1137
00:53:25,910 --> 00:53:30,490
你会拿出来手册
将能够阅读兰特的

1138
00:53:30,490 --> 00:53:34,260
命令输出数伪随机字节
播种后的随机数

1139
00:53:34,260 --> 00:53:35,510
发电机一次。

1140
00:53:35,510 --> 00:53:38,450

1141
00:53:38,450 --> 00:53:39,700
>> 所以这是一个描述。

1142
00:53:39,700 --> 00:53:43,860

1143
00:53:43,860 --> 00:53:46,800
这是什么兰特，给人
你一个随机号码，当

1144
00:53:46,800 --> 00:53:48,610
你调用该函数。

1145
00:53:48,610 --> 00:53:53,140
不幸的是，这是不是真正的随机
因为如果你只需要调用随机

1146
00:53:53,140 --> 00:53:55,970
一些种子，一些没有得到
起点，但它总是会选择

1147
00:53:55,970 --> 00:53:59,100
相同的之一，它使用一个公式
以确定下一个。

1148
00:53:59,100 --> 00:54:01,730
所以，如果你调用rand，它只是
给你同样的事情。

1149
00:54:01,730 --> 00:54:02,610
这将是非常可预测的。

1150
00:54:02,610 --> 00:54:03,790
实际上，它不会是随机的。

1151
00:54:03,790 --> 00:54:09,610
>> 所以我们需要做什么，每马库斯的
指示给我，种子兰特

1152
00:54:09,610 --> 00:54:13,810
别的东西，这是什么
的srand函数确实。

1153
00:54:13,810 --> 00:54:18,055
种子兰特的东西多一点
随机比同样的事情，

1154
00:54:18,055 --> 00:54:23,360
他的播种时间NULL，
是，按照惯例，目前的

1155
00:54:23,360 --> 00:54:24,650
时间（以秒为单位）。

1156
00:54:24,650 --> 00:54:29,790
>> 所以，你假设每个人的不
要在准确的运行代码

1157
00:54:29,790 --> 00:54:33,620
同一秒内，所以它是一个安全的赌注
时间NULL将是不同的

1158
00:54:33,620 --> 00:54:35,250
每次运行此代码。

1159
00:54:35,250 --> 00:54:39,020
安全的赌注，因此，srand函数将种子兰特
不同的东西每

1160
00:54:39,020 --> 00:54:39,990
一次。

1161
00:54:39,990 --> 00:54:44,110
因此，按照惯例，当我们想要一个
随机数，我们写这条线，

1162
00:54:44,110 --> 00:54:50,540
函数srand时间NULL，给我们一个更
更多的随机种子，然后我们运行

1163
00:54:50,540 --> 00:54:52,080
兰特，这给了我们一个随机数。

1164
00:54:52,080 --> 00:54:52,840
是吗？

1165
00:54:52,840 --> 00:54:54,140
>> 学生：你能说什么
你的意思是由种子吗？

1166
00:54:54,140 --> 00:54:55,630
>> JASON HIRSCHHORN：如在种子 - 

1167
00:54:55,630 --> 00:54:58,730
所以兰特要挑一些数字
它会使用一些

1168
00:54:58,730 --> 00:55:00,060
公式得到。

1169
00:55:00,060 --> 00:55:03,250
所以它要的东西开始
然后把它变成一种基于

1170
00:55:03,250 --> 00:55:03,890
关闭该公式。

1171
00:55:03,890 --> 00:55:06,090
如果你总是给它同样的事情，
它总是会变成

1172
00:55:06,090 --> 00:55:06,790
同样的事情。

1173
00:55:06,790 --> 00:55:08,450
所以，第一件事你
给它的种子。

1174
00:55:08,450 --> 00:55:10,880
所以，你想给的东西
不同的开始，所以它

1175
00:55:10,880 --> 00:55:12,610
会变成不同的东西。

1176
00:55:12,610 --> 00:55:15,840
>> ，然后最后，第20行
这被称为％

1177
00:55:15,840 --> 00:55:17,470
模，那就是混乱。

1178
00:55:17,470 --> 00:55:19,850
这东西是一点点
不同，在这里，你真的不

1179
00:55:19,850 --> 00:55:22,240
在现实生活中的数学。

1180
00:55:22,240 --> 00:55:27,430
但本质上，当你把一个巨大的
号码，你分在C，

1181
00:55:27,430 --> 00:55:29,482
发生的其余？

1182
00:55:29,482 --> 00:55:30,510
>> 学生：被截断。

1183
00:55:30,510 --> 00:55:31,220
>> JASON HIRSCHHORN：被截断。

1184
00:55:31,220 --> 00:55:35,200
所以20除以3是什么？

1185
00:55:35,200 --> 00:55:37,950
这是什么返回
你，20除以3。

1186
00:55:37,950 --> 00:55:39,260
我们很抱歉，10除以3。

1187
00:55:39,260 --> 00:55:41,062
这是什么回报给你吗？

1188
00:55:41,062 --> 00:55:41,540
>> 学生：[听不清]。

1189
00:55:41,540 --> 00:55:45,170
>> JASON HIRSCHHORN：10除以3只是
返回3，不是3余1。

1190
00:55:45,170 --> 00:55:51,490
那么，什么10模3返回
仅仅是余数，1。

1191
00:55:51,490 --> 00:55:54,020
所以，如果你想知道什么10分
3，你会

1192
00:55:54,020 --> 00:55:58,950
做10除以3，你会得到你的3，
然后你会做10模3，

1193
00:55:58,950 --> 00:55:59,860
你会得到一个1。

1194
00:55:59,860 --> 00:56:04,630
所以，你会意识到10分
3 3，其余1。

1195
00:56:04,630 --> 00:56:07,990
>> 在此行中，兰特
的任一整数，本质上。

1196
00:56:07,990 --> 00:56:12,660
因此，模说，它除以
号，这是在这种情况下，5。

1197
00:56:12,660 --> 00:56:16,420
如果你曾经除以一个数字，
整数总是有小于

1198
00:56:16,420 --> 00:56:17,590
这个数字。

1199
00:56:17,590 --> 00:56:22,200
所以，如果你数除以5，
剩下的总是要

1200
00:56:22,200 --> 00:56:23,396
通过四个零。

1201
00:56:23,396 --> 00:56:25,520
这是多么的数学工作。

1202
00:56:25,520 --> 00:56:29,700
>> 所以一个一个较小的moduloed的大量
数将始终返回

1203
00:56:29,700 --> 00:56:33,530
其余部分将始终返回一些
数数比您少

1204
00:56:33,530 --> 00:56:34,693
除以。

1205
00:56:34,693 --> 00:56:37,920
没有任何人有任何疑问，
模的，因为它会非常，

1206
00:56:37,920 --> 00:56:41,450
非常方便，所以我要确保
大家都明白吗？

1207
00:56:41,450 --> 00:56:43,710
凉爽。

1208
00:56:43,710 --> 00:56:46,000
而且，我们看到，这个程序工作。

1209
00:56:46,000 --> 00:56:50,280
OK，继续前进。

1210
00:56:50,280 --> 00:56:52,970
>> 所以接下来，我们将要进入
的功能，我们打算去

1211
00:56:52,970 --> 00:56:55,580
通过这个东西剩下的漂亮
很快，因为我想获得

1212
00:56:55,580 --> 00:56:57,150
命令行参数。

1213
00:56:57,150 --> 00:57:00,330
所以基本上，
如您所见，黑盒子。

1214
00:57:00,330 --> 00:57:04,290
他们拿东西名为参数，
他们做了他们，无论是

1215
00:57:04,290 --> 00:57:06,990
改变或创造一些副作用，
最后，他们吐

1216
00:57:06,990 --> 00:57:09,530
出来的东西，这是
返回值。

1217
00:57:09,530 --> 00:57:12,495
有谁能够给我一个理由
为什么我们会使用的功能呢？

1218
00:57:12,495 --> 00:57:15,870

1219
00:57:15,870 --> 00:57:16,360
任何人吗？

1220
00:57:16,360 --> 00:57:19,360
其中一个原因就是为什么我们要使用的功能吗？

1221
00:57:19,360 --> 00:57:21,280
有人吗？

1222
00:57:21,280 --> 00:57:22,700
我看到了两只手。

1223
00:57:22,700 --> 00:57:23,590
一个很好的理由是什么？

1224
00:57:23,590 --> 00:57:24,930
马库斯？

1225
00:57:24,930 --> 00:57:27,730
>> 学生：如果你必须调用相同的
大块的代码多次。

1226
00:57:27,730 --> 00:57:29,150
>> JASON HIRSCHHORN：OK，如果你需要
调用相同的块

1227
00:57:29,150 --> 00:57:30,040
多次编码。

1228
00:57:30,040 --> 00:57:32,470
杰夫，你是否也有不同的原因吗？

1229
00:57:32,470 --> 00:57:34,230
>> 学生：只要
您可以编写更少。

1230
00:57:34,230 --> 00:57:35,070
>> JASON HIRSCHHORN：您可以编写更少。

1231
00:57:35,070 --> 00:57:35,320
右。

1232
00:57:35,320 --> 00:57:38,720
如果你想要做的东西很多 - 

1233
00:57:38,720 --> 00:57:41,720
在上面的代码中，我能有
书面串五倍，但

1234
00:57:41,720 --> 00:57:44,620
for循环，使它看起来更好，
你必须写更少的代码。

1235
00:57:44,620 --> 00:57:45,760
函数是一种类似的想法。

1236
00:57:45,760 --> 00:57:48,720
如果我想要做同样的事情很多，
将它移动到一个函数，并调用

1237
00:57:48,720 --> 00:57:49,610
每次功能。

1238
00:57:49,610 --> 00:57:51,190
这会为你做那件事。

1239
00:57:51,190 --> 00:57:53,740
这是一个很大的原因
使用功能。

1240
00:57:53,740 --> 00:57:54,870
>> 因此，解剖函数。

1241
00:57:54,870 --> 00:57:56,670
函数一般会
这个样子。

1242
00:57:56,670 --> 00:57:59,280
它会开始返回类型，
那么你会得到这个名字。

1243
00:57:59,280 --> 00:58:02,935
它会采取的论点，否则
已知参数，和内部

1244
00:58:02,935 --> 00:58:05,290
那些花括号，你会
写你的代码。

1245
00:58:05,290 --> 00:58:07,150
>> 我们已经看到了一个功能很多。

1246
00:58:07,150 --> 00:58:09,160
这是主要的。

1247
00:58:09,160 --> 00:58:13,820
这里主要是叠加
解剖我有更早。

1248
00:58:13,820 --> 00:58:15,525
诠释权在这里表示什么？

1249
00:58:15,525 --> 00:58:18,534

1250
00:58:18,534 --> 00:58:19,450
什么诠释是什么意思？

1251
00:58:19,450 --> 00:58:21,026
当我写的诠释主要（无效）。

1252
00:58:21,026 --> 00:58:21,740
>> 学生：返回类型？

1253
00:58:21,740 --> 00:58:22,350
>> JASON HIRSCHHORN：对不起？

1254
00:58:22,350 --> 00:58:23,170
>> 学生：返回类型。

1255
00:58:23,170 --> 00:58:24,820
>> JASON HIRSCHHORN：诠释是
返回类型，分毫不差。

1256
00:58:24,820 --> 00:58:25,870
主返回一个int。

1257
00:58:25,870 --> 00:58:28,678
主要是什么？

1258
00:58:28,678 --> 00:58:29,510
>> 学生：功能名称。

1259
00:58:29,510 --> 00:58:30,800
>> JASON HIRSCHHORN：主要是
的函数名。

1260
00:58:30,800 --> 00:58:31,510
完全正确。

1261
00:58:31,510 --> 00:58:31,840
和无效的呢？

1262
00:58:31,840 --> 00:58:33,190
括号内的什么是无效的？

1263
00:58:33,190 --> 00:58:36,650

1264
00:58:36,650 --> 00:58:42,030
>> 学生：它并不需要
任何外部的价值。

1265
00:58:42,030 --> 00:58:42,930
>> JASON HIRSCHHORN：所以无效 - 

1266
00:58:42,930 --> 00:58:43,240
正确的。

1267
00:58:43,240 --> 00:58:45,940
括号内的，我们把
参数或参数

1268
00:58:45,940 --> 00:58:48,480
功能需要？
黑盒子内。

1269
00:58:48,480 --> 00:58:50,760
当你写无效，你说
这需要什么英寸

1270
00:58:50,760 --> 00:58:53,802
因此INT主要无效意味着主要的
不采取任何英寸

1271
00:58:53,802 --> 00:58:56,950
>> 花括号内的，我们有一些
代码，然后我们看到了在年底

1272
00:58:56,950 --> 00:58:57,640
返回零。

1273
00:58:57,640 --> 00:59:01,220
归零什么意思？

1274
00:59:01,220 --> 00:59:02,470
好吧，我们谈到的返回类型。

1275
00:59:02,470 --> 00:59:03,780
主要需要返回一个int。

1276
00:59:03,780 --> 00:59:04,960
这是这一行做什么。

1277
00:59:04,960 --> 00:59:07,330
它返回一个int，零。

1278
00:59:07,330 --> 00:59:13,600
>> 当然，我们还没有看到，很多
因为在编程中，我们做

1279
00:59:13,600 --> 00:59:16,070
我们做的机器和编译器
我们用如今，你

1280
00:59:16,070 --> 00:59:16,990
不需要该行。

1281
00:59:16,990 --> 00:59:20,070
主要是够特别，它知道
主，只是当你到达终点

1282
00:59:20,070 --> 00:59:22,060
返回零，如果一切都很顺利。

1283
00:59:22,060 --> 00:59:25,560
事实上，如果事情不顺利，
主往往会返回不同的

1284
00:59:25,560 --> 00:59:28,500
数字标志着东西
与你的程序出了错。

1285
00:59:28,500 --> 00:59:32,470
>> 所以，通常当你看到代码，你
不写返回零，但它的好

1286
00:59:32,470 --> 00:59:34,770
知道背后发生了什么事
场景，因为每当你写

1287
00:59:34,770 --> 00:59:36,370
另一种不同的功能，
您将需要

1288
00:59:36,370 --> 00:59:37,400
包括返回行。

1289
00:59:37,400 --> 00:59:39,710
如果你说我要去
返回一个int，你必须

1290
00:59:39,710 --> 00:59:41,250
写返回的东西。

1291
00:59:41,250 --> 00:59:45,160
如果你说在这里无效
年初，无效的主要无效，

1292
00:59:45,160 --> 00:59:48,670
例如，那么它并没有返回
什么 - 空虚意味着什么 - 

1293
00:59:48,670 --> 00:59:50,320
所以你不需要返回的行。

1294
00:59:50,320 --> 00:59:53,610
但你曾经写的东西，这不是
无效的返回类型，你需要

1295
00:59:53,610 --> 00:59:55,950
一个回报，你说行
需要把东西

1296
00:59:55,950 --> 00:59:57,650
类型相匹配的。

1297
00:59:57,650 --> 00:59:58,900
任何问题吗？

1298
00:59:58,900 --> 01:00:03,110

1299
01:00:03,110 --> 01:00:04,680
甜。

1300
01:00:04,680 --> 01:00:05,930
>> 范围。

1301
01:00:05,930 --> 01:00:07,360
这是我们已经
以及感动。

1302
01:00:07,360 --> 01:00:10,720
每个变量，因为我们知道，有一个
一定范围内，这是基本

1303
01:00:10,720 --> 01:00:14,160
谈论变量
可能会或可能不会被引用。

1304
01:00:14,160 --> 01:00:16,310
我喜欢说会发生什么
在大括号中保持

1305
01:00:16,310 --> 01:00:18,000
花括号内。

1306
01:00:18,000 --> 01:00:21,490
因此，例如，如果我们看一下这段代码，
我们定义了一个全局变量

1307
01:00:21,490 --> 01:00:24,510
为主，诠释一个外，
这里在顶部。

1308
01:00:24,510 --> 01:00:27,380
我们调用另一个
int一个主里面。

1309
01:00:27,380 --> 01:00:29,760
我们有一些比较大括号，
我们调用另一个INT的一个。

1310
01:00:29,760 --> 01:00:31,690
>> 我们有三个代码。

1311
01:00:31,690 --> 01:00:32,550
这些都是不一样的东西。

1312
01:00:32,550 --> 01:00:34,880
我创建了三个不同的变量。

1313
01:00:34,880 --> 01:00:39,370
然后里面这些内在的卷发
牙套，我说A = 4。

1314
01:00:39,370 --> 01:00:44,130
哪一个是谈论，
第一个，第二个，

1315
01:00:44,130 --> 01:00:47,045
第三只呢？

1316
01:00:47,045 --> 01:00:47,920
>> 学生：第三个。

1317
01:00:47,920 --> 01:00:49,320
>> JASON HIRSCHHORN：在谈论
关于第三个。

1318
01:00:49,320 --> 01:00:52,850
所有那些实际上可以
谈到在这个特殊的

1319
01:00:52,850 --> 01:00:58,660
例如，由于其范围
到这些最里面的大括号。

1320
01:00:58,660 --> 01:01:02,360
然而，当你调用东西是一样的
名称，称为隐藏的东西。

1321
01:01:02,360 --> 01:01:09,670
所以你只处理或修复，或使用
最近的变量，或者一个

1322
01:01:09,670 --> 01:01:11,090
最接近你。

1323
01:01:11,090 --> 01:01:14,760
所以，里面第三个是在这里，这是最接近
该行中，a = 4，所以它

1324
01:01:14,760 --> 01:01:16,550
影响第三。

1325
01:01:16,550 --> 01:01:19,890
和最后一行中，a = 2，a是
，谈论，所述第一，第二，

1326
01:01:19,890 --> 01:01:20,805
第三个是？

1327
01:01:20,805 --> 01:01:22,530
>> 学生：二。

1328
01:01:22,530 --> 01:01:24,430
>> JASON HIRSCHHORN：在谈论
关于第二个是。

1329
01:01:24,430 --> 01:01:27,970
当然，第三个是最接近
它的代码，但第三个

1330
01:01:27,970 --> 01:01:30,200
外部不存在
那些大括号。

1331
01:01:30,200 --> 01:01:32,650
一旦你到那个封闭的卷发
梅开二度，这就像它不见了，

1332
01:01:32,650 --> 01:01:33,570
本质上。

1333
01:01:33,570 --> 01:01:36,150
所以，唯一的两个你已经离开的是那些
第2个，当然，现在

1334
01:01:36,150 --> 01:01:37,960
它的最近的第二个。

1335
01:01:37,960 --> 01:01:39,410
>> 所以这是一件好事，
记得大约范围。

1336
01:01:39,410 --> 01:01:42,900
例如，我敢肯定，你遇到
这在一个do while循环。

1337
01:01:42,900 --> 01:01:46,680
如果初始化的变量里面
DO WHILE循环，然后你​​试试

1338
01:01:46,680 --> 01:01:50,360
访问它之外，你可能
像，这得到了一些警告

1339
01:01:50,360 --> 01:01:51,680
变量不存在。

1340
01:01:51,680 --> 01:01:54,370
那是因为范围的想法，
事情只存在

1341
01:01:54,370 --> 01:01:55,320
那些大括号内。

1342
01:01:55,320 --> 01:01:59,320
大括号是像一个巨大的拥抱
你给你的代码，又是另一回事

1343
01:01:59,320 --> 01:02:01,380
去想它。

1344
01:02:01,380 --> 01:02:05,280
>> 因此，这是另一种功能，这
你们的代码，hellofunction.c。

1345
01:02:05,280 --> 01:02:08,240
我们要跳过的现在，但
这是我鼓励你

1346
01:02:08,240 --> 01:02:09,740
在自己的练习。

1347
01:02:09,740 --> 01:02:12,510
写一个方案，其中主要电话
另一个函数，打印出

1348
01:02:12,510 --> 01:02:13,750
问候给用户。

1349
01:02:13,750 --> 01:02:17,750
它本质上是“世界，你好
和抽象成的printf

1350
01:02:17,750 --> 01:02:18,680
另一个功能。

1351
01:02:18,680 --> 01:02:22,360
但我们不打算这样做，现在
因为我们没有尽可能多的时间

1352
01:02:22,360 --> 01:02:23,350
离开，我会很喜欢。

1353
01:02:23,350 --> 01:02:26,250
>> 所以函数声明。

1354
01:02:26,250 --> 01:02:28,080
我们已经看到了这个前。

1355
01:02:28,080 --> 01:02:31,180
如果你想要写另一个函数，
你需要让计算机知道

1356
01:02:31,180 --> 01:02:32,600
主知道它的存在。

1357
01:02:32,600 --> 01:02:37,140
所以，我们做的是上面的主，我们写
返回类型，名称，和

1358
01:02:37,140 --> 01:02:42,970
参数，然后向下跌破主力，
这里，我们实际上该行复制

1359
01:02:42,970 --> 01:02:45,080
然后编写实际的代码。

1360
01:02:45,080 --> 01:02:50,990
那么这样一来，如果你调用函数
主要在顶部，主知道，

1361
01:02:50,990 --> 01:02:54,650
你好存在，例如，如果我是
打电话招呼，然后它看起来

1362
01:02:54,650 --> 01:02:56,710
实施向下跌破。

1363
01:02:56,710 --> 01:02:59,680
会发生什么事，如果不包括这
线向上顶，无效（无效）？

1364
01:02:59,680 --> 01:03:03,820

1365
01:03:03,820 --> 01:03:06,560
>> 如果不包括此行
和主呼叫你好，我是

1366
01:03:06,560 --> 01:03:07,640
要得到一个错误。

1367
01:03:07,640 --> 01:03:10,090
我要得到一个错误，因为
编译器不知道

1368
01:03:10,090 --> 01:03:13,070
这件事情的存在。

1369
01:03:13,070 --> 01:03:16,680
这就是为什么我们
＃包括cs50.h.

1370
01:03:16,680 --> 01:03:21,390
基本上cs50.h做
放置得到字符串在那里。

1371
01:03:21,390 --> 01:03:23,120
推杆得到int的有。

1372
01:03:23,120 --> 01:03:26,570
它把所有这些功能
前主让原型时

1373
01:03:26,570 --> 01:03:29,900
你叫他们在主，主知道
这些东西的存在。

1374
01:03:29,900 --> 01:03:31,630
这是那些h文件。

1375
01:03:31,630 --> 01:03:33,850
所以，如果你打算让自己的
功能，你一定要确保

1376
01:03:33,850 --> 01:03:36,690
在那里，你把原型。

1377
01:03:36,690 --> 01:03:38,380
关于这个到目前为止的任何问题？

1378
01:03:38,380 --> 01:03:41,630

1379
01:03:41,630 --> 01:03:42,490
>> 命令行参数。

1380
01:03:42,490 --> 01:03:44,780
这就是我们要去完成
，然后希望我们能

1381
01:03:44,780 --> 01:03:46,180
挤在一些pset中。

1382
01:03:46,180 --> 01:03:48,700
我不知道，如果我们将能够挤
因为时间，但

1383
01:03:48,700 --> 01:03:51,560
你们谁在这里，如果你
家伙想了一下后说，我们

1384
01:03:51,560 --> 01:03:54,290
可以在它外面。

1385
01:03:54,290 --> 01:03:56,020
但我们要完成
命令行参数

1386
01:03:56,020 --> 01:03:58,510
最后15分钟。

1387
01:03:58,510 --> 01:03:59,930
我们醒了，迈克尔？

1388
01:03:59,930 --> 01:04:01,180
你醒了吗？

1389
01:04:01,180 --> 01:04:01,660
好。

1390
01:04:01,660 --> 01:04:03,760
我不知道，如果你睡
闭上你的眼睛。

1391
01:04:03,760 --> 01:04:05,800
这将是非常棘手。

1392
01:04:05,800 --> 01:04:07,180
>> 命令行参数。

1393
01:04:07,180 --> 01:04:10,430
这是一个的方式来传递信息
进入程序。

1394
01:04:10,430 --> 01:04:12,780
最后，我们会遇到别人。

1395
01:04:12,780 --> 01:04:15,600
但是，从本质上讲，我们要停止
写诠释的主要（无效）如果我们想

1396
01:04:15,600 --> 01:04:16,720
采取一些命令行参数。

1397
01:04:16,720 --> 01:04:19,850
我们打​​算写这个东西
被称为国际主要（INT ARGC，

1398
01:04:19,850 --> 01:04:22,430
串argv的括号内。

1399
01:04:22,430 --> 01:04:23,710
这是令人目不暇接。

1400
01:04:23,710 --> 01:04:26,070
这是一个很大的字母中所没有的
人类的英语，所以我们要

1401
01:04:26,070 --> 01:04:27,680
现在他们解压。

1402
01:04:27,680 --> 01:04:30,450
>> ARGC参数计数 - 

1403
01:04:30,450 --> 01:04:32,600
再次，所有这些都将
可在线 - 

1404
01:04:32,600 --> 01:04:34,280
参数的个数。

1405
01:04:34,280 --> 01:04:37,940
ARGV参数向量，
这些都是自己的论据。

1406
01:04:37,940 --> 01:04:38,830
这是一个字符串数组。

1407
01:04:38,830 --> 01:04:40,880
实际上，我们已经看到了一个阵列
今天之前的字符串。

1408
01:04:40,880 --> 01:04:44,390
我们创建了一个在过去
程序编码。

1409
01:04:44,390 --> 01:04:45,720
>> 因此，这里是一个例子。

1410
01:04:45,720 --> 01:04:50,230
我写。/ ohai CS50节
我的命令行。

1411
01:04:50,230 --> 01:04:54,090
ARGC在这种情况下等于3。

1412
01:04:54,090 --> 01:05:01,170
ARGV支架0 ohai，argv的支架1
CS50，argv的支架2部分。

1413
01:05:01,170 --> 01:05:05,160
同样，argc是参数的个数，
把你绊倒了一点

1414
01:05:05,160 --> 01:05:08,710
位，我们总是算的名称
函数的第一个参数。

1415
01:05:08,710 --> 01:05:12,350
因此，在这种情况下，有三个
参数的函数名

1416
01:05:12,350 --> 01:05:14,590
那么这两个，我键入。

1417
01:05:14,590 --> 01:05:18,900
>> 下一步，我们要拯救那些
参数本身argv中。

1418
01:05:18,900 --> 01:05:22,690
再次，正如我们之前看到的，我们做
这在过去的程序编码。

1419
01:05:22,690 --> 01:05:27,110
您可以将通过数组
argv和那些字符串。

1420
01:05:27,110 --> 01:05:28,830
本质上这是我们做了什么
年底我们的最后一个节目。

1421
01:05:28,830 --> 01:05:33,190
我们挑了随机的名字，然后去
名称支架无论和印刷

1422
01:05:33,190 --> 01:05:34,580
出字符串设在那里。

1423
01:05:34,580 --> 01:05:39,870

1424
01:05:39,870 --> 01:05:43,670
>> 论只是一个阵列的顶部，由于
字符串本身阵列，

1425
01:05:43,670 --> 01:05:46,320
谈到，你可以有阵列
的阵列，这是

1426
01:05:46,320 --> 01:05:48,530
基本上argv是什么。

1427
01:05:48,530 --> 01:05:51,370
一种方式，你可以考虑一下
这是行和列。

1428
01:05:51,370 --> 01:05:54,750
现在，我可以得出这样的权利。

1429
01:05:54,750 --> 01:05:57,370
所以argv的 - 

1430
01:05:57,370 --> 01:05:58,630
不擦除。

1431
01:05:58,630 --> 01:05:59,880
让我们借鉴ohai下。

1432
01:05:59,880 --> 01:06:09,320

1433
01:06:09,320 --> 01:06:12,490
>> 所以，如果我写的，ohai CS50部分，
我要截断

1434
01:06:12,490 --> 01:06:14,520
在这个例子中的一节。

1435
01:06:14,520 --> 01:06:29,026
但是，从本质上讲，我的多维
阵列，ohai CS50

1436
01:06:29,026 --> 01:06:32,200
我们要做的教派。

1437
01:06:32,200 --> 01:06:34,610
所以在这里，我可以访问 - 

1438
01:06:34,610 --> 01:06:40,930

1439
01:06:40,930 --> 01:06:45,710
如果我只是给argv的一个数字 - 

1440
01:06:45,710 --> 01:06:46,390
这是错误的。

1441
01:06:46,390 --> 01:06:49,020
在这个图中有什么不对？

1442
01:06:49,020 --> 01:06:49,690
>> 学生：从零开始。

1443
01:06:49,690 --> 01:06:50,350
>> JASON HIRSCHHORN：它应该
从零开始。

1444
01:06:50,350 --> 01:06:52,940
也许我应该还可以旋转它，但
因为我已经画了，我

1445
01:06:52,940 --> 01:06:54,120
要离开现在。

1446
01:06:54,120 --> 01:06:55,160
但是，从零开始。

1447
01:06:55,160 --> 01:06:56,410
这是正确的。

1448
01:06:56,410 --> 01:06:58,980

1449
01:06:58,980 --> 01:07:00,120
对不起，如果这是小的。

1450
01:07:00,120 --> 01:07:01,370
你们可以看到吗？

1451
01:07:01,370 --> 01:07:03,620

1452
01:07:03,620 --> 01:07:06,670
所以，如果我做的argv 0，我会
得到所有ohai。

1453
01:07:06,670 --> 01:07:08,555
如果我做的argv 1，我会得到所有的CS50。

1454
01:07:08,555 --> 01:07:10,720
如果我做的argv 2，我会得到所有的教派。

1455
01:07:10,720 --> 01:07:13,370
>> 但现在，正如我们所说，字符串
阵列本身。

1456
01:07:13,370 --> 01:07:19,740
那么我能做什么我就可以把这个
作为一个多维数组，并且我

1457
01:07:19,740 --> 01:07:24,190
可以做一些沿线
argv的0，0，这给了我只是

1458
01:07:24,190 --> 01:07:25,400
字符0。

1459
01:07:25,400 --> 01:07:28,760
ARGV 0，1，这给了我只是ħ。

1460
01:07:28,760 --> 01:07:33,960
ARGV 1，3，给我
0这里CS50。

1461
01:07:33,960 --> 01:07:37,690
>> 因此，因为字符串本身
阵列，我们把

1462
01:07:37,690 --> 01:07:38,540
在另一个数组。

1463
01:07:38,540 --> 01:07:42,850
我们现在有数组的数组，我们
我们的第一个数组索引和

1464
01:07:42,850 --> 01:07:44,840
然后我们第二个数组的索引。

1465
01:07:44,840 --> 01:07:48,650
和你所期望的，我们这样做
只是把那两个 - 

1466
01:07:48,650 --> 01:07:51,760
只是我们做的方括号
旁边另一个。

1467
01:07:51,760 --> 01:07:58,930
所以在这个例子中，argv 1是CS50和
argv的1，2，就像我们所说的，仅仅是5。

1468
01:07:58,930 --> 01:08:02,120
没有任何人有任何疑问，
多维数组？

1469
01:08:02,120 --> 01:08:05,090

1470
01:08:05,090 --> 01:08:06,380
你们做得真棒。

1471
01:08:06,380 --> 01:08:07,750
甜。

1472
01:08:07,750 --> 01:08:11,980
>> 因此，我们有另一个程序在这里，
这是我们的最后一件事

1473
01:08:11,980 --> 01:08:13,690
现在要做的。

1474
01:08:13,690 --> 01:08:18,160
所以，我要你写一个程序，
以用户的全名，只有两个

1475
01:08:18,160 --> 01:08:21,649
两个命令行参数，最后，
打印出问候

1476
01:08:21,649 --> 01:08:24,180
用户包括他们的名字。

1477
01:08:24,180 --> 01:08:27,800
那么，为什么不把三个或四个
分钟做这个，然后我们一起去

1478
01:08:27,800 --> 01:08:29,870
以上为一组，并
然后我们将收官？

1479
01:08:29,870 --> 01:09:44,189

1480
01:09:44,189 --> 01:09:48,084
>> 再次，在这里，当我们说一个
描述每个用户的全名

1481
01:09:48,084 --> 01:09:54,473
这个问题，它应该是命令
行参数，不使用字符串。

1482
01:09:54,473 --> 01:09:55,450
是啊，马库斯？

1483
01:09:55,450 --> 01:09:58,260
>> 学生：所以当你说两个命令
行参数，除了

1484
01:09:58,260 --> 01:10:00,000
/运行，或者 - 

1485
01:10:00,000 --> 01:10:02,980
>> JASON HIRSCHHORN：好问题。

1486
01:10:02,980 --> 01:10:05,995
做的，包括。/运行，三
命令行参数。

1487
01:10:05,995 --> 01:10:08,550

1488
01:10:08,550 --> 01:10:11,320
或包括/个性化，
这种情况下，因为这是

1489
01:10:11,320 --> 01:10:12,360
此文件的名称。

1490
01:10:12,360 --> 01:10:13,300
所以ARGC将有三个。

1491
01:10:13,300 --> 01:10:19,480
不过，我想只有两个参数
给程序。

1492
01:10:19,480 --> 01:10:20,400
我应该指定。

1493
01:10:20,400 --> 01:10:23,380
之前，我交的，我会作出这样的改变
这些，并送他们到你们。

1494
01:10:23,380 --> 01:10:32,747

1495
01:10:32,747 --> 01:10:34,740
>> 学生：如果你
有一个中间的名字吗？

1496
01:10:34,740 --> 01:10:36,800
>> JASON HIRSCHHORN：如果你有一个中间
名字，你的运气了。

1497
01:10:36,800 --> 01:10:38,050
对不起。

1498
01:10:38,050 --> 01:10:40,320

1499
01:10:40,320 --> 01:10:43,744
或者，如果你只去夏奇拉
你也是出于运气。

1500
01:10:43,744 --> 01:10:55,672

1501
01:10:55,672 --> 01:10:56,425
是吗？

1502
01:10:56,425 --> 01:11:00,760
>> 学生：所以当人们没有
cs50.h，他们定义的argv

1503
01:11:00,760 --> 01:11:03,450
为char明星argv的？

1504
01:11:03,450 --> 01:11:05,160
或者是它仍然被称为串的argv？

1505
01:11:05,160 --> 01:11:07,430
>> JASON HIRSCHHORN：是的。

1506
01:11:07,430 --> 01:11:10,480
因此，字符串，我们再次掩盖了什么
究竟是有发生。

1507
01:11:10,480 --> 01:11:14,040
这是怎么回事也许要解压缩
上周三，但很快。

1508
01:11:14,040 --> 01:11:16,380
这就像训练车轮。

1509
01:11:16,380 --> 01:11:18,370
因为从本质上讲，它是
同样的事情。

1510
01:11:18,370 --> 01:11:37,040

1511
01:11:37,040 --> 01:11:42,560
>> 因此，让我们一分钟程序
这一点，然后我们会去

1512
01:11:42,560 --> 01:11:45,130
为一组，然后
就像我说的，包裹起来。

1513
01:11:45,130 --> 01:11:47,770
而且我觉得他们仍然是额外的糖果，
所以你们应该有希望

1514
01:11:47,770 --> 01:11:49,790
，请采取这一。

1515
01:11:49,790 --> 01:12:20,380

1516
01:12:20,380 --> 01:12:22,560
>> 很抱歉，如果你还在写，
但我想潜水，我们

1517
01:12:22,560 --> 01:12:24,010
可以一起完成。

1518
01:12:24,010 --> 01:12:30,470
所以，我已经写了＃
cs50.h＃包括stdio.h中。

1519
01:12:30,470 --> 01:12:33,970
诠释的主要（无效），卷发，大括号
括号，里面三行

1520
01:12:33,970 --> 01:12:38,760
伪代码，用户的全名，
两个，只有两个命令行

1521
01:12:38,760 --> 01:12:42,670
参数，打印出问候
用户包括他们的名字。

1522
01:12:42,670 --> 01:12:45,810
>> 因此，第一个，
用户的全名。

1523
01:12:45,810 --> 01:12:47,290
谁可以帮我
用户的全名吗？

1524
01:12:47,290 --> 01:12:50,882

1525
01:12:50,882 --> 01:12:52,780
我该怎么做的那部分？

1526
01:12:52,780 --> 01:12:57,685

1527
01:12:57,685 --> 01:12:59,500
难道你们这样做，第一部分？

1528
01:12:59,500 --> 01:13:02,587

1529
01:13:02,587 --> 01:13:03,894
以用户的全名。

1530
01:13:03,894 --> 01:13:05,860
那么，对于一个命令行
的说法，我应该写什么？

1531
01:13:05,860 --> 01:13:09,624
我应该改变什么
我的函数声明？

1532
01:13:09,624 --> 01:13:11,140
>> 学生：你不希望
它是无效的了。

1533
01:13:11,140 --> 01:13:11,410
>> JASON HIRSCHHORN：没错。

1534
01:13:11,410 --> 01:13:12,385
我不希望它是无效的。

1535
01:13:12,385 --> 01:13:13,630
我想要什么？

1536
01:13:13,630 --> 01:13:14,650
>> 学生：INT ARGC。

1537
01:13:14,650 --> 01:13:15,720
>> JASON HIRSCHHORN：INT ARGC。

1538
01:13:15,720 --> 01:13:17,430
>> 学生：弦乐的argv。

1539
01:13:17,430 --> 01:13:19,055
>> JASON HIRSCHHORN的String argv的。

1540
01:13:19,055 --> 01:13:19,705
>> 学生：支架，支架。

1541
01:13:19,705 --> 01:13:20,070
>> JASON HIRSCHHORN：支架，支架。

1542
01:13:20,070 --> 01:13:21,780
这完全正确的，那就是
其实我会怎么得到

1543
01:13:21,780 --> 01:13:22,820
用户的全名。

1544
01:13:22,820 --> 01:13:24,070
他们打算把它放在那里。

1545
01:13:24,070 --> 01:13:27,720

1546
01:13:27,720 --> 01:13:28,780
所以，一个人的工作。

1547
01:13:28,780 --> 01:13:30,780
所以现在我想两个，只有两个
命令行参数。

1548
01:13:30,780 --> 01:13:35,065
所以，诺亚，什么是尽我所能
检查数量的命令

1549
01:13:35,065 --> 01:13:36,315
我行参数？

1550
01:13:36,315 --> 01:13:39,676

1551
01:13:39,676 --> 01:13:40,725
>> 学生：你做一个if语句。

1552
01:13:40,725 --> 01:13:42,270
>> JASON HIRSCHHORN：如果
声明中，完全吻合。

1553
01:13:42,270 --> 01:13:44,830
我想要什么条件？

1554
01:13:44,830 --> 01:13:48,370
>> 学生：如果大于3的argc。

1555
01:13:48,370 --> 01:13:52,485
>> JASON HIRSCHHORN：如果ARGC
大于3。

1556
01:13:52,485 --> 01:13:58,430
如果ARGC大于3，怎么做？

1557
01:13:58,430 --> 01:13:59,400
>> 学生：返回1。

1558
01:13:59,400 --> 01:14:01,856
>> JASON HIRSCHHORN：返回1。

1559
01:14:01,856 --> 01:14:04,050
将确保我有
两个只有两个？

1560
01:14:04,050 --> 01:14:07,280

1561
01:14:07,280 --> 01:14:07,820
>> 学生：

1562
01:14:07,820 --> 01:14:13,110
如果argc是大于
3和小于2。

1563
01:14:13,110 --> 01:14:17,770
>> JASON HIRSCHHORN：如果argc是更大
比3和argc小于2。

1564
01:14:17,770 --> 01:14:21,540
什么方法可以让我写这篇文章，在短短
一行上，或者不使用该

1565
01:14:21,540 --> 01:14:23,890
布尔运算符？

1566
01:14:23,890 --> 01:14:25,942
>> 学生：这不是等于2。

1567
01:14:25,942 --> 01:14:28,790
>> JASON HIRSCHHORN：如果ARGC
不等于2。

1568
01:14:28,790 --> 01:14:29,260
没错。

1569
01:14:29,260 --> 01:14:34,890
因此，如果argc是不等于2，即
会给我这个程序，

1570
01:14:34,890 --> 01:14:37,250
个性化，当我跑的时候，
会给我多少

1571
01:14:37,250 --> 01:14:38,740
命令行参数？

1572
01:14:38,740 --> 01:14:42,110
我检查了多少？

1573
01:14:42,110 --> 01:14:42,370
>> 抱歉。

1574
01:14:42,370 --> 01:14:43,400
让我改写了。

1575
01:14:43,400 --> 01:14:46,620
如果ARGC = 2，没多少东西
用户写入行？

1576
01:14:46,620 --> 01:14:47,500
>> 学生：一。

1577
01:14:47,500 --> 01:14:49,120
>> JASON HIRSCHHORN：只有一个问题。

1578
01:14:49,120 --> 01:14:50,430
所以之前，你是对的，诺亚。

1579
01:14:50,430 --> 01:14:52,192
什么我确实需要放在那里？

1580
01:14:52,192 --> 01:14:53,640
>> 学生：那等于3。

1581
01:14:53,640 --> 01:14:55,970
>> JASON HIRSCHHORN：ARGC
不等于3。

1582
01:14:55,970 --> 01:15:00,250
因为我想，我要等于3
个性化的附加其他两个。

1583
01:15:00,250 --> 01:15:02,560
因此，如果ARGC不等于3，返回1。

1584
01:15:02,560 --> 01:15:04,475
你为什么说返回1？

1585
01:15:04,475 --> 01:15:06,180
>> 学生：因为，
意味着它是错误的。

1586
01:15:06,180 --> 01:15:08,420
>> JASON HIRSCHHORN：这意味着它是错误的，
什么该怎么办？

1587
01:15:08,420 --> 01:15:10,360
>> 学生：重新提示用户。

1588
01:15:10,360 --> 01:15:11,940
>> JASON HIRSCHHORN：这将退出
程序，所以它会运行

1589
01:15:11,940 --> 01:15:14,520
了，但我们不会有什么关系
在这里再次要求他们。

1590
01:15:14,520 --> 01:15:14,840
我没有要求。

1591
01:15:14,840 --> 01:15:15,990
所以这是完全正确的。

1592
01:15:15,990 --> 01:15:17,680
返回1只退出程序。

1593
01:15:17,680 --> 01:15:18,520
太好了。

1594
01:15:18,520 --> 01:15:21,600
>> 并打印出用户打招呼
，其中包括他们的名字。

1595
01:15:21,600 --> 01:15:24,010
我怎样才能做到这一点呢？

1596
01:15:24,010 --> 01:15:25,990
安娜？

1597
01:15:25,990 --> 01:15:26,580
>> 学生：printf的。

1598
01:15:26,580 --> 01:15:27,785
>> JASON HIRSCHHORN：printf的。

1599
01:15:27,785 --> 01:15:28,640
>> 学生：（“

1600
01:15:28,640 --> 01:15:30,460
>> JASON HIRSCHHORN：（

1601
01:15:30,460 --> 01:15:31,600
>> 学生：“你好

1602
01:15:31,600 --> 01:15:33,210
>> JASON HIRSCHHORN：“你好

1603
01:15:33,210 --> 01:15:34,800
>> 学生：％S

1604
01:15:34,800 --> 01:15:37,230
>> JASON HIRSCHHORN：％s的

1605
01:15:37,230 --> 01:15:38,840
>> 学生：/ N

1606
01:15:38,840 --> 01:15:41,030
>> JASON HIRSCHHORN / N

1607
01:15:41,030 --> 01:15:43,120
>> 学生：“

1608
01:15:43,120 --> 01:15:45,130
>> JASON HIRSCHHORN：“

1609
01:15:45,130 --> 01:15:46,620
>> 学生：ARGV

1610
01:15:46,620 --> 01:15:47,080
>> JASON HIRSCHHORN：对不起？

1611
01:15:47,080 --> 01:15:47,750
>> 学生：ARGV

1612
01:15:47,750 --> 01:15:48,840
>> JASON HIRSCHHORN：ARGV

1613
01:15:48,840 --> 01:15:50,190
>> 学生：方括号1。

1614
01:15:50,190 --> 01:15:51,230
>> JASON HIRSCHHORN：方括号？

1615
01:15:51,230 --> 01:15:51,870
>> 学生：1。

1616
01:15:51,870 --> 01:15:54,050
>> JASON HIRSCHHORN：1。

1617
01:15:54,050 --> 01:15:55,850
>> 学生：）和分号。

1618
01:15:55,850 --> 01:15:58,290
>> JASON HIRSCHHORN：）分号。

1619
01:15:58,290 --> 01:16:00,250
让我们运行这个。

1620
01:16:00,250 --> 01:16:03,730
使个性化。

1621
01:16:03,730 --> 01:16:06,392
/个性化。

1622
01:16:06,392 --> 01:16:07,420
它只是退出。

1623
01:16:07,420 --> 01:16:10,390
为什么退出？

1624
01:16:10,390 --> 01:16:11,310
>> 学生：你没有提出任何论据。

1625
01:16:11,310 --> 01:16:12,560
>> JASON HIRSCHHORN：我没有
把任何参数英寸

1626
01:16:12,560 --> 01:16:16,360

1627
01:16:16,360 --> 01:16:16,920
看起来不错。

1628
01:16:16,920 --> 01:16:18,130
你们钉。

1629
01:16:18,130 --> 01:16:22,420
如此反复，你走进argv和你
在开始的argc检查。

1630
01:16:22,420 --> 01:16:24,390
这些是两个重要的
事情要记住。

1631
01:16:24,390 --> 01:16:29,250
因此，在我们之前，我们最后两分钟
离开，我们不会给pset两个，但

1632
01:16:29,250 --> 01:16:33,585
就像我说的，如果你想留后
10分钟，我想他乐意去

1633
01:16:33,585 --> 01:16:35,710
用你们的逻辑
这些问题集。

1634
01:16:35,710 --> 01:16:37,930
我们有很多今天覆盖
所以我没有得到他们。

1635
01:16:37,930 --> 01:16:39,820
通常情况下，我想包括
在末端。

1636
01:16:39,820 --> 01:16:42,150
所以，如果你要坚持围绕，
坚持10分钟左右。

1637
01:16:42,150 --> 01:16:42,990
我们会做到这一点。

1638
01:16:42,990 --> 01:16:46,250
>> 然后，我开始提到的，
pset的零和一，我们会拿到

1639
01:16:46,250 --> 01:16:48,040
反馈回给您
尽快。

1640
01:16:48,040 --> 01:16:51,260
我们的目标是获得的pset一个反馈，
注释部分，

1641
01:16:51,260 --> 01:16:52,850
之前的pset二是由于。

1642
01:16:52,850 --> 01:16:56,730
所以，如果你犯了一些错误或
文体，事情可能会更好，

1643
01:16:56,730 --> 01:17:01,330
你就会有这些信息，以便您
不会做同样的事情在pset中两个。

1644
01:17:01,330 --> 01:17:06,140
然后在未来，你会得到所有
您的的PSET反馈和意见

1645
01:17:06,140 --> 01:17:08,190
回在下单前到期。

1646
01:17:08,190 --> 01:17:12,695
>> 最后，如​​果我可以把在另一个
插头反馈。

1647
01:17:12,695 --> 01:17:13,935
这是你的第一个部分。

1648
01:17:13,935 --> 01:17:15,920
这是我的第一部分
今年教学。

1649
01:17:15,920 --> 01:17:16,930
去那里。

1650
01:17:16,930 --> 01:17:19,800
写的东西，好的和坏的，
我会用它来作

1651
01:17:19,800 --> 01:17:21,320
部分在下一次做得更好。

1652
01:17:21,320 --> 01:17:24,870
最后，再次，如果你需要
什么，让我知道。

1653
01:17:24,870 --> 01:17:26,410
我更乐意帮助你们。

1654
01:17:26,410 --> 01:17:28,420
如果你只是想糖果，我
将有额外的糖果。

1655
01:17:28,420 --> 01:17:29,800
我很高兴把它给你。

1656
01:17:29,800 --> 01:17:31,190
>> 这将是一个惊人的课程。

1657
01:17:31,190 --> 01:17:34,900
这是一个，如果不是我喜欢的
当然，我已经在我的整个生命，

1658
01:17:34,900 --> 01:17:37,220
我希望这将是
为您精彩。

1659
01:17:37,220 --> 01:17:40,090
所以，我想要做我的一切力量
，你真棒。

1660
01:17:40,090 --> 01:17:46,590
我要发送一封电子邮件，如果你
在我的部分或诺亚，

1661
01:17:46,590 --> 01:17:50,310
去尝试，并安排与各
你们的时间检查过

1662
01:17:50,310 --> 01:17:53,820
接下来的几个星期，这样我就可以得到
感你的CS背景是什么，

1663
01:17:53,820 --> 01:17:58,170
它也将帮助我定制这些
部分，以更好地满足您的需求。

1664
01:17:58,170 --> 01:17:59,740
所以，这就是我得到一字排开。

1665
01:17:59,740 --> 01:18:02,260
再次，我会看到你外
如果你想在那里。

1666
01:18:02,260 --> 01:18:03,700
这是一周两节。

1667
01:18:03,700 --> 01:18:04,950
谢谢你们这么多。

1668
01:18:04,950 --> 01:18:09,067