1
00:00:00,000 --> 00:00:02,418
>> [音乐播放]

2
00:00:02,418 --> 00:00:10,542

3
00:00:10,542 --> 00:00:12,000
ALLISON BUCHHOLTZ-AU：嘿大家。

4
00:00:12,000 --> 00:00:15,640
欢迎来到你的第一个
官方CS50部分。

5
00:00:15,640 --> 00:00:19,507
正如你可以，看到这是
部CS50状，刚

6
00:00:19,507 --> 00:00:20,840
拉了我们今天的议程。

7
00:00:20,840 --> 00:00:23,990
那么，我是谁，我敢肯定
你们都知道。

8
00:00:23,990 --> 00:00:25,514
我是你的TF。

9
00:00:25,514 --> 00:00:27,930
我不只是一个随机的学生
谁在冒充你的TF。

10
00:00:27,930 --> 00:00:31,190
>> 而且我会去通过
种有部分会流，

11
00:00:31,190 --> 00:00:34,900
期望我们有，
资源，等等，等等。

12
00:00:34,900 --> 00:00:39,190
我们要谈的数组，ASCII
功能，命令行参数，

13
00:00:39,190 --> 00:00:42,020
它不是在这里，但
我也会帮助

14
00:00:42,020 --> 00:00:45,054
有种你想通过
你的下一个PSET本周。

15
00:00:45,054 --> 00:00:46,720
我相信你会明白一切。

16
00:00:46,720 --> 00:00:48,190

17
00:00:48,190 --> 00:00:53,390
>> 因此，首先question--我是谁，
除了在这里你旺盛的TF。

18
00:00:53,390 --> 00:00:55,390
我艾莉森Buchholtz金。

19
00:00:55,390 --> 00:00:57,970
这是我第二年TFing CS50。

20
00:00:57,970 --> 00:01:00,570
我也TF CS51的春天。

21
00:01:00,570 --> 00:01:03,930
你可能会看到再次出现
如果你决定接受它。

22
00:01:03,930 --> 00:01:07,370
我也是一个PAF，所以任何Freshmen--
如果你不是一个新生，

23
00:01:07,370 --> 00:01:09,980
这是我第三年
作为建议的家伙。

24
00:01:09,980 --> 00:01:13,630
我很精通
建议你对生活和课程

25
00:01:13,630 --> 00:01:16,549
CS之内，而不是在CS。

26
00:01:16,549 --> 00:01:18,090
我是一名计算机科学选矿厂。

27
00:01:18,090 --> 00:01:20,800
我在斯楼，最好的房子高级。

28
00:01:20,800 --> 00:01:22,430

29
00:01:22,430 --> 00:01:26,050
还没等我切换到
CS我大二春天，

30
00:01:26,050 --> 00:01:27,640
我其实是一个生物医学工程师。

31
00:01:27,640 --> 00:01:29,020
我本来打算去地中海学校。

32
00:01:29,020 --> 00:01:30,530
我将是一个创伤外科医生。

33
00:01:30,530 --> 00:01:33,000
并具有完全
改变，因为我把CS50。

34
00:01:33,000 --> 00:01:34,250

35
00:01:34,250 --> 00:01:36,310
我把我的课程二年级秋季。

36
00:01:36,310 --> 00:01:38,920
这是我第一次接触CS如初。

37
00:01:38,920 --> 00:01:44,104
我是你的78％的一个谁
有经验为零进来，

38
00:01:44,104 --> 00:01:45,520
它彻底改变了我的生活。

39
00:01:45,520 --> 00:01:49,820
现在我在我的工作
微软，和你可爱的TF。

40
00:01:49,820 --> 00:01:53,500
而CS50大概是1
最好的经验

41
00:01:53,500 --> 00:01:56,210
说我已经在这里
Harvard--无论服用类

42
00:01:56,210 --> 00:01:59,040
并能够帮助
教给学生喜欢你。

43
00:01:59,040 --> 00:02:01,410
>> 所以，我真的很激动
你都在这里。

44
00:02:01,410 --> 00:02:04,270
如果你进来
晚了，有糖果，

45
00:02:04,270 --> 00:02:07,227
你应该感到
免费抢过来，或者发

46
00:02:07,227 --> 00:02:08,560
别人抓住它给你。

47
00:02:08,560 --> 00:02:09,399
没关系。

48
00:02:09,399 --> 00:02:10,440
我不想吃。

49
00:02:10,440 --> 00:02:13,350
我的房间有足够的巧克力，所以
你们应该尝试并完成了。

50
00:02:13,350 --> 00:02:16,730
我知道的有100件，
但像，在周一凌晨4时，

51
00:02:16,730 --> 00:02:19,000
我想每个人都可以利用一些糖。

52
00:02:19,000 --> 00:02:21,750
>> 所以大家谁是
正式在我的部分

53
00:02:21,750 --> 00:02:24,700
应该得到一个电子邮件
从我有我的电话号码，

54
00:02:24,700 --> 00:02:29,920
电子邮件addr​​ess--随意添加我的
谷歌聊天软件，随意添​​加我在Facebook，

55
00:02:29,920 --> 00:02:33,360
同时也为您的休息，
你可以发邮件给我就在这里。

56
00:02:33,360 --> 00:02:34,450
有两个H的。

57
00:02:34,450 --> 00:02:37,090
每个人都总是这样
就像两个L's或两个C的。

58
00:02:37,090 --> 00:02:38,260
两个H在姓氏。

59
00:02:38,260 --> 00:02:41,800
否则，它会反弹，并
我不会让你的电子邮件。

60
00:02:41,800 --> 00:02:46,400
>> 所以，随时给我发电子邮件，
与我联系在任何时间。

61
00:02:46,400 --> 00:02:51,440
我可能不会回去
您应在24分钟之内，

62
00:02:51,440 --> 00:02:53,760
但我答应回去
你在24小时内。

63
00:02:53,760 --> 00:02:54,900

64
00:02:54,900 --> 00:02:58,067
如果你打电话给我半小时前
您PSET是因为，你是喜欢，

65
00:02:58,067 --> 00:02:59,650
我不知道我在做什么佳佳。

66
00:02:59,650 --> 00:03:00,160
帮我。

67
00:03:00,160 --> 00:03:04,049
我要你平静下来，
但在一天结束时，

68
00:03:04,049 --> 00:03:07,340
如果你打电话给我半小时前
您PSET是由于什么也没有写，

69
00:03:07,340 --> 00:03:11,570
我要像，好吧，也许
它的时间来使用该晚一天。

70
00:03:11,570 --> 00:03:15,215
因此，我将所有的回应你
要求在一个非常及时。

71
00:03:15,215 --> 00:03:16,482

72
00:03:16,482 --> 00:03:18,190
我的手机通常是
贴在我的手上。

73
00:03:18,190 --> 00:03:21,530
我通常多回应
快超过24小时，

74
00:03:21,530 --> 00:03:25,650
但我只能保证
24小时响应。

75
00:03:25,650 --> 00:03:26,580
>> 行。

76
00:03:26,580 --> 00:03:28,410
那么，为什么我们在这里？

77
00:03:28,410 --> 00:03:32,160
另外，如果您有问题
任何时候，请让我知道。

78
00:03:32,160 --> 00:03:32,780
我谈了很多。

79
00:03:32,780 --> 00:03:35,320
我说话快，但请
随时打断我。

80
00:03:35,320 --> 00:03:36,980
这给了我喘息的余地为好。

81
00:03:36,980 --> 00:03:38,159

82
00:03:38,159 --> 00:03:40,200
因此，部分是时间
对于我们真的只是潜水

83
00:03:40,200 --> 00:03:44,270
中，获得一些实践经验，
经过我们提到的话题

84
00:03:44,270 --> 00:03:49,760
在课堂上或在学习材料
我们建议你们在网上。

85
00:03:49,760 --> 00:03:52,980
我们将真正经历
一些有点这些资源。

86
00:03:52,980 --> 00:03:54,300

87
00:03:54,300 --> 00:03:57,400
>> 因此，一些注意事项部分支持。

88
00:03:57,400 --> 00:04:00,250
CS50--的事情之一，使
这是我最喜欢的类别之一

89
00:04:00,250 --> 00:04:02,510
是，你永远不会孤单的感觉。

90
00:04:02,510 --> 00:04:05,430
我们有超过100名员工
人谁是来帮助你的。

91
00:04:05,430 --> 00:04:08,080
我们的办公时间
周一至周四。

92
00:04:08,080 --> 00:04:13,230
因此，有这么多的人谁
爱班只是像我这样做

93
00:04:13,230 --> 00:04:15,750
，谁是真的在这里
因为他们要到这里来。

94
00:04:15,750 --> 00:04:19,390
我们中的大多数是学生，而这
就像第五类除

95
00:04:19,390 --> 00:04:20,390
我们的工作休息。

96
00:04:20,390 --> 00:04:22,723
>> 这是一个大量的工作，但
我们这样做是因为我们爱它，

97
00:04:22,723 --> 00:04:25,600
我们真的爱教你
并帮助分享我们的兴奋

98
00:04:25,600 --> 00:04:27,260
针对这个问题和这个类。

99
00:04:27,260 --> 00:04:28,490
所以，请利用。

100
00:04:28,490 --> 00:04:29,370
再来说说我们。

101
00:04:29,370 --> 00:04:33,034
我感到孤独时，我的学生
不要跟我说话，所以如果你想，

102
00:04:33,034 --> 00:04:33,950
都挂出了我。

103
00:04:33,950 --> 00:04:35,200
这将是巨大的。

104
00:04:35,200 --> 00:04:37,400
>> 因此，部分显然是
您的一个最重要的事情。

105
00:04:37,400 --> 00:04:41,770
我们将通过东西
您在演讲学会，

106
00:04:41,770 --> 00:04:44,100
做一些简短的例子
当我们有时间，

107
00:04:44,100 --> 00:04:46,187
和种一般
获取有关的事情的想法

108
00:04:46,187 --> 00:04:48,270
你应该思考
关于您的问题集。

109
00:04:48,270 --> 00:04:49,540

110
00:04:49,540 --> 00:04:53,591
有多少人真正Shorts--
看着从你从头视频

111
00:04:53,591 --> 00:04:54,090
短？

112
00:04:54,090 --> 00:04:55,460

113
00:04:55,460 --> 00:04:57,390
任何人都认识我了？

114
00:04:57,390 --> 00:04:59,720
因此，这些都是非常大的。

115
00:04:59,720 --> 00:05:01,210
你一定要看看那些。

116
00:05:01,210 --> 00:05:02,880
大量的工作已投入其中。

117
00:05:02,880 --> 00:05:06,690
而他们只是意思是
一口大小的块为你只是看

118
00:05:06,690 --> 00:05:09,760
三，四分钟，并获得
更好地理解一个概念。

119
00:05:09,760 --> 00:05:11,147

120
00:05:11,147 --> 00:05:12,980
走throughs--如何
很多人都看过

121
00:05:12,980 --> 00:05:14,880
在穿行于以前的？

122
00:05:14,880 --> 00:05:16,240
Zamyla是惊人的，对不对？

123
00:05:16,240 --> 00:05:18,100
喜欢，我希望我是Zamyla的时候。

124
00:05:18,100 --> 00:05:19,650

125
00:05:19,650 --> 00:05:21,640
所以肯定用你穿行。

126
00:05:21,640 --> 00:05:25,070
她将它分解成
小，一口大小的块。

127
00:05:25,070 --> 00:05:28,079
而当你拥有这些巨大
从你的习题集规格，

128
00:05:28,079 --> 00:05:30,870
这将是非常重要的
要能随便找个地方

129
00:05:30,870 --> 00:05:32,600
启动，并通过它慢慢地工作。

130
00:05:32,600 --> 00:05:33,610

131
00:05:33,610 --> 00:05:40,260
>> 好了，我们也有Study50，这
是study50.harvard.edu，我相信。

132
00:05:40,260 --> 00:05:42,270
你可以谷歌
学习，它会冒出来。

133
00:05:42,270 --> 00:05:45,750
这是一个
最好的资源，我们有。

134
00:05:45,750 --> 00:05:49,800
这是学习认证与笔记
和实践对你的问题

135
00:05:49,800 --> 00:05:52,430
的解决方案，你
其实可以穿行。

136
00:05:52,430 --> 00:05:57,000
所以，如果你想多练，
比我们多节以上

137
00:05:57,000 --> 00:06:00,700
比你的习题集，这是
真的，我鼓励你去的地方。

138
00:06:00,700 --> 00:06:03,590
它是建立在去年夏天通过
我的一些非常要好的朋友。

139
00:06:03,590 --> 00:06:04,480
它是惊人的。

140
00:06:04,480 --> 00:06:05,540

141
00:06:05,540 --> 00:06:08,670
事实上，有很多的幻灯片
我将使用的第

142
00:06:08,670 --> 00:06:10,190
将来自Study50。

143
00:06:10,190 --> 00:06:12,000
>> 所以很多的转录因子的使用它。

144
00:06:12,000 --> 00:06:13,920
最后，我
所提到的，办公时间。

145
00:06:13,920 --> 00:06:15,836
如果您遇到问题
家庭作业，你

146
00:06:15,836 --> 00:06:18,270
具有与麻烦
概念，来办公时间。

147
00:06:18,270 --> 00:06:20,190
去年初，在本周如果可以的话。

148
00:06:20,190 --> 00:06:23,130
走不出来了四，
因为它是一种远。

149
00:06:23,130 --> 00:06:24,780
没有人喜欢走在那里。

150
00:06:24,780 --> 00:06:27,090
但它是你的优势，
因为那时你

151
00:06:27,090 --> 00:06:29,580
将拥有所有这些转录因子，
[听不清]围绕着你。

152
00:06:29,580 --> 00:06:31,920
尤其是现在，
只是一个提示，星期四

153
00:06:31,920 --> 00:06:35,310
非常寒冷的，现在在
马瑟因您的pset

154
00:06:35,310 --> 00:06:36,577
是由于在周四。

155
00:06:36,577 --> 00:06:38,410
并知道要
用你的迟到几天呢。

156
00:06:38,410 --> 00:06:40,030
>> 所以，如果你有
与概念的麻烦，

157
00:06:40,030 --> 00:06:41,780
有许多转录因子的谁
在那里帮助你。

158
00:06:41,780 --> 00:06:43,196
所以出来马瑟周四。

159
00:06:43,196 --> 00:06:45,280
如果你想看到我，
我要去那里。

160
00:06:45,280 --> 00:06:48,870
我通常做我自己的功课，
因为没有人愿意帮助我。

161
00:06:48,870 --> 00:06:50,260
那么就来看看我们。

162
00:06:50,260 --> 00:06:51,460

163
00:06:51,460 --> 00:06:52,440
>> 我们见面了一半。

164
00:06:52,440 --> 00:06:55,400
那么有多少人参加
讲课或在线观看呢？

165
00:06:55,400 --> 00:06:56,570

166
00:06:56,570 --> 00:06:59,140
有多少人去了
上周超节？

167
00:06:59,140 --> 00:07:00,171

168
00:07:00,171 --> 00:07:00,670
凉爽。

169
00:07:00,670 --> 00:07:02,190
这实际上是一个公平的数字。

170
00:07:02,190 --> 00:07:05,425
你们有多少人看过你的
SPEC本周，为您PSET？

171
00:07:05,425 --> 00:07:07,081

172
00:07:07,081 --> 00:07:08,461
哦，我是你们的骄傲！

173
00:07:08,461 --> 00:07:09,335
更多糖果你们。

174
00:07:09,335 --> 00:07:11,070

175
00:07:11,070 --> 00:07:13,280
>> 好，让我们的意思
“我们见面了一半，”是

176
00:07:13,280 --> 00:07:16,440
这章只是
将是超级对你有用

177
00:07:16,440 --> 00:07:19,810
如果你进来看了你
规范的PSET。

178
00:07:19,810 --> 00:07:23,859
因为当我经历的概述
你应该找出来的东西，

179
00:07:23,859 --> 00:07:25,650
它不会使
如果你是多大意义

180
00:07:25,650 --> 00:07:28,358
不知道你的问题集
是要问你的事。

181
00:07:28,358 --> 00:07:29,020

182
00:07:29,020 --> 00:07:32,590
>> 如果你不来款，显然
我不能对你有用。

183
00:07:32,590 --> 00:07:36,600
我不打算把它亲手如果
你不来我的部分，现在，

184
00:07:36,600 --> 00:07:38,570
但你绝对应该。

185
00:07:38,570 --> 00:07:40,090
如果不能，在线观看。

186
00:07:40,090 --> 00:07:41,230

187
00:07:41,230 --> 00:07:42,519
他们是有原因的。

188
00:07:42,519 --> 00:07:43,560
矿将在那里。

189
00:07:43,560 --> 00:07:44,187

190
00:07:44,187 --> 00:07:47,270
当你发现，我们被记录下来，
所以它会在那里为你们。

191
00:07:47,270 --> 00:07:49,110

192
00:07:49,110 --> 00:07:51,570
同时，要
lectures--这显然

193
00:07:51,570 --> 00:07:53,790
你得到的，其中
开始你的材料在这里。

194
00:07:53,790 --> 00:07:57,430
所以，我一定会尝试
帮助你尽我所能，

195
00:07:57,430 --> 00:07:58,840
但我只能满足你们这么远。

196
00:07:58,840 --> 00:08:01,220
你要种
迎接我们的一半。

197
00:08:01,220 --> 00:08:04,050
>> Grading--所以，在座的各位
谁从我这里得到了一封电子邮件，

198
00:08:04,050 --> 00:08:05,445
你是我的正式部分。

199
00:08:05,445 --> 00:08:06,470

200
00:08:06,470 --> 00:08:08,120
我将你的分级pset中。

201
00:08:08,120 --> 00:08:12,870
我只想说，一件事，
你应该注意的

202
00:08:12,870 --> 00:08:13,820
有意见。

203
00:08:13,820 --> 00:08:17,390
该意见往往是比较有用
比实际的分数，我们给你。

204
00:08:17,390 --> 00:08:19,890
和意见实际上是
在那里我花了我很多时间

205
00:08:19,890 --> 00:08:20,770
当我分级。

206
00:08:20,770 --> 00:08:22,700
所以，我将不胜感激
它，如果你阅读。

207
00:08:22,700 --> 00:08:26,990
而它们实际上是你如何去
详细了解设计理念和风格

208
00:08:26,990 --> 00:08:29,860
并且事情是一个
少一些添油加醋。

209
00:08:29,860 --> 00:08:31,770
>> 所以，真正要注意
这些意见。

210
00:08:31,770 --> 00:08:34,720
如果您有关于他们的问题，
或者你的分数问题，

211
00:08:34,720 --> 00:08:37,620
请你跟我说话
无论是部分之前，

212
00:08:37,620 --> 00:08:41,039
我可能会挂出
在大堂，或之后。

213
00:08:41,039 --> 00:08:43,559
如果要计划
如何单对单会议

214
00:08:43,559 --> 00:08:46,100
你可以帮助改善后
习题集，只是让我知道。

215
00:08:46,100 --> 00:08:47,520

216
00:08:47,520 --> 00:08:49,750
>> 然后只是一对夫妇
对你们的提示。

217
00:08:49,750 --> 00:08:53,110
这样的最大的事情之一
我一直强调我的第

218
00:08:53,110 --> 00:08:57,700
当你学习如何编写代码是
先写出来的东西在纸上。

219
00:08:57,700 --> 00:09:01,080
如果你有一个比赛计划
在您的代码需要去

220
00:09:01,080 --> 00:09:03,230
和它所需要
这样做，它的分解

221
00:09:03,230 --> 00:09:06,000
成伪小位
你写出来的代码，

222
00:09:06,000 --> 00:09:09,780
你会少
可能使语法错误

223
00:09:09,780 --> 00:09:12,355
或创建一个，如果循环
没有一个人。

224
00:09:12,355 --> 00:09:14,064

225
00:09:14,064 --> 00:09:15,980
如果你知道你
要全面，你

226
00:09:15,980 --> 00:09:19,764
不太可能使这些微小
的错误，有时会带你

227
00:09:19,764 --> 00:09:22,555
小时修复，因为你喜欢，
在那里我错过了这架？

228
00:09:22,555 --> 00:09:23,580

229
00:09:23,580 --> 00:09:27,420
>> 关于这一点，请使用Style50。

230
00:09:27,420 --> 00:09:28,820

231
00:09:28,820 --> 00:09:31,590
特别是当你
要去上班时间，

232
00:09:31,590 --> 00:09:34,850
如果你的代码是所有
切换到一侧，

233
00:09:34,850 --> 00:09:37,740
这当然是政策
我们可以说，解决这个问题

234
00:09:37,740 --> 00:09:41,990
因此，它看起来像Style50说
它应该，然后我们会帮你的。

235
00:09:41,990 --> 00:09:43,830
因此，它会让你的生活更轻松。

236
00:09:43,830 --> 00:09:45,030
它会让我们的生活更轻松。

237
00:09:45,030 --> 00:09:46,000
每个人的幸福。

238
00:09:46,000 --> 00:09:47,290
每个人都得到更好的成绩。

239
00:09:47,290 --> 00:09:48,760
这不正是我们都想要的吗？

240
00:09:48,760 --> 00:09:50,420

241
00:09:50,420 --> 00:09:53,860
>> 所以在写的东西在纸上
你有没有碰你的电脑。

242
00:09:53,860 --> 00:09:57,540
谈出来的东西在一个较高的水平，
确保你知道你要去哪里。

243
00:09:57,540 --> 00:09:59,940
如果你不确定，
坐下来与人

244
00:09:59,940 --> 00:10:03,340
并通过分步走他们
你的代码是应该做的。

245
00:10:03,340 --> 00:10:07,940
和九次了10年，你会
像，哦，我忘了一个if条件

246
00:10:07,940 --> 00:10:12,420
还是我忘了分号在这里或
我更新这个变量是错误​​的。

247
00:10:12,420 --> 00:10:15,740
所以这些都是我成功的秘诀。

248
00:10:15,740 --> 00:10:19,820
>> 如此以来，大约有一半的你
就像你参加超部分，

249
00:10:19,820 --> 00:10:24,080
我只是很
简要经过循环，

250
00:10:24,080 --> 00:10:26,650
这不是我们原来的议程。

251
00:10:26,650 --> 00:10:28,190
但是他们真的很重要。

252
00:10:28,190 --> 00:10:30,250
所以我要去样
高速通过那些

253
00:10:30,250 --> 00:10:32,860
在我们进入我们的实际部分。

254
00:10:32,860 --> 00:10:36,269
之前，我这样做，是有
任何questions--后勤，

255
00:10:36,269 --> 00:10:38,060
就个人而言，是有
什么都想要

256
00:10:38,060 --> 00:10:40,990
了解我或约
一般一节或一类？

257
00:10:40,990 --> 00:10:43,195

258
00:10:43,195 --> 00:10:43,880
所有的好？

259
00:10:43,880 --> 00:10:45,300
OK，爽。

260
00:10:45,300 --> 00:10:46,781

261
00:10:46,781 --> 00:10:47,280
可爱的。

262
00:10:47,280 --> 00:10:50,071
>> 所以loops--你们应该都
从头开始认识到这些作品。

263
00:10:50,071 --> 00:10:51,310

264
00:10:51,310 --> 00:10:55,220
因此，循环基本上只是
一种方式为我们做什么

265
00:10:55,220 --> 00:10:58,900
次一定数量，有的反复
根据某些条件操作。

266
00:10:58,900 --> 00:11:00,140

267
00:11:00,140 --> 00:11:02,090
因此，我们有三个不同的类型。

268
00:11:02,090 --> 00:11:04,860
我们有for循环，同时，和do-whil​​e。

269
00:11:04,860 --> 00:11:06,430

270
00:11:06,430 --> 00:11:11,320
>> 因此，对于loops--我们只是有一个非常
这里的for循环总体布局。

271
00:11:11,320 --> 00:11:16,110
这是伟大的，当你知道如何
多次事需要执行。

272
00:11:16,110 --> 00:11:17,040

273
00:11:17,040 --> 00:11:18,790
当我们谈论
其他循环，你会

274
00:11:18,790 --> 00:11:20,650
看看为什么这是一个重要的区别。

275
00:11:20,650 --> 00:11:22,530
但是，for循环的东西集。

276
00:11:22,530 --> 00:11:24,590
你知道你既可以
计算数

277
00:11:24,590 --> 00:11:29,230
或者你知道多少次你
希望此重复开始。

278
00:11:29,230 --> 00:11:32,220
>> 所以，如果你看到这里，我们
刚刚一般性的

279
00:11:32,220 --> 00:11:34,480
骨骼框架
for循环在这里。

280
00:11:34,480 --> 00:11:38,080
所以对于初始化，这就是
您的变量被初始化。

281
00:11:38,080 --> 00:11:41,915
马里奥，我敢肯定，你们做了
像INT i等于0。

282
00:11:41,915 --> 00:11:42,920

283
00:11:42,920 --> 00:11:44,710
这就是将蓝色发生。

284
00:11:44,710 --> 00:11:48,290
你有你的条件，这
是什么检查每次。

285
00:11:48,290 --> 00:11:52,410
如果这种情况属实，那么
代码的其余部分执行。

286
00:11:52,410 --> 00:11:54,749
然后它会运行again--问问。

287
00:11:54,749 --> 00:11:57,290
然后我们有更新的，其中
要更新您的变量。

288
00:11:57,290 --> 00:12:01,410
所以，再一次，与像马里奥，我敢肯定，
你们不喜欢的东西我加再加。

289
00:12:01,410 --> 00:12:04,640
所以每次循环
跑了，我得到了更新，

290
00:12:04,640 --> 00:12:09,370
当我们对检查它
一定条件下，它是不断变化的。

291
00:12:09,370 --> 00:12:12,570
>> 因为如果你只是
有一个静态变量，

292
00:12:12,570 --> 00:12:15,567
如果在执行第一次，这是
只是要无限地执行。

293
00:12:15,567 --> 00:12:18,025
所以，你必须确保你
正确地更新您的变量。

294
00:12:18,025 --> 00:12:19,350

295
00:12:19,350 --> 00:12:23,890
我们也有一个刚
可视化表示形式出现。

296
00:12:23,890 --> 00:12:24,930
大家好？

297
00:12:24,930 --> 00:12:25,630
对于循环。

298
00:12:25,630 --> 00:12:27,540
应该在你的PSET看到了这些。

299
00:12:27,540 --> 00:12:28,840
凉爽。

300
00:12:28,840 --> 00:12:31,870
>> 因此，这里只是一个简单的例子。

301
00:12:31,870 --> 00:12:32,860
打印这是CS50！

302
00:12:32,860 --> 00:12:33,360
的10倍。

303
00:12:33,360 --> 00:12:34,850

304
00:12:34,850 --> 00:12:37,906
因此，我们有我们的初始化，
正如我们所看到那里，我整型

305
00:12:37,906 --> 00:12:41,280
等于0，其中i是少
比10，我加再加。

306
00:12:41,280 --> 00:12:43,090

307
00:12:43,090 --> 00:12:44,540
它会打印出10倍。

308
00:12:44,540 --> 00:12:46,230

309
00:12:46,230 --> 00:12:56,781
>> 因此，尽管loops-- while循环
伟大的，当你这样做不一定

310
00:12:56,781 --> 00:12:59,530
要知道有多少次它的
去在开始更新。

311
00:12:59,530 --> 00:13:00,640

312
00:13:00,640 --> 00:13:02,580
你只是有一些
这是检查的条件。

313
00:13:02,580 --> 00:13:09,550
这可能是类似while--
让我们来举一个例子，从您​​的pset。

314
00:13:09,550 --> 00:13:12,540
如果马里奥，你尝试
输入一个负数。

315
00:13:12,540 --> 00:13:13,270
对不对？

316
00:13:13,270 --> 00:13:15,460
你应该
再提示用户。

317
00:13:15,460 --> 00:13:20,890
所以，你可以说，好吧，如果用户输入
东西小于零，再提示

318
00:13:20,890 --> 00:13:21,390
他们。

319
00:13:21,390 --> 00:13:23,890
我敢肯定，有可能
是的东西，你们中的一些

320
00:13:23,890 --> 00:13:24,660
在你的代码中使用。

321
00:13:24,660 --> 00:13:26,270
>> 所以这是一个简单的事情。

322
00:13:26,270 --> 00:13:28,490
你有一段时间，一些
有条件的检查

323
00:13:28,490 --> 00:13:30,460
每当码去执行。

324
00:13:30,460 --> 00:13:32,660
如果结果为真，我们运行它。

325
00:13:32,660 --> 00:13:33,820
否则，我们不知道。

326
00:13:33,820 --> 00:13:35,650
什么是真正
important--东西我

327
00:13:35,650 --> 00:13:38,155
认为大卫谈到
在lecture--是大括号。

328
00:13:38,155 --> 00:13:40,760

329
00:13:40,760 --> 00:13:42,930
内凡是
括号是什么执行。

330
00:13:42,930 --> 00:13:45,850
如果你忘记那些
牙套，它一定会

331
00:13:45,850 --> 00:13:48,800
直接成为线
被执行一段时间后。

332
00:13:48,800 --> 00:13:51,040
>> 所以，如果你有三个
事情应该

333
00:13:51,040 --> 00:13:54,020
要发生时，本
条件计算结果为true，

334
00:13:54,020 --> 00:13:58,040
而你没有这些括号，只有
第一件事情将要发生。

335
00:13:58,040 --> 00:14:01,510
所以要非常的认识
你把你的大括号。

336
00:14:01,510 --> 00:14:04,880
如果你坚持Style50，
这一定会帮助你。

337
00:14:04,880 --> 00:14:06,220

338
00:14:06,220 --> 00:14:06,760
凉爽。

339
00:14:06,760 --> 00:14:10,835
>> 因此，这是从10到零倒计时。

340
00:14:10,835 --> 00:14:12,380

341
00:14:12,380 --> 00:14:16,210
正如你看到这里，我们初始化
它之外的一些柜台。

342
00:14:16,210 --> 00:14:19,250
有一件事，不同的是
我们没有初始化我们的变量

343
00:14:19,250 --> 00:14:20,300
在我们的while循环。

344
00:14:20,300 --> 00:14:22,150
它在它之外初始化。

345
00:14:22,150 --> 00:14:25,480
我们只是简单地把
条件为我们的时间。

346
00:14:25,480 --> 00:14:28,630
所以在这种情况下，它们也同时
计数大于零。

347
00:14:28,630 --> 00:14:35,134
我们打​​印出什么我们计数，
然后我们我们的递减变化。

348
00:14:35,134 --> 00:14:36,800
而这也是另外一个需要注意的事情。

349
00:14:36,800 --> 00:14:40,440
我们的更新不会出现在
while循环中的第一部分。

350
00:14:40,440 --> 00:14:44,255
它实际上将发生在
大括号，你的正文。

351
00:14:44,255 --> 00:14:46,820

352
00:14:46,820 --> 00:14:51,860
>> 所以不要-而loops--做-whil​​e循环
非常适合用户的验证。

353
00:14:51,860 --> 00:14:54,820
所以，有些人可能有
也用这个在你的PSET。

354
00:14:54,820 --> 00:14:59,960
你可以说，这样做一样，
要求用户输入。

355
00:14:59,960 --> 00:15:04,690
然后一边，喜欢的
输入小于某一数。

356
00:15:04,690 --> 00:15:10,700
>> 因此，对于一个明确的情况下，与马里奥，它
会做的printf，输入一个整数，

357
00:15:10,700 --> 00:15:13,820
然后一些整数等于调用getInt。

358
00:15:13,820 --> 00:15:17,060
然后它会实际
第一次执行该代码。

359
00:15:17,060 --> 00:15:19,120
你居然有
某种整数。

360
00:15:19,120 --> 00:15:23,380
然后你就可以说，而
该整数小于零。

361
00:15:23,380 --> 00:15:26,120
那么，它要做的是它的
要执行至少一次。

362
00:15:26,120 --> 00:15:27,536
这将检查情况。

363
00:15:27,536 --> 00:15:29,690
如果条件为
真的，它会再次运行。

364
00:15:29,690 --> 00:15:32,900
>> 所以做-whil​​e循环
巨大的用户验证，

365
00:15:32,900 --> 00:15:36,770
因为你知道代码
会至少执行

366
00:15:36,770 --> 00:15:39,720
一次，而用
while循环，你不

367
00:15:39,720 --> 00:15:41,630
保证它的
要执行一次。

368
00:15:41,630 --> 00:15:45,330
这将检查情况
，然后再决定要执行它，

369
00:15:45,330 --> 00:15:48,350
而一个做，而会
第一次执行代码

370
00:15:48,350 --> 00:15:51,110
然后检查是否
你需要重复它。

371
00:15:51,110 --> 00:15:52,985
这是否区分
道理大家？

372
00:15:52,985 --> 00:15:53,680

373
00:15:53,680 --> 00:15:54,180
行。

374
00:15:54,180 --> 00:15:55,651

375
00:15:55,651 --> 00:15:56,150
凉爽。

376
00:15:56,150 --> 00:15:57,380

377
00:15:57,380 --> 00:15:59,800
>> 所以在这种情况下，这是一种
什么，我说的是，

378
00:15:59,800 --> 00:16:02,210
这再提示操作，直至
得到的正数。

379
00:16:02,210 --> 00:16:05,060
因此，我们知道的printf
“输入一个正数”

380
00:16:05,060 --> 00:16:08,720
实际上要求的
输入会发生至少一次。

381
00:16:08,720 --> 00:16:12,650
如果用户是邪恶的，并保持
输入一个负数，谁

382
00:16:12,650 --> 00:16:14,210
不知有多少次，它会执行。

383
00:16:14,210 --> 00:16:17,500
但是这个代码是保证
执行至少一次。

384
00:16:17,500 --> 00:16:20,040
这就是为什么它的伟大
验证输入。

385
00:16:20,040 --> 00:16:22,300
你会使用相当多。

386
00:16:22,300 --> 00:16:23,870

387
00:16:23,870 --> 00:16:25,830
>> 好吧，什么问题这么远吗？

388
00:16:25,830 --> 00:16:27,080

389
00:16:27,080 --> 00:16:28,030
我们都好？

390
00:16:28,030 --> 00:16:29,513
难道我说的太快了？

391
00:16:29,513 --> 00:16:30,520

392
00:16:30,520 --> 00:16:31,130
我们是好？

393
00:16:31,130 --> 00:16:31,630
行。

394
00:16:31,630 --> 00:16:32,960

395
00:16:32,960 --> 00:16:33,800
真棒

396
00:16:33,800 --> 00:16:35,841
>> 因此，我们要继续前进
谈谈阵列。

397
00:16:35,841 --> 00:16:36,660

398
00:16:36,660 --> 00:16:37,600
凉爽。

399
00:16:37,600 --> 00:16:40,700
所以数组是基本
只是数据结构

400
00:16:40,700 --> 00:16:43,260
这使我们能够存储
同一类型的东西。

401
00:16:43,260 --> 00:16:47,920
因此，如果你曾经有一个数组，它的
或者只是将不得不整数

402
00:16:47,920 --> 00:16:51,590
或者它只是将不得不花车
或者它只是将不得不字符。

403
00:16:51,590 --> 00:16:55,440
你不会有一个int
一个char与双浮子。

404
00:16:55,440 --> 00:16:56,850
一件事。

405
00:16:56,850 --> 00:17:00,810
阵列只是一个尺寸，
或者他们只是一种类型。

406
00:17:00,810 --> 00:17:05,679
>> 所以在这里我们有大小的数组
3，在这三个整数。

407
00:17:05,679 --> 00:17:07,970
他们可以浮动，但我们
要说他们是整数。

408
00:17:07,970 --> 00:17:09,310

409
00:17:09,310 --> 00:17:16,970
所以，有一点需要知道的是，数组
是一组大小在初始化

410
00:17:16,970 --> 00:17:22,285
它们，并且它们不easily--
因为大家都不太舒服，

411
00:17:22,285 --> 00:17:25,034
你应该把它们看作
不能够在尺寸上延伸。

412
00:17:25,034 --> 00:17:26,119

413
00:17:26,119 --> 00:17:28,740
但是大的你设置了
你的数组中的开始，

414
00:17:28,740 --> 00:17:31,070
这就是它的大小是怎么回事
留下来，因为数组

415
00:17:31,070 --> 00:17:33,070
是连续的存储器块。

416
00:17:33,070 --> 00:17:34,007

417
00:17:34,007 --> 00:17:35,840
当你们拿到
进入多一点点

418
00:17:35,840 --> 00:17:40,820
如何存储的实际布置在
盘和在所述堆和栈，

419
00:17:40,820 --> 00:17:42,220
它会做一点更有意义。

420
00:17:42,220 --> 00:17:48,310
>> 但是，你可能只是觉得像，这是
只是排在你的磁盘空间。

421
00:17:48,310 --> 00:17:52,540
而且你不能保证有
去后它成为空闲空间。

422
00:17:52,540 --> 00:17:55,290
可以初始化一个数组
3，然后也许你

423
00:17:55,290 --> 00:17:59,190
初始化五个另一个数组
后来，它的后正确的。

424
00:17:59,190 --> 00:18:04,000
所以，如果你走过去点
3在该第一阵列，

425
00:18:04,000 --> 00:18:06,370
你会写
过别的东西。

426
00:18:06,370 --> 00:18:10,390
所以数组are--为你们，只是
把它们看成一个固定的大小。

427
00:18:10,390 --> 00:18:12,700

428
00:18:12,700 --> 00:18:16,890
>> 所以，创建你要去的array--
需要这个做了不少。

429
00:18:16,890 --> 00:18:18,240

430
00:18:18,240 --> 00:18:22,080
所以在以同样的方式，我们有一个
一般结构为我们的for循环，

431
00:18:22,080 --> 00:18:24,910
我们有一个很好的通用
结构为我们的数组。

432
00:18:24,910 --> 00:18:28,430
因为它们的一种类型中，所有的
数组中的元素是一种类型的，

433
00:18:28,430 --> 00:18:30,950
您需要初始化
那是什么类型的。

434
00:18:30,950 --> 00:18:33,804
>> 所以，当你看到这里，我们有一个
可爱的小支架的数据类型。

435
00:18:33,804 --> 00:18:35,970
因此，如果我们要创建一个int
阵列，这将是int。

436
00:18:35,970 --> 00:18:38,830
如果我们要创建一个char
数组，它会是char。

437
00:18:38,830 --> 00:18:41,890
如果我们要创建一个字符串
阵列，这将是字符串。

438
00:18:41,890 --> 00:18:45,140
然后阵列的名称，
无论你想的那样。

439
00:18:45,140 --> 00:18:51,750
因此，也许它的测试成绩还是可能
这是学生或也许是糖果。

440
00:18:51,750 --> 00:18:54,440
无论你决定你的名字
数组，这就是它会。

441
00:18:54,440 --> 00:18:57,260
>> 然后在括号中，你会
有你想要的大小。

442
00:18:57,260 --> 00:19:01,350
因此，我们存储10个学生或
我们存储15种糖果？

443
00:19:01,350 --> 00:19:03,200

444
00:19:03,200 --> 00:19:03,920
什么不是。

445
00:19:03,920 --> 00:19:06,830
所以，在这里我们的例子中，
我们要创建一个数组

446
00:19:06,830 --> 00:19:10,100
大小3，你的家伙
看到这里就对了。

447
00:19:10,100 --> 00:19:11,350

448
00:19:11,350 --> 00:19:15,990
当我们第一次初始化
它，一切都设置为零。

449
00:19:15,990 --> 00:19:18,970
所以它只是想
像一张白纸。

450
00:19:18,970 --> 00:19:22,550
我们拥有所有这些空间，我们都
这些盒子，我们可以把我们的数据为，

451
00:19:22,550 --> 00:19:25,530
但他们只是空白
暂且。

452
00:19:25,530 --> 00:19:28,700
>> 因此，如果我们想实际
为其分配这些值，

453
00:19:28,700 --> 00:19:33,050
我们这样做是正确的在这里显示。

454
00:19:33,050 --> 00:19:39,170
所以，你有什么对你的名字
数组，然后你想要的指标。

455
00:19:39,170 --> 00:19:43,070
因此，该指数仅仅指的是，
就像我们在看什么插槽。

456
00:19:43,070 --> 00:19:47,830
和重要的事情要注意
是数组索引从零开始。

457
00:19:47,830 --> 00:19:53,160
因此，如果我们想在存储器中的第一空间
我们的阵列，这将是零。

458
00:19:53,160 --> 00:19:54,740
如果我们希望第二个，它会是一个。

459
00:19:54,740 --> 00:19:56,198
如果我们想在第三，这将是两人。

460
00:19:56,198 --> 00:19:57,820
等等等等。

461
00:19:57,820 --> 00:20:02,130
>> 这也是为什么，以往，
当我们做loops--我敢肯定，

462
00:20:02,130 --> 00:20:05,030
你们想知道，为什么
我们开始在0与1？

463
00:20:05,030 --> 00:20:09,909
那是因为，当我们转换
为使用数组，它映射正确。

464
00:20:09,909 --> 00:20:11,700
所以，如果你想
遍历到一个数组中，

465
00:20:11,700 --> 00:20:14,830
使得很多更有意义
做i等于0，因为我们

466
00:20:14,830 --> 00:20:17,940
知道将对应
以在存储器中的第一点。

467
00:20:17,940 --> 00:20:18,990

468
00:20:18,990 --> 00:20:19,990
每个人都好有吗？

469
00:20:19,990 --> 00:20:21,060

470
00:20:21,060 --> 00:20:21,560
凉爽。

471
00:20:21,560 --> 00:20:26,240
>> 然后在这里的底部是刚刚
另一种方式来初始化一个数组。

472
00:20:26,240 --> 00:20:29,590
你仍然有你
数据类型和名称，

473
00:20:29,590 --> 00:20:31,960
但不是实际
把一个规模在那里，

474
00:20:31,960 --> 00:20:33,830
你可以做的空括号。

475
00:20:33,830 --> 00:20:36,350
然后用这些花
撑杆在底部，

476
00:20:36,350 --> 00:20:40,270
你可以只输入数据
你想用逗号隔开。

477
00:20:40,270 --> 00:20:43,070
并自动将
说好，我看

478
00:20:43,070 --> 00:20:47,300
你有三个
事情在这些括号。

479
00:20:47,300 --> 00:20:51,410
所以我知道我需要分配3
的存储器块，然后存储这些。

480
00:20:51,410 --> 00:20:55,300

481
00:20:55,300 --> 00:21:01,670
>> 因此，第一个版本，你可以使用
如果你问你的用户输入

482
00:21:01,670 --> 00:21:04,770
值，这样就可以
遍历数组

483
00:21:04,770 --> 00:21:07,660
和ask--得到一些INT输入它们。

484
00:21:07,660 --> 00:21:10,500
如果你预先知道的值，
这让很多更有意义

485
00:21:10,500 --> 00:21:12,110
使用第二种方法。

486
00:21:12,110 --> 00:21:17,270
但在大多数情况下，你可能不知道
什么这些值将是。

487
00:21:17,270 --> 00:21:19,060

488
00:21:19,060 --> 00:21:19,560
凉爽。

489
00:21:19,560 --> 00:21:20,393
还有没有其他问题？

490
00:21:20,393 --> 00:21:21,206

491
00:21:21,206 --> 00:21:21,705
好吧。

492
00:21:21,705 --> 00:21:25,960

493
00:21:25,960 --> 00:21:30,370
>> 所以，访问elements--这么一
关于阵列的伟大的事情

494
00:21:30,370 --> 00:21:33,310
是，它们是随机
访问，这意味着你

495
00:21:33,310 --> 00:21:36,010
不必去翻每个块。

496
00:21:36,010 --> 00:21:38,150
如果你知道你
想要什么块2，

497
00:21:38,150 --> 00:21:40,820
你可以说，给我挡住两人。

498
00:21:40,820 --> 00:21:44,160
这就是为什么这些
索引是如此的重要，

499
00:21:44,160 --> 00:21:46,220
这就是我们如何真正访问它们。

500
00:21:46,220 --> 00:21:50,660
所以在这种情况下，如我们之前的时候看到
我们被赋值，在一

501
00:21:50,660 --> 00:21:55,360
之前，我们有名称和
指数我们想访问，对不对？

502
00:21:55,360 --> 00:21:59,370
因此，在以同样的方式，这就是我们
这样做实际上是拉出来的数据。

503
00:21:59,370 --> 00:22:02,940
我们的名字，我们
有我们想要的索引。

504
00:22:02,940 --> 00:22:06,710
>> 所以在这种情况下，对环
这儿的底部，任何人

505
00:22:06,710 --> 00:22:09,060
知道它在做什么，
它会打印出来？

506
00:22:09,060 --> 00:22:13,771

507
00:22:13,771 --> 00:22:14,270
Mmhmm​​？

508
00:22:14,270 --> 00:22:17,790

509
00:22:17,790 --> 00:22:18,520
没错。

510
00:22:18,520 --> 00:22:20,130
所以，是的，它只是通过迭代。

511
00:22:20,130 --> 00:22:23,410
i等于zero--我们可以走
通过代码只是快。

512
00:22:23,410 --> 00:22:26,680
i是等于零，i是少
三多在这一点上，对不对？

513
00:22:26,680 --> 00:22:27,780
这样检查出来。

514
00:22:27,780 --> 00:22:33,370
我们说好，打印˚F
无论是在我的温度。

515
00:22:33,370 --> 00:22:37,990
我是零就在这里，当我们第一次
迭代，所以我们去这第一点，

516
00:22:37,990 --> 00:22:40,840
我们说好，65是
数我们要打印出来。

517
00:22:40,840 --> 00:22:43,570
所以它会打印出65
然后做一个新的生产线。

518
00:22:43,570 --> 00:22:46,550
我会更新，所以它打印87。

519
00:22:46,550 --> 00:22:48,780
它再次更新，它会打印30。

520
00:22:48,780 --> 00:22:49,810

521
00:22:49,810 --> 00:22:50,630
每个人都很酷吧？

522
00:22:50,630 --> 00:22:51,630

523
00:22:51,630 --> 00:22:52,130
真棒。

524
00:22:52,130 --> 00:22:54,340

525
00:22:54,340 --> 00:22:54,840
>> 行。

526
00:22:54,840 --> 00:22:57,710
因此，这里的那种之一
的事情，我是说怎么样

527
00:22:57,710 --> 00:23:00,020
你可以跟踪
一个人的成绩，为什么

528
00:23:00,020 --> 00:23:03,300
你可以使用第一
初始化它的方式

529
00:23:03,300 --> 00:23:04,890
而不是说第二种方法。

530
00:23:04,890 --> 00:23:06,620
而这只是经过。

531
00:23:06,620 --> 00:23:08,945
并请注意，我们有30类大小。

532
00:23:08,945 --> 00:23:10,690

533
00:23:10,690 --> 00:23:15,770
我们正在初始化这个
整型数组的大小是30的。

534
00:23:15,770 --> 00:23:18,070
然后我们遍历
通过与我们

535
00:23:18,070 --> 00:23:20,910
要求用户输入
分数为每个这些

536
00:23:20,910 --> 00:23:23,700
然后将其分配给
在存储器中的特定位置

537
00:23:23,700 --> 00:23:24,860
介于该数组。

538
00:23:24,860 --> 00:23:26,700

539
00:23:26,700 --> 00:23:27,890
酷？

540
00:23:27,890 --> 00:23:29,650
这是否有意义大家？

541
00:23:29,650 --> 00:23:30,150
Mmhmm​​？

542
00:23:30,150 --> 00:23:32,910

543
00:23:32,910 --> 00:23:40,360
>> 因此，包括hashtag定义类的大小
30是一个预处理指令，

544
00:23:40,360 --> 00:23:43,780
这只是意味着它gets--有
做这样的编译过程。

545
00:23:43,780 --> 00:23:47,595
你可以把它想象
作为全局变量。

546
00:23:47,595 --> 00:23:49,260

547
00:23:49,260 --> 00:23:53,030
我们这样做的方式是
typically--它可以让你的代码

548
00:23:53,030 --> 00:23:54,770
可以更容易地改变。

549
00:23:54,770 --> 00:23:59,480
所以我们可以说，我们的班级规模
突然变从30到15，

550
00:23:59,480 --> 00:24:03,930
如果我没有定义这种方式，我会
必须要经过我的整个程序

551
00:24:03,930 --> 00:24:07,420
并改变了30的每个实例到15。

552
00:24:07,420 --> 00:24:11,590
但是这一点，我得到改变一个
现货方面，和其他一切的变化。

553
00:24:11,590 --> 00:24:14,930
>> 如果你想要做的
在一个情况下，散列定义

554
00:24:14,930 --> 00:24:19,020
在那里你正在跟踪一些
设置分数数一类

555
00:24:19,020 --> 00:24:23,250
或者您使用的是数字
将要使用的，等等，

556
00:24:23,250 --> 00:24:27,740
整个一个很长的程序，它的
更好地限定在一开始

557
00:24:27,740 --> 00:24:34,440
因此，如果以往任何时候都改变了，你会得到
改变一个地方，而不是100。

558
00:24:34,440 --> 00:24:34,940
是吗？

559
00:24:34,940 --> 00:24:39,830
>> 学生：介于这样做，只是
过声明[听不清]在顶部。

560
00:24:39,830 --> 00:24:42,470
>> ALLISON BUCHHOLTZ-AU：所以这
是因为有efficient--

561
00:24:42,470 --> 00:24:45,460
它是一种范围之内
我们可以在本节涵盖。

562
00:24:45,460 --> 00:24:49,236
它与效率做多
以及如何实际的东西

563
00:24:49,236 --> 00:24:50,485
在编译过程中的工作。

564
00:24:50,485 --> 00:24:52,590

565
00:24:52,590 --> 00:24:55,006
如果你想真正了解
这件事，我很高兴地向您发送

566
00:24:55,006 --> 00:24:56,450
一封电子邮件，它的资源。

567
00:24:56,450 --> 00:24:57,810

568
00:24:57,810 --> 00:25:03,880
散列定义趋于
最好的东西。

569
00:25:03,880 --> 00:25:06,380
而随着你的代码越多，你
种学习的细微差别

570
00:25:06,380 --> 00:25:09,135
当你要使用的
全球对哈希定义。

571
00:25:09,135 --> 00:25:11,010
但暂时，
你真的没有

572
00:25:11,010 --> 00:25:13,290
担心的是
这简短的回答。

573
00:25:13,290 --> 00:25:15,360

574
00:25:15,360 --> 00:25:16,360
每个人都好有吗？

575
00:25:16,360 --> 00:25:18,151
而且，如果你想
使用散列定义，

576
00:25:18,151 --> 00:25:21,120
这真的很重要要注意
这个名字应该是全部大写。

577
00:25:21,120 --> 00:25:22,210

578
00:25:22,210 --> 00:25:24,674
我们不只是在做
班级规模是巨大的。

579
00:25:24,674 --> 00:25:26,090
它实际上应该是全部大写。

580
00:25:26,090 --> 00:25:27,880

581
00:25:27,880 --> 00:25:28,610
凉爽。

582
00:25:28,610 --> 00:25:30,130
还有别的吗？

583
00:25:30,130 --> 00:25:31,190
我们是好？

584
00:25:31,190 --> 00:25:32,220
可爱的。

585
00:25:32,220 --> 00:25:32,720
欢迎光临。

586
00:25:32,720 --> 00:25:34,240

587
00:25:34,240 --> 00:25:38,495
>> 好了，我要你们去看看
在此，看你是否能找到的bug。

588
00:25:38,495 --> 00:25:45,580

589
00:25:45,580 --> 00:25:46,507
我会给你一个提示。

590
00:25:46,507 --> 00:25:47,840
它是介于该for循环。

591
00:25:47,840 --> 00:25:53,070

592
00:25:53,070 --> 00:25:53,665
Mmhmm​​？

593
00:25:53,665 --> 00:25:55,704
>> 学生：应小于等于2。

594
00:25:55,704 --> 00:25:56,920

595
00:25:56,920 --> 00:26:01,094
>> 艾里逊：所以它可能比小于或
等于2，或者它可以是小于3。

596
00:26:01,094 --> 00:26:02,510
和有什么理由是什么？

597
00:26:02,510 --> 00:26:05,135
>> 学生：[听不清]，0，1，2。

598
00:26:05,135 --> 00:26:06,080
>> 艾里逊：没错。

599
00:26:06,080 --> 00:26:12,180
因此，在大小为​​n的阵列，我们
只有有n个减1的指数。

600
00:26:12,180 --> 00:26:13,700

601
00:26:13,700 --> 00:26:14,200
凉爽。

602
00:26:14,200 --> 00:26:15,091

603
00:26:15,091 --> 00:26:17,840
然后我们就可以得到真正的疯狂
并获得多维数组。

604
00:26:17,840 --> 00:26:19,340

605
00:26:19,340 --> 00:26:23,960
其中的一个问题，当我把它我
一年所需的多维数组，

606
00:26:23,960 --> 00:26:28,720
而且我认为他们中的一个可能需要
就在今年，这样很舒服。

607
00:26:28,720 --> 00:26:30,140
包装你的头左右，现在。

608
00:26:30,140 --> 00:26:33,087
它会回来困扰
你，但在冷静的方式。

609
00:26:33,087 --> 00:26:35,420
这样你就可以真的只是想
多维数组的

610
00:26:35,420 --> 00:26:36,870
作为数组的数组。

611
00:26:36,870 --> 00:26:38,060

612
00:26:38,060 --> 00:26:43,809
所以，你可以种觉得这顶
行作为存储器的第一个块。

613
00:26:43,809 --> 00:26:45,600
而这一次是
内存第二块，

614
00:26:45,600 --> 00:26:47,570
和最后一行的
内存三大块。

615
00:26:47,570 --> 00:26:50,740
和范围内的，有一个阵列。

616
00:26:50,740 --> 00:26:53,250
不过，当然，它更容易
描绘这样。

617
00:26:53,250 --> 00:26:55,610
>> 所以，你初始化它以同样的方式。

618
00:26:55,610 --> 00:26:57,290

619
00:26:57,290 --> 00:27:01,610
这是一个字符
三名由三种。

620
00:27:01,610 --> 00:27:04,180
所以，你有三排
和三列。

621
00:27:04,180 --> 00:27:06,760
我们表示这样的看法。

622
00:27:06,760 --> 00:27:11,800
而你能访问它
相同的方式，由排列。

623
00:27:11,800 --> 00:27:14,840
所以1,1我们在这里看到。

624
00:27:14,840 --> 00:27:18,730
我们分配一个零，零在那里。

625
00:27:18,730 --> 00:27:21,900
2,0和0,2。

626
00:27:21,900 --> 00:27:26,900
所以你只需访问them--如果
任何人的做过线性代数，

627
00:27:26,900 --> 00:27:31,580
访问中的元件以相同的方式
一个矩阵的计算，它在这里同样的想法。

628
00:27:31,580 --> 00:27:33,030
这样你就可以与回数学。

629
00:27:33,030 --> 00:27:34,130

630
00:27:34,130 --> 00:27:36,380
你也不必太担心
很多关于这个现在。

631
00:27:36,380 --> 00:27:38,671
这是件好事，曝光，
要知道你可以做到这一点。

632
00:27:38,671 --> 00:27:42,700
你可以创建一些
疯狂number--可以

633
00:27:42,700 --> 00:27:44,750
打造疯狂阵列的
所有我要说的话。

634
00:27:44,750 --> 00:27:45,250
[听不清]

635
00:27:45,250 --> 00:27:46,585

636
00:27:46,585 --> 00:27:48,460
它变得有点疯狂，
但它真的很酷。

637
00:27:48,460 --> 00:27:50,020

638
00:27:50,020 --> 00:27:50,670
真棒。

639
00:27:50,670 --> 00:27:52,550
>> 然后，让我们有一个例子来说明。

640
00:27:52,550 --> 00:27:54,165
它可以计算一个字符串的长度。

641
00:27:54,165 --> 00:27:55,210

642
00:27:55,210 --> 00:27:59,670
那么有多少人知道，
您正在使用的字符串

643
00:27:59,670 --> 00:28:01,265
是字符数组只？

644
00:28:01,265 --> 00:28:03,670

645
00:28:03,670 --> 00:28:04,655
好吧，是的。

646
00:28:04,655 --> 00:28:08,000
所以你们可能会认为你没有
使用数组，但是以往任何时候

647
00:28:08,000 --> 00:28:10,740
您在使用的GetString
CSView库，你

648
00:28:10,740 --> 00:28:14,690
其实只是要求
字符数组。

649
00:28:14,690 --> 00:28:17,450
我们正在照顾所有的
在后端为您服务。

650
00:28:17,450 --> 00:28:20,184
但你使用过
数组，因为你开始。

651
00:28:20,184 --> 00:28:21,350
你只是不知道它。

652
00:28:21,350 --> 00:28:22,420

653
00:28:22,420 --> 00:28:28,390
>> 而只要你有一个字符数组
或数组的存储字符串

654
00:28:28,390 --> 00:28:32,050
过去的事情永远是什么
叫一个空终止，这

655
00:28:32,050 --> 00:28:33,830
这是在这里。

656
00:28:33,830 --> 00:28:37,300
那就是在结束时
每次你存储字。

657
00:28:37,300 --> 00:28:41,170
因此，如果我们想弄清楚的
字符串的长度，我们可以说，

658
00:28:41,170 --> 00:28:45,320
嗯，你知道，
该块的内容

659
00:28:45,320 --> 00:28:46,867
不等于我们的空终止。

660
00:28:46,867 --> 00:28:49,450
这意味着，有一些
性格有我们实际上是

661
00:28:49,450 --> 00:28:51,540
关心那是字的一部分。

662
00:28:51,540 --> 00:28:52,665
你增加的长度。

663
00:28:52,665 --> 00:28:55,540
然后，当我们真正去
这个词的结尾，它会终止

664
00:28:55,540 --> 00:28:58,790
它会回报我们的长度我们。

665
00:28:58,790 --> 00:29:00,098
Mmhmm​​？

666
00:29:00,098 --> 00:29:02,906
>> 学生：请问空间
算不算空终止？

667
00:29:02,906 --> 00:29:04,780
艾里逊：那么一个空间
不是一个空终止。

668
00:29:04,780 --> 00:29:10,590
所以，如果你有multiple--空间
实际上是一个特定的ASCII值。

669
00:29:10,590 --> 00:29:11,719

670
00:29:11,719 --> 00:29:13,552
学生：什么是
再次感叹平等？

671
00:29:13,552 --> 00:29:17,080
ALLISON：所以，这就是您参考。

672
00:29:17,080 --> 00:29:21,220
如果你听到我在办公时间内，
我总是把它一样，砰等于。

673
00:29:21,220 --> 00:29:23,520
因此，爆炸没有。

674
00:29:23,520 --> 00:29:25,370
因此，这是不是等于。

675
00:29:25,370 --> 00:29:28,480

676
00:29:28,480 --> 00:29:32,290
所以，如果你想
看看什么是假的，

677
00:29:32,290 --> 00:29:35,915
你知道总是这样，什么爆炸
变量是，如果它是假的，

678
00:29:35,915 --> 00:29:38,540
它的计算结果为true并
可以做很酷的东西这一点。

679
00:29:38,540 --> 00:29:39,830

680
00:29:39,830 --> 00:29:40,675
后来更多。

681
00:29:40,675 --> 00:29:42,090

682
00:29:42,090 --> 00:29:42,590
凉爽。

683
00:29:42,590 --> 00:29:44,260
一切都很好吗？

684
00:29:44,260 --> 00:29:44,760
真棒。

685
00:29:44,760 --> 00:29:48,045
>> 所以，现在这是你的男人“的时间
工作，因为我一直在谈论。

686
00:29:48,045 --> 00:29:49,220

687
00:29:49,220 --> 00:29:53,200
所以，我希望你只是创建一个数组
与整数1，2，和3，

688
00:29:53,200 --> 00:29:54,660
然后让他们打印出来。

689
00:29:54,660 --> 00:29:58,050
你不必做的一样，
主，等等，等等，等等，等等。

690
00:29:58,050 --> 00:30:00,840
我只是想让你初始化
数组，然后创建

691
00:30:00,840 --> 00:30:04,790
一个for循环打印出来out--
或while循环，给你。

692
00:30:04,790 --> 00:30:07,600
>> 我只给你一对夫妇
分上工作了。

693
00:30:07,600 --> 00:30:09,320
我要休息我的声​​音。

694
00:30:09,320 --> 00:30:13,290
如果您有任何问题，我很高兴
要过来和你说话的家伙。

695
00:30:13,290 --> 00:30:15,290
随时与对方交谈。

696
00:30:15,290 --> 00:30:16,125
获得更多的糖果。

697
00:30:16,125 --> 00:30:17,181

698
00:30:17,181 --> 00:30:18,930
其实，我只是
走动糖果。

699
00:30:18,930 --> 00:30:19,600
怎么样？

700
00:30:19,600 --> 00:30:22,974

701
00:30:22,974 --> 00:30:23,938
>> 你愿意购买吗？

702
00:30:23,938 --> 00:30:34,703

703
00:30:34,703 --> 00:30:36,675
任何人在这个房间要糖果？

704
00:30:36,675 --> 00:30:47,030

705
00:30:47,030 --> 00:30:49,206
您也可以不止一个，伙计们。

706
00:30:49,206 --> 00:30:50,330
抓了一把，如果你想要的。

707
00:30:50,330 --> 00:30:52,690

708
00:30:52,690 --> 00:30:53,190
不妨。

709
00:30:53,190 --> 00:30:54,929

710
00:30:54,929 --> 00:30:55,720
其他人都好？

711
00:30:55,720 --> 00:30:57,561

712
00:30:57,561 --> 00:30:58,060
行。

713
00:30:58,060 --> 00:31:02,750

714
00:31:02,750 --> 00:31:07,290
>> 另外，我要创造
匿名谷歌的形式，

715
00:31:07,290 --> 00:31:09,830
并且你们可以只提交
每一段后反馈

716
00:31:09,830 --> 00:31:14,115
如果有什么东西要
改善后或者是你想要完成的。

717
00:31:14,115 --> 00:31:17,135
如果我是一个有点太强力的
为了你，我可以调下来。

718
00:31:17,135 --> 00:31:18,510

719
00:31:18,510 --> 00:31:20,885
我将创建并发送
出来大家算账。

720
00:31:20,885 --> 00:32:39,420

721
00:32:39,420 --> 00:32:40,020
>> 行。

722
00:32:40,020 --> 00:32:41,050
因此，让我们从小事做起。

723
00:32:41,050 --> 00:32:42,740
如何将我们初始化我们的数组？

724
00:32:42,740 --> 00:32:49,690

725
00:32:49,690 --> 00:32:51,670
什么是我们的阵列的类型？

726
00:32:51,670 --> 00:32:52,410
一个int，不是吗？

727
00:32:52,410 --> 00:32:54,740
好了，你想要做什么
打电话给你的数组？

728
00:32:54,740 --> 00:32:57,880

729
00:32:57,880 --> 00:32:59,230
int数组，很酷。

730
00:32:59,230 --> 00:33:04,200
好吧，让我们有整型int数组
等于，之后，我们有什么？

731
00:33:04,200 --> 00:33:07,009

732
00:33:07,009 --> 00:33:08,259
学生：[听不清]括号中。

733
00:33:08,259 --> 00:33:09,140
艾里逊：括号。

734
00:33:09,140 --> 00:33:10,330

735
00:33:10,330 --> 00:33:11,775
然后在大括号内？

736
00:33:11,775 --> 00:33:14,360

737
00:33:14,360 --> 00:33:16,830
一个逗号2逗号三种。

738
00:33:16,830 --> 00:33:17,330
凉爽。

739
00:33:17,330 --> 00:33:18,660
所以这是所有权利。

740
00:33:18,660 --> 00:33:21,480
所以，现在我们有我们的for循环。

741
00:33:21,480 --> 00:33:24,180
所以在第一部分我们的
for循环，我们有什么？

742
00:33:24,180 --> 00:33:25,796

743
00:33:25,796 --> 00:33:27,420
>> 学生：我等于0？

744
00:33:27,420 --> 00:33:31,400
>> 艾里逊：那么INT i等于0，
然后呢，是我们的条件？

745
00:33:31,400 --> 00:33:33,750

746
00:33:33,750 --> 00:33:36,120
什么是我要小于？

747
00:33:36,120 --> 00:33:39,510
不到三年，并
我们怎么做，我们更新吗？

748
00:33:39,510 --> 00:33:41,630
我加上加，由一个更新它。

749
00:33:41,630 --> 00:33:46,150
然后我们将有
一些printf的整数中，

750
00:33:46,150 --> 00:33:49,530
什么是最后一个
一部分实际上

751
00:33:49,530 --> 00:33:51,370
会说什么，我们应该打印？

752
00:33:51,370 --> 00:33:55,610

753
00:33:55,610 --> 00:33:59,120
这将是的名称
数组，数据类型为int的数组，对不对？

754
00:33:59,120 --> 00:34:01,090
和什么在int数组的括号？

755
00:34:01,090 --> 00:34:02,540

756
00:34:02,540 --> 00:34:03,640
我。

757
00:34:03,640 --> 00:34:06,550
[？所以，我？]叫我
例如，但你去那里。

758
00:34:06,550 --> 00:34:07,939

759
00:34:07,939 --> 00:34:08,480
没有那么糟糕。

760
00:34:08,480 --> 00:34:09,250
大家好？

761
00:34:09,250 --> 00:34:10,220

762
00:34:10,220 --> 00:34:10,719
凉爽。

763
00:34:10,719 --> 00:34:12,949

764
00:34:12,949 --> 00:34:14,340
>> 因此，我们用数组实现。

765
00:34:14,340 --> 00:34:15,190
恭喜。

766
00:34:15,190 --> 00:34:18,274
你设法迭代
通过所有the--是吗？

767
00:34:18,274 --> 00:34:19,705
>> 学生：[听不清]

768
00:34:19,705 --> 00:34:20,659
>> 艾里逊：是的。

769
00:34:20,659 --> 00:34:26,383

770
00:34:26,383 --> 00:34:27,798
>> 学生：我有一个问题。

771
00:34:27,798 --> 00:34:30,288
你应该缩进括号？

772
00:34:30,288 --> 00:34:34,150
>> 艾里逊：那么大括号应该排队
用for循环，然后一切

773
00:34:34,150 --> 00:34:35,699
里面的大括号应缩进。

774
00:34:35,699 --> 00:34:37,824
>> 学生：OK，应
for循环被缩进？

775
00:34:37,824 --> 00:34:41,159
>> 艾里逊：for循环不
需要在这一点上缩进。

776
00:34:41,159 --> 00:34:46,750
如果你是主，如果我们
实际上有一个main函数在这里，

777
00:34:46,750 --> 00:34:48,929
它会从主缩进。

778
00:34:48,929 --> 00:34:52,590
但在这种情况下，它的罚款。

779
00:34:52,590 --> 00:34:53,354
是的，问题。

780
00:34:53,354 --> 00:34:55,687
>> 学生：你需要有
括号的例子呢？

781
00:34:55,687 --> 00:34:59,050

782
00:34:59,050 --> 00:35:01,260
>> ALLISON：是的，如果你是
初始化这种方式。

783
00:35:01,260 --> 00:35:03,430

784
00:35:03,430 --> 00:35:06,860
所以请记住，这是第二次
初始化数组，其中的方法

785
00:35:06,860 --> 00:35:10,680
我们有括号，然后我们的实际
数据通过在逗号分隔。

786
00:35:10,680 --> 00:35:14,700

787
00:35:14,700 --> 00:35:17,281
>> 学生：我想有
括号内为例子。

788
00:35:17,281 --> 00:35:19,010
>> 艾里逊：不，他们是大括号。

789
00:35:19,010 --> 00:35:20,039
他们是大括号。

790
00:35:20,039 --> 00:35:22,330
如果你正在初始化它
这第二种方法，它的括号。

791
00:35:22,330 --> 00:35:28,780
如果我们说，INT example--如果
我们只是想要一个空白数组int类型，

792
00:35:28,780 --> 00:35:32,270
这将是int例如括号三种。

793
00:35:32,270 --> 00:35:34,670
括号表示的大小。

794
00:35:34,670 --> 00:35:36,720
当你有括号，
它的实际数据

795
00:35:36,720 --> 00:35:39,244
你把它变成这样。

796
00:35:39,244 --> 00:35:40,535
我们可以回滚真快。

797
00:35:40,535 --> 00:35:42,370

798
00:35:42,370 --> 00:35:48,010
>> 所以在这一块，这只是我们
最初的数组，初始化。

799
00:35:48,010 --> 00:35:51,640
在这里，我们是单独
点分配给他们，

800
00:35:51,640 --> 00:35:56,730
所以这代表的索引我们
数组，这就是为什么我们有括号。

801
00:35:56,730 --> 00:36:01,630
但在这里，如果你注意到，我们已经
离开我们没有括号的尺寸，

802
00:36:01,630 --> 00:36:05,969
我们用它进行初始化
实际数据的所有功能于一身的大括号。

803
00:36:05,969 --> 00:36:08,260
学生：那么，我们为什么不有
括号中的这个例子吗？

804
00:36:08,260 --> 00:36:11,030
ALLISON：那么，在哪一部分？

805
00:36:11,030 --> 00:36:14,645
学生：会不会我们
比方说，INT例如支架

806
00:36:14,645 --> 00:36:19,710
等于括号[听不清]
括号内为例子。

807
00:36:19,710 --> 00:36:20,900
>> ALLISON：哦，对不起。

808
00:36:20,900 --> 00:36:21,560
你说得对。

809
00:36:21,560 --> 00:36:22,690
我们确实有支架存在。

810
00:36:22,690 --> 00:36:23,486
对不起你们，是我不好。

811
00:36:23,486 --> 00:36:25,150

812
00:36:25,150 --> 00:36:27,560
是的，你应该有
例如括号后。

813
00:36:27,560 --> 00:36:28,850
你是绝对正确的。

814
00:36:28,850 --> 00:36:29,750
>> 学生：[听不清]没有这样做。

815
00:36:29,750 --> 00:36:31,270
>> 艾里逊：不，你必须有
括号，否则它的

816
00:36:31,270 --> 00:36:32,810
不会声明数组。

817
00:36:32,810 --> 00:36:33,685
学生：[听不清]。

818
00:36:33,685 --> 00:36:34,200
我们对此深感抱歉。

819
00:36:34,200 --> 00:36:36,200
>> ALLISON：对不起，您需要
例如括号后。

820
00:36:36,200 --> 00:36:36,620

821
00:36:36,620 --> 00:36:37,120
错字。

822
00:36:37,120 --> 00:36:40,650

823
00:36:40,650 --> 00:36:43,160
好抓，金星为您服务。

824
00:36:43,160 --> 00:36:47,730
另外，如果你问一个问题，
你们会告诉我你的名字，

825
00:36:47,730 --> 00:36:48,570
我喜欢这一点。

826
00:36:48,570 --> 00:36:50,630
我很想能
知道所有人的名字。

827
00:36:50,630 --> 00:36:53,187
我不会冷
其实给你打电话，我

828
00:36:53,187 --> 00:36:54,520
不只是想知道你的名字。

829
00:36:54,520 --> 00:36:57,530
所以，请居然告诉我你的名字。

830
00:36:57,530 --> 00:36:58,426
>> 利亚利亚。

831
00:36:58,426 --> 00:36:59,340
>> 艾里逊：利亚。

832
00:36:59,340 --> 00:37:03,960
好了，functions--我知道在短暂的
他们的演讲中谈到了这一点。

833
00:37:03,960 --> 00:37:07,590
所以功能是正中下怀
像这样的小一口大小的东西

834
00:37:07,590 --> 00:37:11,525
在这里你传递的投入，一些
神奇的发生了，而你得到的输出。

835
00:37:11,525 --> 00:37:12,680

836
00:37:12,680 --> 00:37:13,180
凉爽。

837
00:37:13,180 --> 00:37:15,013
所以，你实际使用
很多这些了。

838
00:37:15,013 --> 00:37:15,970

839
00:37:15,970 --> 00:37:18,840
获取整型，字符串获取，打印F。

840
00:37:18,840 --> 00:37:21,790
这些是所有功能
在那里你只是给他们打电话，

841
00:37:21,790 --> 00:37:24,370
有很多神奇的事情
在后台正在进行

842
00:37:24,370 --> 00:37:27,390
你不一定看，
你得到了你想要的东西。

843
00:37:27,390 --> 00:37:30,280
或者至少你得到
你希望你想要的。

844
00:37:30,280 --> 00:37:31,920

845
00:37:31,920 --> 00:37:35,620
>> 和基本的功能点，
和CS的主题之一，

846
00:37:35,620 --> 00:37:38,700
就是要打破你的代码
成可管理的片段。

847
00:37:38,700 --> 00:37:41,520
当你开始写
这些很长的程序，

848
00:37:41,520 --> 00:37:44,970
或划痕，当你有
对于游戏这个伟大的思想，

849
00:37:44,970 --> 00:37:48,070
您需要能够打破它
下来一样，OK，我怎么开始？

850
00:37:48,070 --> 00:37:50,470
什么是小件，我需要什么？

851
00:37:50,470 --> 00:37:53,320
哦，我要问的
用户的东西。

852
00:37:53,320 --> 00:37:54,830
现在我需要打印的东西。

853
00:37:54,830 --> 00:37:56,590
哦，我需要计算这个值。

854
00:37:56,590 --> 00:38:00,050
>> 并学习如何分手的
码和大问题，你

855
00:38:00,050 --> 00:38:02,740
有进入这些小块
和创建功能

856
00:38:02,740 --> 00:38:05,330
实际上是一个
CS大基石。

857
00:38:05,330 --> 00:38:06,440

858
00:38:06,440 --> 00:38:11,740
所以，你能想到的只是作为一个功能
就像一个黑盒子，一个神奇的黑盒子，

859
00:38:11,740 --> 00:38:15,030
你把东西放进
你会得到一些输出。

860
00:38:15,030 --> 00:38:16,290

861
00:38:16,290 --> 00:38:19,460
和该程序的其余部分
不需要一定知道

862
00:38:19,460 --> 00:38:21,150
这是怎么回事内的黑盒子。

863
00:38:21,150 --> 00:38:24,190
它所关心的是什么
进去和出来的东西。

864
00:38:24,190 --> 00:38:26,230

865
00:38:26,230 --> 00:38:26,730
凉爽。

866
00:38:26,730 --> 00:38:27,820
>> 那么，为什么功能呢？

867
00:38:27,820 --> 00:38:33,240
Organization--正如我所说，当你
处理非常大的代码库，

868
00:38:33,240 --> 00:38:37,357
你如何组织你的代码会
如果您使用的功能要容易得多。

869
00:38:37,357 --> 00:38:39,190
因为你可以
要一样，确定这一点，

870
00:38:39,190 --> 00:38:41,849
就是这个函数和
这里是另外一个人做。

871
00:38:41,849 --> 00:38:43,890
而且你可以很容易地看到
它们是如何结合在一起的。

872
00:38:43,890 --> 00:38:45,590

873
00:38:45,590 --> 00:38:48,210
因此，将其分成各
这些可管理的子部分。

874
00:38:48,210 --> 00:38:51,860
>> 所以simplification--我敢肯定你们
都看到了这一点，正如我所说，有划痕。

875
00:38:51,860 --> 00:38:53,230

876
00:38:53,230 --> 00:38:56,790
你有这样的宏伟构想，并
你喜欢，怎么做这些工作？

877
00:38:56,790 --> 00:38:59,710
但是，如果你接近它
零零碎碎，你说好不好，

878
00:38:59,710 --> 00:39:03,650
我怎么做一个精灵
漂浮在屏幕上？

879
00:39:03,650 --> 00:39:04,805
这是一个有点容易。

880
00:39:04,805 --> 00:39:06,000

881
00:39:06,000 --> 00:39:09,590
因此，良好的使用功能，使
你的代码更易于阅读。

882
00:39:09,590 --> 00:39:13,800
这使得它更容易调试，为
你进入你以后的习题集，

883
00:39:13,800 --> 00:39:15,900
你要真
希望能够做到的。

884
00:39:15,900 --> 00:39:17,900
而且他们也更容易
设计和实施。

885
00:39:17,900 --> 00:39:21,100
您可以编写了一个小
功能比较快

886
00:39:21,100 --> 00:39:25,260
并确保它的工作原理与尝试
创造这整个漫长的程序

887
00:39:25,260 --> 00:39:28,960
然后种经历和
看看有什么工作，什么不是。

888
00:39:28,960 --> 00:39:30,300
>> 然后可重用性。

889
00:39:30,300 --> 00:39:33,380
所以功能只需要
写一次，

890
00:39:33,380 --> 00:39:35,586
然后，你可以使用它们
多次越好。

891
00:39:35,586 --> 00:39:37,210
所以它的一样，生态友好的感觉。

892
00:39:37,210 --> 00:39:39,660

893
00:39:39,660 --> 00:39:42,070
如果你有喜​​欢的东西
打印f，其中您

894
00:39:42,070 --> 00:39:47,420
只好写出来的那张魔法
背后印F中的任意一个时间

895
00:39:47,420 --> 00:39:51,040
你想打印的东西，你
将是非常厌倦了它

896
00:39:51,040 --> 00:39:51,650
由端。

897
00:39:51,650 --> 00:39:52,660

898
00:39:52,660 --> 00:39:55,292
>> 其中一件事，你会
学会在以后的CS类，

899
00:39:55,292 --> 00:39:57,000
还是其中的佼佼者
咨询件我得到

900
00:39:57,000 --> 00:40:00,870
是，如果你是复制和粘贴
代码，它应该是一个函数。

901
00:40:00,870 --> 00:40:01,880

902
00:40:01,880 --> 00:40:06,007
如果您有相同的
所有的线条贯穿你的代码，

903
00:40:06,007 --> 00:40:08,090
如果你分解出来，
你的代码可能会

904
00:40:08,090 --> 00:40:11,860
是一样，5倍短
并且更加容易阅读。

905
00:40:11,860 --> 00:40:15,230
而不是试图解决
所有这些不同地方的东西

906
00:40:15,230 --> 00:40:18,021
可能会出问题，你有一个函数
您得到解决。

907
00:40:18,021 --> 00:40:19,230

908
00:40:19,230 --> 00:40:21,890
我保证，很多这种
似乎是一种抽象的现在，

909
00:40:21,890 --> 00:40:24,620
但是当你进入后
后来习题集，

910
00:40:24,620 --> 00:40:28,950
它会让很多更有意义
而真正被赶回家。

911
00:40:28,950 --> 00:40:31,775
有没有问题
有关功能如何呢？

912
00:40:31,775 --> 00:40:32,650
为什么我们要使用它们？

913
00:40:32,650 --> 00:40:34,775
我知道我们还没有得到
进入细节问题呢。

914
00:40:34,775 --> 00:40:40,610
所以定义就像function--
数组，我们需要of--这某种

915
00:40:40,610 --> 00:40:41,860
仅仅是个通用输出。

916
00:40:41,860 --> 00:40:45,110
因此，这是一个函数，它是
只是要立方体一些输入。

917
00:40:45,110 --> 00:40:50,120
而接下来的页面上，实际上，我们有
所有这些真棒这里的小东西。

918
00:40:50,120 --> 00:40:52,420
因此，每个人都可以读
即，出于好奇？

919
00:40:52,420 --> 00:40:55,050
我知道紫色和黑色
可能会有点辛苦。

920
00:40:55,050 --> 00:41:00,730
>> 但大的事情知道 - 所以第一
1这里是我们的返回类型。

921
00:41:00,730 --> 00:41:05,270
因此，这是讲的输出
这个功能的时候，在这种情况下，

922
00:41:05,270 --> 00:41:08,990
我们把一些数字，就是我们
得到的是立方数。

923
00:41:08,990 --> 00:41:11,090
所以，它应该是在这种情况下，一个int。

924
00:41:11,090 --> 00:41:14,055
也许这将是一张双人床或
别的以后，但在这种情况下，

925
00:41:14,055 --> 00:41:14,555
这是一个int。

926
00:41:14,555 --> 00:41:15,620

927
00:41:15,620 --> 00:41:19,440
>> 用C，你总是需要一个返回类型。

928
00:41:19,440 --> 00:41:20,267
这将是一个int。

929
00:41:20,267 --> 00:41:20,975
这将是一个浮动。

930
00:41:20,975 --> 00:41:22,180
这将是一个双。

931
00:41:22,180 --> 00:41:25,370
但你必须指定哪些
这个函数会返回。

932
00:41:25,370 --> 00:41:26,480

933
00:41:26,480 --> 00:41:29,170
否则会骂
你，它不会编译。

934
00:41:29,170 --> 00:41:30,462
你会难过，我会很伤心的。

935
00:41:30,462 --> 00:41:31,420
它只是不好。

936
00:41:31,420 --> 00:41:31,940
行。

937
00:41:31,940 --> 00:41:34,290
>> 然后，我们有我们的函数名。

938
00:41:34,290 --> 00:41:38,440
正如你可以在这里看到，用c
有这非常符合范式。

939
00:41:38,440 --> 00:41:42,630
什么是你喜欢的类型，叫什么名字，
然后在年底一些其他的东西。

940
00:41:42,630 --> 00:41:45,550
因此，我们有我们的返回类型，
我们的函数名，然后

941
00:41:45,550 --> 00:41:49,320
我们有我们的头与
我们的参数列表。

942
00:41:49,320 --> 00:41:52,080
>> 因此，参数列表，什么是
此功能会采取？

943
00:41:52,080 --> 00:41:56,360
参数列表是一个简单的
代名词，什么是我们的投入？

944
00:41:56,360 --> 00:42:00,230
并以同样的方式，我们
必须确定我们的函数

945
00:42:00,230 --> 00:42:03,210
并给它一回
类型，我们每一个输入

946
00:42:03,210 --> 00:42:05,350
需要有与它相关联的类型。

947
00:42:05,350 --> 00:42:08,850
因此，我们知道我们的功能
其实可以一起工作。

948
00:42:08,850 --> 00:42:11,290
>> 所以在这种情况下，我们有一些整数的输入。

949
00:42:11,290 --> 00:42:14,660
如此反复，这将是该型
和你要调用它。

950
00:42:14,660 --> 00:42:16,500

951
00:42:16,500 --> 00:42:19,040
然后，当你看到
在这里，我们有我们的身体。

952
00:42:19,040 --> 00:42:23,600
因此，我们有一些INT输出，即
只是我们投入时间本身

953
00:42:23,600 --> 00:42:25,810
时间本身，它只是立方体它。

954
00:42:25,810 --> 00:42:27,610
然后我们返回输出。

955
00:42:27,610 --> 00:42:32,140
>> 所以，当你看到这里，我们有一个
诠释时代一个int次一个int，

956
00:42:32,140 --> 00:42:35,420
所以它返回一个int，这
已申报存在。

957
00:42:35,420 --> 00:42:38,240
所以，一切都凝聚力。

958
00:42:38,240 --> 00:42:39,210
一切的快乐。

959
00:42:39,210 --> 00:42:40,250
你的函数将运行。

960
00:42:40,250 --> 00:42:41,192

961
00:42:41,192 --> 00:42:42,650
而这仅仅是普通的事情。

962
00:42:42,650 --> 00:42:46,750
所以，总有返回类型，
的名字，你的参数列表。

963
00:42:46,750 --> 00:42:48,830
在每一件事情你
参数列表，或输入，

964
00:42:48,830 --> 00:42:51,410
需要有与它相关联的类型。

965
00:42:51,410 --> 00:42:54,210
然后你有你的
机身这里什么

966
00:42:54,210 --> 00:42:55,590
你想与你的输入。

967
00:42:55,590 --> 00:42:57,390

968
00:42:57,390 --> 00:43:00,410
>> 然后显然你
想回到什么。

969
00:43:00,410 --> 00:43:02,630
有时候功能将只返回。

970
00:43:02,630 --> 00:43:06,090
它们实际上并不返回
东西供你使用。

971
00:43:06,090 --> 00:43:08,660
但你必须以某种方式返回。

972
00:43:08,660 --> 00:43:12,900
当你正在做
自己的函数，

973
00:43:12,900 --> 00:43:15,430
我们可以进入一个更深一点。

974
00:43:15,430 --> 00:43:18,880
就个人而言，如果你愿意，也有很多
不同的东西，你可以在那里做。

975
00:43:18,880 --> 00:43:21,350

976
00:43:21,350 --> 00:43:22,140
大家好？

977
00:43:22,140 --> 00:43:25,900
什么这个列表，你要我上
走了过来，说你不明白？

978
00:43:25,900 --> 00:43:27,204

979
00:43:27,204 --> 00:43:28,120
每个人都很好吗？

980
00:43:28,120 --> 00:43:29,071

981
00:43:29,071 --> 00:43:29,570
凉爽。

982
00:43:29,570 --> 00:43:31,350

983
00:43:31,350 --> 00:43:32,120
真棒。

984
00:43:32,120 --> 00:43:34,700
>> 好了，我们正在把
现在这一切都在一起。

985
00:43:34,700 --> 00:43:35,720

986
00:43:35,720 --> 00:43:41,201
因此，我们有一些整型立方体输入，因此
这是这里一个完整的程序。

987
00:43:41,201 --> 00:43:42,950
到现在为止，我已经
种了给你

988
00:43:42,950 --> 00:43:45,699
球员片段，可能
在程序中去。

989
00:43:45,699 --> 00:43:47,240
我们刚刚一直在寻找的功能。

990
00:43:47,240 --> 00:43:48,448
但这里有一个完整的计划。

991
00:43:48,448 --> 00:43:49,400

992
00:43:49,400 --> 00:43:53,690
所以，你们有多少人还记得
从演讲词的原型？

993
00:43:53,690 --> 00:43:54,750

994
00:43:54,750 --> 00:43:55,300
凉爽。

995
00:43:55,300 --> 00:43:55,890
我们已经得到了一个。

996
00:43:55,890 --> 00:43:57,160

997
00:43:57,160 --> 00:43:58,110
你叫什么名字？

998
00:43:58,110 --> 00:43:58,850
>> 斯蒂芬：斯蒂芬。

999
00:43:58,850 --> 00:43:59,475
>> 艾里逊：斯蒂芬？

1000
00:43:59,475 --> 00:44:01,030
OK，真棒。

1001
00:44:01,030 --> 00:44:03,310
所以，你还记得什么是原型？

1002
00:44:03,310 --> 00:44:04,651

1003
00:44:04,651 --> 00:44:10,230
>> 学生：你说[听不清]
在你真正对付它。

1004
00:44:10,230 --> 00:44:11,700
>> 艾里逊：你还记得，为什么？

1005
00:44:11,700 --> 00:44:13,158
>> 学生：没有。

1006
00:44:13,158 --> 00:44:14,620
>> 艾里逊：OK。

1007
00:44:14,620 --> 00:44:16,090
金名将。

1008
00:44:16,090 --> 00:44:19,470
所以，是的，一个原型，我们有
事先，因为否则

1009
00:44:19,470 --> 00:44:21,260
我们的编译器是要骂我们。

1010
00:44:21,260 --> 00:44:24,294
它会说，OK，
这是什么魔方功能？

1011
00:44:24,294 --> 00:44:26,460
就像，你从字面上有
告诉我没有谈到这个。

1012
00:44:26,460 --> 00:44:28,110
这就像当你
走进教室，

1013
00:44:28,110 --> 00:44:29,320
有人的样子，
今天有一个小测验。

1014
00:44:29,320 --> 00:44:31,380
和你一样，你
从来没有告诉过我这件事。

1015
00:44:31,380 --> 00:44:32,930
我不开心与我们联系。

1016
00:44:32,930 --> 00:44:34,300

1017
00:44:34,300 --> 00:44:37,020
原型基本上像
您的大纲说，看。

1018
00:44:37,020 --> 00:44:37,900
当心。

1019
00:44:37,900 --> 00:44:39,570
还有的将是在这一天进行测验。

1020
00:44:39,570 --> 00:44:41,420
不要惊慌，当你得到它。

1021
00:44:41,420 --> 00:44:42,690
你会好起来的。

1022
00:44:42,690 --> 00:44:48,170
>> 因此，所有的原型确实是告诉
主，我要使用此功能。

1023
00:44:48,170 --> 00:44:51,010
我发誓我以后定义它。

1024
00:44:51,010 --> 00:44:52,260
不要吓坏了我。

1025
00:44:52,260 --> 00:44:54,750
只是编译和做什么，我告诉你。

1026
00:44:54,750 --> 00:44:58,880
因此，我们有原型存在
只是为了让我们的编译器高兴。

1027
00:44:58,880 --> 00:45:04,360
它基本上是一个承诺
你定义了这个功能以后

1028
00:45:04,360 --> 00:45:07,960
那你是不是刚刚打电话
这种随意的事情，它

1029
00:45:07,960 --> 00:45:10,070
不知道你在做什么
将要干什么。

1030
00:45:10,070 --> 00:45:11,910
>> 所以在这种情况下，我们有主这里。

1031
00:45:11,910 --> 00:45:14,660
我们初始化一些整数x。

1032
00:45:14,660 --> 00:45:15,620
这是两人。

1033
00:45:15,620 --> 00:45:17,510
我们要打印出x的值。

1034
00:45:17,510 --> 00:45:18,800
我们将立方体X。

1035
00:45:18,800 --> 00:45:21,520
正如你看到的，我们有我们的
函数声明

1036
00:45:21,520 --> 00:45:23,770
到这里，我们
谈到以前。

1037
00:45:23,770 --> 00:45:28,260
这将立方体x，然后，如果我们
请记住，立方体函数实际上

1038
00:45:28,260 --> 00:45:31,340
返回一个整数
我们，它存储

1039
00:45:31,340 --> 00:45:35,860
在X再一次让我们可以打印
出8，或者现在​​立方体X。

1040
00:45:35,860 --> 00:45:37,170

1041
00:45:37,170 --> 00:45:38,920
这是否有意义大家？

1042
00:45:38,920 --> 00:45:40,360
我们是好？

1043
00:45:40,360 --> 00:45:41,160
行。

1044
00:45:41,160 --> 00:45:41,660
真棒。

1045
00:45:41,660 --> 00:45:45,540

1046
00:45:45,540 --> 00:45:46,840
>> 行。

1047
00:45:46,840 --> 00:45:50,879
有多少你们的
记住这所以这

1048
00:45:50,879 --> 00:45:52,670
基本上是你
栈和堆的，

1049
00:45:52,670 --> 00:45:56,510
只是一个可视化
记忆是如何存储在这里。

1050
00:45:56,510 --> 00:45:58,200

1051
00:45:58,200 --> 00:46:01,400
所以，我们只是想使
确保您了解

1052
00:46:01,400 --> 00:46:03,680
如何将这些表示在内存中。

1053
00:46:03,680 --> 00:46:07,670
如果你喜欢的类
CS61之类的东西后，

1054
00:46:07,670 --> 00:46:10,570
你了解这更
在深度，它真的很酷。

1055
00:46:10,570 --> 00:46:11,730
我强烈推荐它。

1056
00:46:11,730 --> 00:46:12,740

1057
00:46:12,740 --> 00:46:14,720
但现在，我给
你的全面概述

1058
00:46:14,720 --> 00:46:16,950
所以你不必
知道的细节问题。

1059
00:46:16,950 --> 00:46:20,820
>> 所以顶端只是一个文本段哪
包含了实际的零和一，

1060
00:46:20,820 --> 00:46:23,740
二进制为。

1061
00:46:23,740 --> 00:46:27,510
这被用于存储
全局变量，如果您有任何。

1062
00:46:27,510 --> 00:46:28,870

1063
00:46:28,870 --> 00:46:32,240
当你向下移动，我们
有，因为你在这里看到，

1064
00:46:32,240 --> 00:46:34,670
初始化数据，未初始化
数据，然后堆。

1065
00:46:34,670 --> 00:46:35,800

1066
00:46:35,800 --> 00:46:38,584
>> 所以，我们真的不说话
关于堆现在。

1067
00:46:38,584 --> 00:46:39,500
我们会得到它以后。

1068
00:46:39,500 --> 00:46:40,762

1069
00:46:40,762 --> 00:46:42,970
现在，我只是要
波我的手，像，

1070
00:46:42,970 --> 00:46:44,553
你不需要知道这个了。

1071
00:46:44,553 --> 00:46:46,100

1072
00:46:46,100 --> 00:46:49,060
但是，我们会聊一点
关于堆栈位。

1073
00:46:49,060 --> 00:46:53,050
所以堆栈where--我们有放大研究。

1074
00:46:53,050 --> 00:46:58,590
这实际上是如何计划
我们只是看着发生在内存中。

1075
00:46:58,590 --> 00:47:01,630
>> 那么，什么情况是，每
一次，我们调用一个函数，

1076
00:47:01,630 --> 00:47:04,180
我们得到了什么叫做栈
帧，这是其中之一。

1077
00:47:04,180 --> 00:47:05,870
因此，主要的参数。

1078
00:47:05,870 --> 00:47:07,944
因此，这些都是事
我们通过进入主。

1079
00:47:07,944 --> 00:47:11,110
于是，他们就在这里的底部，
因为这是我们所说的第一句话。

1080
00:47:11,110 --> 00:47:13,401
然后，我们去主要的
当地人说，当我们说，

1081
00:47:13,401 --> 00:47:15,970
我们指的是局部变量
存储在主。

1082
00:47:15,970 --> 00:47:19,950

1083
00:47:19,950 --> 00:47:23,620
因此，当地人在这里会一样，
x是在这种情况下等于2。

1084
00:47:23,620 --> 00:47:26,350
因为这是定位于主力。

1085
00:47:26,350 --> 00:47:29,745
大家是否还记得范围，
去了，在演讲？

1086
00:47:29,745 --> 00:47:31,517

1087
00:47:31,517 --> 00:47:32,017
行。

1088
00:47:32,017 --> 00:47:36,110
所以，仅仅是变量
在主要的初始化。

1089
00:47:36,110 --> 00:47:38,550
所以这就是为什么我们有主要的[？主唱。 ？]

1090
00:47:38,550 --> 00:47:40,390
>> 然后在主，我们称之为立方体。

1091
00:47:40,390 --> 00:47:41,000
对不对？

1092
00:47:41,000 --> 00:47:44,510
因此，我们得到另一个框架
与多维数据集的参数。

1093
00:47:44,510 --> 00:47:47,050
所以在这种情况下，立方体的
参数是现在

1094
00:47:47,050 --> 00:47:50,800
我们通过在x，
我们通过两个。

1095
00:47:50,800 --> 00:47:55,320
然后立方体的当地人，这是
在实际体积测量发生。

1096
00:47:55,320 --> 00:47:56,450
然后返回。

1097
00:47:56,450 --> 00:48:02,120
>> 那么，什么情况是如立方体实际上做
什么是应该做的，它返回。

1098
00:48:02,120 --> 00:48:07,020
当它返回时，这架离开，
其倒回主。

1099
00:48:07,020 --> 00:48:09,160
然后在主，我们
实际上可以打印出来。

1100
00:48:09,160 --> 00:48:10,840

1101
00:48:10,840 --> 00:48:14,500
因此，当你回来的东西，
当你的函数返回，

1102
00:48:14,500 --> 00:48:19,900
它就像传递这些值
它下面的框，然后离开。

1103
00:48:19,900 --> 00:48:22,200
和事物有才能执行。

1104
00:48:22,200 --> 00:48:25,550
>> 而当你得到更大的计划，
我们可以做出更酷，更复杂

1105
00:48:25,550 --> 00:48:26,470
图。

1106
00:48:26,470 --> 00:48:29,070
但现在，这是
只是一般概述

1107
00:48:29,070 --> 00:48:31,110
所以你有怎样的
了解什么

1108
00:48:31,110 --> 00:48:35,160
当你调用一个函数发生
以及如何实际看起来在内存中。

1109
00:48:35,160 --> 00:48:37,230

1110
00:48:37,230 --> 00:48:37,770
酷？

1111
00:48:37,770 --> 00:48:38,353
大家好？

1112
00:48:38,353 --> 00:48:39,920

1113
00:48:39,920 --> 00:48:40,420
真棒。

1114
00:48:40,420 --> 00:48:42,070

1115
00:48:42,070 --> 00:48:50,575
>> 所以这是一个是
只是想交换的东西。

1116
00:48:50,575 --> 00:48:52,260

1117
00:48:52,260 --> 00:48:54,930
我们在这里看到，我们有
我们的函数原型

1118
00:48:54,930 --> 00:48:56,900
让我们的编译器不骂我们。

1119
00:48:56,900 --> 00:48:59,220
我们有一些主要的，而我们
要切换的x和y。

1120
00:48:59,220 --> 00:49:00,320

1121
00:49:00,320 --> 00:49:04,129
他们没有这样做演示
在演讲的是，有吗？

1122
00:49:04,129 --> 00:49:04,670
他们有没有关系？

1123
00:49:04,670 --> 00:49:05,900
行。

1124
00:49:05,900 --> 00:49:08,450
因此，我们打算去
在这个很简单。

1125
00:49:08,450 --> 00:49:12,210
你会惹上这个例子更多
深入，我认为，这个星期。

1126
00:49:12,210 --> 00:49:15,680
再接下来的一周，我们才能真正
潜入为什么这是行不通的。

1127
00:49:15,680 --> 00:49:18,810
>> 因此，我们有这个空间
功能这里 - 调剂。

1128
00:49:18,810 --> 00:49:20,720
所以虚空只是意味着
不返回任何值。

1129
00:49:20,720 --> 00:49:22,000

1130
00:49:22,000 --> 00:49:24,110
我们有交换INT A和INT B。

1131
00:49:24,110 --> 00:49:27,046
我们有一些暂时的
可变的，这是一个。

1132
00:49:27,046 --> 00:49:30,050
一个被分配给B，然后
B被分配到temp

1133
00:49:30,050 --> 00:49:32,235
使a和b的
现在值被切换。

1134
00:49:32,235 --> 00:49:33,510

1135
00:49:33,510 --> 00:49:36,030
>> 但是，剧情转折，这是行不通的。

1136
00:49:36,030 --> 00:49:37,390

1137
00:49:37,390 --> 00:49:42,380
而它的一部分实际上有
做的一个事实，即

1138
00:49:42,380 --> 00:49:48,800
而B在这里，那获得通过的那些
这里，实际上是x和y的副本。

1139
00:49:48,800 --> 00:49:53,220
因此，当该函数实际上返回，
它切换的副本，但不

1140
00:49:53,220 --> 00:49:55,960
实际的x和y的。

1141
00:49:55,960 --> 00:50:02,370
因此从另一个角度去想它是
that--假装这些都是掉。

1142
00:50:02,370 --> 00:50:03,130
行？

1143
00:50:03,130 --> 00:50:05,390
所以在主，我们有x和y初始化。

1144
00:50:05,390 --> 00:50:06,530

1145
00:50:06,530 --> 00:50:10,760
但是，当我们真正去了
与交换这些帧

1146
00:50:10,760 --> 00:50:15,740
我们在传递的值
它，他们正在初始化。

1147
00:50:15,740 --> 00:50:18,570
>> 他们永远只能住在这里。

1148
00:50:18,570 --> 00:50:19,796
因此，A和B住在这里。

1149
00:50:19,796 --> 00:50:20,670
他们被换。

1150
00:50:20,670 --> 00:50:21,870

1151
00:50:21,870 --> 00:50:26,190
但是，当我们返回时，我们不
做与a和b什​​么。一

1152
00:50:26,190 --> 00:50:28,980
和b离开我们的功能。

1153
00:50:28,980 --> 00:50:30,850
所以x和y保持不变。

1154
00:50:30,850 --> 00:50:31,960

1155
00:50:31,960 --> 00:50:39,665
你会得到更多的进入如何解决和
我们如何真正与处理后。

1156
00:50:39,665 --> 00:50:40,750

1157
00:50:40,750 --> 00:50:43,740
>> 但它只是一件事
以种牢记。

1158
00:50:43,740 --> 00:50:45,270
使用它的未来。

1159
00:50:45,270 --> 00:50:48,050
如果没有做别担心
所有的意义世界。

1160
00:50:48,050 --> 00:50:49,510

1161
00:50:49,510 --> 00:50:51,440
他们是拷贝是最重要的事情。

1162
00:50:51,440 --> 00:50:54,580
如果你要带什么
离，你传入副本。

1163
00:50:54,580 --> 00:50:56,410
所以原稿保持不变。

1164
00:50:56,410 --> 00:50:58,170

1165
00:50:58,170 --> 00:50:58,770
大家好？

1166
00:50:58,770 --> 00:51:00,280

1167
00:51:00,280 --> 00:51:00,930
凉爽。

1168
00:51:00,930 --> 00:51:02,295
>> 因此，命令行参数。

1169
00:51:02,295 --> 00:51:03,520

1170
00:51:03,520 --> 00:51:07,630
我敢肯定，在开始的时候你们都
有那些伟大一样，INT主要空隙。

1171
00:51:07,630 --> 00:51:09,517
和你一样，好凉爽。

1172
00:51:09,517 --> 00:51:10,350
我真的不关心。

1173
00:51:10,350 --> 00:51:12,360
这正是我写的。

1174
00:51:12,360 --> 00:51:16,349
但是，在你的新计划，
特别是在这个pset中，

1175
00:51:16,349 --> 00:51:17,890
为什么有粉笔在地上？

1176
00:51:17,890 --> 00:51:19,640

1177
00:51:19,640 --> 00:51:22,680
>> 随着你的下一个PSET，你
将要看到这一点。

1178
00:51:22,680 --> 00:51:26,130
INT为主，诠释ARG C，
弦弧V，支架。

1179
00:51:26,130 --> 00:51:28,770
所以，从我们刚才
今天学什么

1180
00:51:28,770 --> 00:51:32,190
我们认为，第二个参数
或者说第二个元素是在这里？

1181
00:51:32,190 --> 00:51:34,830

1182
00:51:34,830 --> 00:51:35,824
这是一个数组。

1183
00:51:35,824 --> 00:51:36,615
什么类型的数组？

1184
00:51:36,615 --> 00:51:38,430

1185
00:51:38,430 --> 00:51:40,690
String数组，是的。

1186
00:51:40,690 --> 00:51:41,980
凉爽。

1187
00:51:41,980 --> 00:51:45,320
这就是你如何去
现在要宣布这些。

1188
00:51:45,320 --> 00:51:48,570
>> 有谁还记得
这些东西代表什么？

1189
00:51:48,570 --> 00:51:52,551

1190
00:51:52,551 --> 00:51:53,050
不是吗？

1191
00:51:53,050 --> 00:51:54,020

1192
00:51:54,020 --> 00:51:54,520
嗯？

1193
00:51:54,520 --> 00:51:55,640
>> 学生：ARG温度。

1194
00:51:55,640 --> 00:51:56,961

1195
00:51:56,961 --> 00:51:58,950
>> 艾里逊：那么ARGç保持一个计数器。

1196
00:51:58,950 --> 00:51:59,450
这是一个int。

1197
00:51:59,450 --> 00:52:00,615
这是一个数字，对不对？

1198
00:52:00,615 --> 00:52:02,240
那么，你认为这个数字呢？

1199
00:52:02,240 --> 00:52:08,260

1200
00:52:08,260 --> 00:52:08,760
是啊。

1201
00:52:08,760 --> 00:52:11,450
所以，ARG c是弦数
构成该命令行。

1202
00:52:11,450 --> 00:52:12,560

1203
00:52:12,560 --> 00:52:18,499
所以，如果我们要真正do--，
有例子在此之后，

1204
00:52:18,499 --> 00:52:19,790
所以我不会提前拿到自己。

1205
00:52:19,790 --> 00:52:21,299

1206
00:52:21,299 --> 00:52:23,840
这是一个数字的字符串是
只是让你的命令行。

1207
00:52:23,840 --> 00:52:35,080
>> 所以，当你做一样，点斜线马里奥，
这是一根弦，使得它了。

1208
00:52:35,080 --> 00:52:38,520
在这一块，你实际上是
喂东西进入命令行，

1209
00:52:38,520 --> 00:52:41,750
我敢肯定，你们谁
看过规格锯。

1210
00:52:41,750 --> 00:52:44,470
因此，在这种情况下，也许你会
有两个或三个参数。

1211
00:52:44,470 --> 00:52:45,652

1212
00:52:45,652 --> 00:52:48,360
这将是一个有用的东西来使用。

1213
00:52:48,360 --> 00:52:51,500
>> 然后ARG V，正如我们所说，
只是一个字符串数组。

1214
00:52:51,500 --> 00:52:57,000
使实际存储是什么
您输入到命令行。

1215
00:52:57,000 --> 00:52:59,960
因此，我们有这些。

1216
00:52:59,960 --> 00:53:02,850
你有一些点斜杠
复制INFILE OUTFILE。

1217
00:53:02,850 --> 00:53:06,670
所以，如果精氨酸c是字符串数
我们正在传递到命令

1218
00:53:06,670 --> 00:53:09,080
行，有什么是我们ARG c。在这种情况下？

1219
00:53:09,080 --> 00:53:14,520

1220
00:53:14,520 --> 00:53:15,850
三。

1221
00:53:15,850 --> 00:53:16,690
没错。

1222
00:53:16,690 --> 00:53:20,086
>> 那么什么是零ARG V？

1223
00:53:20,086 --> 00:53:21,710
那么，什么是我们所存储的第一件事？

1224
00:53:21,710 --> 00:53:24,640

1225
00:53:24,640 --> 00:53:26,290
点斜线副本，没错。

1226
00:53:26,290 --> 00:53:28,065
然后第二个是INFILE。

1227
00:53:28,065 --> 00:53:29,290

1228
00:53:29,290 --> 00:53:30,930
第三个是OUTFILE。

1229
00:53:30,930 --> 00:53:32,390
那么，关于精氨酸V 3？

1230
00:53:32,390 --> 00:53:35,810

1231
00:53:35,810 --> 00:53:39,370
这将是空的，因为这是
我们的数组的结尾，对不对？

1232
00:53:39,370 --> 00:53:40,600

1233
00:53:40,600 --> 00:53:41,460
凉爽。

1234
00:53:41,460 --> 00:53:44,500
>> 然后怎么样第六个？

1235
00:53:44,500 --> 00:53:45,900
这是种一个有趣的问题。

1236
00:53:45,900 --> 00:53:46,400
伊什。

1237
00:53:46,400 --> 00:53:49,027

1238
00:53:49,027 --> 00:53:49,943
我们知道它是什么？

1239
00:53:49,943 --> 00:53:50,960

1240
00:53:50,960 --> 00:53:51,690
这是不确定的。

1241
00:53:51,690 --> 00:53:53,170
我们不知道，可能是。

1242
00:53:53,170 --> 00:53:57,000
这是什么是正确的
在存储器阵列后，

1243
00:53:57,000 --> 00:54:00,220
我们不知道那是什么。

1244
00:54:00,220 --> 00:54:03,500
和它的危险去触摸那些
的事情，因为你知道，

1245
00:54:03,500 --> 00:54:07,080
它是内存的一部分，你
不应该访问或空。

1246
00:54:07,080 --> 00:54:09,000
它可以做疯狂的事情。

1247
00:54:09,000 --> 00:54:11,690
这就是所谓的过度索引
您绑定到您的阵列。

1248
00:54:11,690 --> 00:54:14,785
不要去的边界之外的
数组，或者坏的事情都可能发生。

1249
00:54:14,785 --> 00:54:16,274

1250
00:54:16,274 --> 00:54:18,940
你回来一样，法律
物理学已被销毁

1251
00:54:18,940 --> 00:54:19,481
什么的。

1252
00:54:19,481 --> 00:54:21,021

1253
00:54:21,021 --> 00:54:21,520
凉爽。

1254
00:54:21,520 --> 00:54:22,895
这是否有意义大家？

1255
00:54:22,895 --> 00:54:23,810

1256
00:54:23,810 --> 00:54:25,025
差不太多。

1257
00:54:25,025 --> 00:54:28,926
>> 所以，现在，大家的
最喜欢的部分，PSET审查。

1258
00:54:28,926 --> 00:54:29,426
耶！

1259
00:54:29,426 --> 00:54:30,530

1260
00:54:30,530 --> 00:54:31,030
行。

1261
00:54:31,030 --> 00:54:33,830
因此，对于那些你们谁
没有看过的pset规范，

1262
00:54:33,830 --> 00:54:36,790
你正在做一些真正
凉的东西与密码。

1263
00:54:36,790 --> 00:54:39,360
你要创建一个凯撒
密码和V @ genere加密。

1264
00:54:39,360 --> 00:54:42,000

1265
00:54:42,000 --> 00:54:45,480
你一定要读
SPEC怎么看这些作品。

1266
00:54:45,480 --> 00:54:49,650
如果你有任何麻烦
它实际上应该做的，

1267
00:54:49,650 --> 00:54:52,920
请你跟我说话，
给我发电子邮件或短信我。

1268
00:54:52,920 --> 00:54:53,420
我在周围。

1269
00:54:53,420 --> 00:54:54,780

1270
00:54:54,780 --> 00:54:57,070
>> 因此，主要有三个
这里的东西，我们

1271
00:54:57,070 --> 00:55:00,440
要谈about--正中下怀
的演讲的延伸。

1272
00:55:00,440 --> 00:55:03,645
东西，你可能不知道
约，有用的提示和工具。

1273
00:55:03,645 --> 00:55:05,520
所以，我们要做一个
快速审查ASCII的，

1274
00:55:05,520 --> 00:55:10,420
因为这将是超
重要的V @ genere的密码。

1275
00:55:10,420 --> 00:55:11,809

1276
00:55:11,809 --> 00:55:14,100
我们要转换
命令行输入，

1277
00:55:14,100 --> 00:55:17,160
将是恺撒密码非常有帮助。

1278
00:55:17,160 --> 00:55:18,133
然后取模。

1279
00:55:18,133 --> 00:55:20,220

1280
00:55:20,220 --> 00:55:21,210
凉爽。

1281
00:55:21,210 --> 00:55:24,005
>> 因此，ASCII字符映射到数字。

1282
00:55:24,005 --> 00:55:25,270

1283
00:55:25,270 --> 00:55:26,365
这是一个伟大的图表。

1284
00:55:26,365 --> 00:55:28,115
你应该有这
地方添加书签。

1285
00:55:28,115 --> 00:55:29,310

1286
00:55:29,310 --> 00:55:33,250
你会想它
你的第一个中期。

1287
00:55:33,250 --> 00:55:36,320
我敢肯定每个人都有这种
图表上的中期板。

1288
00:55:36,320 --> 00:55:37,810
所以，学习它。

1289
00:55:37,810 --> 00:55:38,410
爱它。

1290
00:55:38,410 --> 00:55:39,740
备在手边。

1291
00:55:39,740 --> 00:55:41,210
这将是有益的。

1292
00:55:41,210 --> 00:55:45,630
>> 和所有它是是一种编码
映射字母，数字，

1293
00:55:45,630 --> 00:55:47,740
和其他字符
数字对我们的电脑。

1294
00:55:47,740 --> 00:55:49,947
因为，当然，在
最后，我们的一切存储

1295
00:55:49,947 --> 00:55:52,030
是会得到转换
下降到零和一，

1296
00:55:52,030 --> 00:55:55,200
所以我们需要一些方法来表示
文本和字符，我们都是

1297
00:55:55,200 --> 00:55:59,105
看惯了的某种数量。

1298
00:55:59,105 --> 00:56:00,370

1299
00:56:00,370 --> 00:56:05,880
>> 所以，我们在这里看到，我们有
大写字母A，这是在那里。

1300
00:56:05,880 --> 00:56:06,555
这是65岁。

1301
00:56:06,555 --> 00:56:07,570

1302
00:56:07,570 --> 00:56:09,660
和小写字母A是97。

1303
00:56:09,660 --> 00:56:13,170
所以，你自己看着办out--
正如我刚才所说，

1304
00:56:13,170 --> 00:56:16,532
如果你有多个阵列
字符串，他们每个人

1305
00:56:16,532 --> 00:56:17,490
有一个空终止。

1306
00:56:17,490 --> 00:56:18,480
这将是一个空间。

1307
00:56:18,480 --> 00:56:22,581
空间有自己special--
我忘记了它是在这里。

1308
00:56:22,581 --> 00:56:23,080
啊。

1309
00:56:23,080 --> 00:56:24,700
图32是空间。

1310
00:56:24,700 --> 00:56:27,090
所以一切都映射到它。

1311
00:56:27,090 --> 00:56:28,680

1312
00:56:28,680 --> 00:56:29,740
>> 因此，我们有ASCII数学。

1313
00:56:29,740 --> 00:56:31,080

1314
00:56:31,080 --> 00:56:34,290
临tip--中的V @ genere的，
你可能受到诱惑

1315
00:56:34,290 --> 00:56:39,480
您的数字转换成整数，
但它实际上是更好的做法

1316
00:56:39,480 --> 00:56:43,860
能够使用
这样的人物

1317
00:56:43,860 --> 00:56:45,820
当你真正操纵他们。

1318
00:56:45,820 --> 00:56:48,950
所以，如果你想使用的数字，就可以了。

1319
00:56:48,950 --> 00:56:55,260
但更好的方法，或者一种方式，
我们往往喜欢你们这样做，

1320
00:56:55,260 --> 00:56:57,830
就是这样，你是
实际上减去字符。

1321
00:56:57,830 --> 00:56:58,840

1322
00:56:58,840 --> 00:57:02,830
>> 所以我想，你们来
种计算这些的。

1323
00:57:02,830 --> 00:57:05,070
你为什么不尝试每隔一个？

1324
00:57:05,070 --> 00:57:07,580

1325
00:57:07,580 --> 00:57:09,830
所以做第一个，
第三个和第五个1。

1326
00:57:09,830 --> 00:57:11,160

1327
00:57:11,160 --> 00:57:15,000
因为我想确保我们讨论
一切，我们需要谈谈。

1328
00:57:15,000 --> 00:57:17,410

1329
00:57:17,410 --> 00:57:20,259
我只是想说，之一
重要的事情to--哦，等等，

1330
00:57:20,259 --> 00:57:21,550
你们还没有看到这一点。

1331
00:57:21,550 --> 00:57:23,710
确定这样做前三。

1332
00:57:23,710 --> 00:57:24,430
让我们做到这一点。

1333
00:57:24,430 --> 00:57:25,971
因为我们要谈的模。

1334
00:57:25,971 --> 00:57:27,810

1335
00:57:27,810 --> 00:57:28,310
我知道。

1336
00:57:28,310 --> 00:57:28,851
数学是很难的。

1337
00:57:28,851 --> 00:57:29,870

1338
00:57:29,870 --> 00:57:30,980
您可以使用计算器。

1339
00:57:30,980 --> 00:57:31,580
没关系。

1340
00:57:31,580 --> 00:57:37,464

1341
00:57:37,464 --> 00:57:40,380
或拉了一个ASCII表，因为
你可能会想的。

1342
00:57:40,380 --> 00:58:03,660

1343
00:58:03,660 --> 00:58:04,820
>> 凉爽。

1344
00:58:04,820 --> 00:58:07,960
所以，我会很快走
您完成这些家伙。

1345
00:58:07,960 --> 00:58:11,120
因此，人们ASCII表拉升？

1346
00:58:11,120 --> 00:58:15,645
什么是我们的数字
数小写​​？

1347
00:58:15,645 --> 00:58:16,270
学生：七。

1348
00:58:16,270 --> 00:58:19,420

1349
00:58:19,420 --> 00:58:24,550
>> 艾里逊：那么小写字母A是
97和大写字母A是65。

1350
00:58:24,550 --> 00:58:26,390
所以97减65？

1351
00:58:26,390 --> 00:58:27,782

1352
00:58:27,782 --> 00:58:28,570
>> 听众：32？

1353
00:58:28,570 --> 00:58:33,260

1354
00:58:33,260 --> 00:58:35,630
>> ALLISON：62，是的。

1355
00:58:35,630 --> 00:58:38,675
所以在这种情况下，什么
将它打印出来？

1356
00:58:38,675 --> 00:58:40,360
这第一次？

1357
00:58:40,360 --> 00:58:43,830
如果我们有百分之D，
那能说明什么？

1358
00:58:43,830 --> 00:58:45,980

1359
00:58:45,980 --> 00:58:46,730
学生：一个数字。

1360
00:58:46,730 --> 00:58:48,604
艾里逊：我们正在打印
出的实数。

1361
00:58:48,604 --> 00:58:50,770
所以，我们实际上会
在这里打印出32。

1362
00:58:50,770 --> 00:58:56,360
如果这是百分之C，
32会给我们一个空间。

1363
00:58:56,360 --> 00:58:57,700

1364
00:58:57,700 --> 00:59:01,670
这么理解的
字符可以被打印

1365
00:59:01,670 --> 00:59:06,140
这两个数字和为
实际字符

1366
00:59:06,140 --> 00:59:11,080
是非常重要的，和支付
注意实际的类型

1367
00:59:11,080 --> 00:59:12,040
我们在这里所做的。

1368
00:59:12,040 --> 00:59:14,520

1369
00:59:14,520 --> 00:59:15,020
凉爽。

1370
00:59:15,020 --> 00:59:18,862
所以对于这些每隔1，
什么是我们将要打印？

1371
00:59:18,862 --> 00:59:19,825
>> 学生：一个字符。

1372
00:59:19,825 --> 00:59:20,830
>> 艾里逊：一个字符。

1373
00:59:20,830 --> 00:59:21,330
凉爽。

1374
00:59:21,330 --> 00:59:24,260
所以，如果你们想知道，你
可以工作，这些在你自己。

1375
00:59:24,260 --> 00:59:25,900
如果您遇到问题，给我发电子邮件。

1376
00:59:25,900 --> 00:59:28,950
但是，第二个会
打印出一个小写的B。

1377
00:59:28,950 --> 00:59:32,910
第三个会打印出一个
大写字母B.第四个将打印

1378
00:59:32,910 --> 00:59:36,410
出一个大写的C，而
最后一个将是一个小写A.

1379
00:59:36,410 --> 00:59:42,530
最后埃德蒙顿我们实际上会
要进什么疯狂的百分比

1380
00:59:42,530 --> 00:59:45,020
标志甚至意味着一对夫妇的幻灯片。

1381
00:59:45,020 --> 00:59:46,667
因此，尝试那些你自己。

1382
00:59:46,667 --> 00:59:48,500
如果你有麻烦，
请你跟我说话。

1383
00:59:48,500 --> 00:59:49,655

1384
00:59:49,655 --> 00:59:53,290
如果你通常在亚当斯D厅，
你可能会发现我身边。

1385
00:59:53,290 --> 00:59:54,760

1386
00:59:54,760 --> 00:59:55,760
>> 所以，ATOI。

1387
00:59:55,760 --> 00:59:59,660
你们有多少人看到了这
功能或听说过呢？

1388
00:59:59,660 --> 01:00:00,380

1389
01:00:00,380 --> 01:00:00,880
任何人吗？

1390
01:00:00,880 --> 01:00:02,100

1391
01:00:02,100 --> 01:00:02,600
凉爽。

1392
01:00:02,600 --> 01:00:06,250
那么，它实际上代表
对于是ASCII为整数。

1393
01:00:06,250 --> 01:00:13,150
所以，你可以做的是，凯撒，
对于那些谁读的规格，

1394
01:00:13,150 --> 01:00:16,460
你要做点斜线撒
之后，你写你的程序，

1395
01:00:16,460 --> 01:00:18,690
然后你要
输入一些数字，你

1396
01:00:18,690 --> 01:00:24,780
想你的秘密消息进行编码。

1397
01:00:24,780 --> 01:00:30,700
>> 但是，如果我们还记得，我们所有的
输入被存储为字符串。

1398
01:00:30,700 --> 01:00:31,390
对不对？

1399
01:00:31,390 --> 01:00:35,160
我们有一个ARG V阵列
这是所有类型的字符串。

1400
01:00:35,160 --> 01:00:37,870
所以，如果你只是尝试
拉那一个，它会

1401
01:00:37,870 --> 01:00:43,240
认为一个或任何数量
你使用的实际上是一个字符。

1402
01:00:43,240 --> 01:00:45,490
所以，你会得到
一些疯狂的结果。

1403
01:00:45,490 --> 01:00:48,200
所以，如果你真的想
把它变成一个整数

1404
01:00:48,200 --> 01:00:52,060
你可以用它来操纵
你的话或你的消息，

1405
01:00:52,060 --> 01:00:53,366
你想用ATOI。

1406
01:00:53,366 --> 01:00:56,320
ATOI只是转换
您的字符串转换为int。

1407
01:00:56,320 --> 01:01:04,530
>> 所以，如果我们有12的字符串，如果我们调用
ATOI月12日，或任何的输入，

1408
01:01:04,530 --> 01:01:07,370
它实际上将返回
你的整数。

1409
01:01:07,370 --> 01:01:10,610
不是字符或字符串12。

1410
01:01:10,610 --> 01:01:14,230
其中，当你开始
要补充的是，以数字，

1411
01:01:14,230 --> 01:01:17,710
会有很大的不同，
因为字符串12是

1412
01:01:17,710 --> 01:01:21,210
在一些疯狂的数字
ASCII码，而整数12

1413
01:01:21,210 --> 01:01:23,390
实际上是12，这是你想要的。

1414
01:01:23,390 --> 01:01:25,630
所以，你要确保使用ATOI。

1415
01:01:25,630 --> 01:01:29,203
>> 你会想这个
在恺撒，因为你

1416
01:01:29,203 --> 01:01:32,520
需要通过提供的INT
用户在命令行中。

1417
01:01:32,520 --> 01:01:35,230
但是，当他们把它的命令
线，它是作为字符串存储

1418
01:01:35,230 --> 01:01:35,813
开始。

1419
01:01:35,813 --> 01:01:36,950

1420
01:01:36,950 --> 01:01:38,210
这是否有道理？

1421
01:01:38,210 --> 01:01:40,590
你不一定
需要这个的V @ genere。

1422
01:01:40,590 --> 01:01:43,180
用的V @ genere，正如我所说
之前，你应该尝试使用

1423
01:01:43,180 --> 01:01:46,600
ASCII数学，看起来更像是
这一点，在那里你实际上

1424
01:01:46,600 --> 01:01:49,320
使用我们提供给您的字符。

1425
01:01:49,320 --> 01:01:50,970

1426
01:01:50,970 --> 01:01:51,470
凉爽。

1427
01:01:51,470 --> 01:01:52,970

1428
01:01:52,970 --> 01:01:54,170
每个人都很好吗？

1429
01:01:54,170 --> 01:01:56,530

1430
01:01:56,530 --> 01:01:57,480
真棒。

1431
01:01:57,480 --> 01:01:59,030
>> 所以模。

1432
01:01:59,030 --> 01:02:01,950
所以，如果你正在考虑
这个庞大的数字凯撒？

1433
01:02:01,950 --> 01:02:03,720

1434
01:02:03,720 --> 01:02:07,970
你有这样的想法，
如果你在Z和你

1435
01:02:07,970 --> 01:02:11,020
给定一个数字2，
这意味着你need--

1436
01:02:11,020 --> 01:02:15,130
ž成为第二
经过自己的信，对不对？

1437
01:02:15,130 --> 01:02:20,800
所以，你需要以某种方式环绕，
和模是做到这一点的方法。

1438
01:02:20,800 --> 01:02:23,310
因此，它是所有这
给你剩下

1439
01:02:23,310 --> 01:02:25,660
的师
由第二首数。

1440
01:02:25,660 --> 01:02:28,660
我们有一些例子，
做出一点更具体。

1441
01:02:28,660 --> 01:02:34,390
但基本上，你用模时
想让周围的东西包裹。

1442
01:02:34,390 --> 01:02:36,950
>> 所以，如果你只想要
数字一到八人，

1443
01:02:36,950 --> 01:02:39,670
你可以在任何其他使用模
号，它会永远

1444
01:02:39,670 --> 01:02:42,960
返回一个数从零到8。

1445
01:02:42,960 --> 01:02:48,750
因此，一些examples--如果
我们有55模数10，

1446
01:02:48,750 --> 01:02:55,350
它只是给你的剩余
55除以10，这将是5。

1447
01:02:55,350 --> 01:02:56,440

1448
01:02:56,440 --> 01:03:02,470
然后3模5，
有人猜是什么，这将是？

1449
01:03:02,470 --> 01:03:03,800

1450
01:03:03,800 --> 01:03:04,300
三。

1451
01:03:04,300 --> 01:03:05,570

1452
01:03:05,570 --> 01:03:10,910
>> 所以，如果你面前有一个较小的数字
模，它不能进去均匀。

1453
01:03:10,910 --> 01:03:11,520
这是零。

1454
01:03:11,520 --> 01:03:14,090
所以它只是返回数字本身。

1455
01:03:14,090 --> 01:03:15,920
所以8模8会是什么？

1456
01:03:15,920 --> 01:03:16,603
>> 学生：零。

1457
01:03:16,603 --> 01:03:18,350
>> 艾里逊：零。

1458
01:03:18,350 --> 01:03:20,160
因为它会在均匀。

1459
01:03:20,160 --> 01:03:22,095
16模15？

1460
01:03:22,095 --> 01:03:23,660
>> 听众：一。

1461
01:03:23,660 --> 01:03:24,700
>> 艾里逊：酷。

1462
01:03:24,700 --> 01:03:29,280
然后这最后一个是刚
展示你 - 你可能会想，好吧，

1463
01:03:29,280 --> 01:03:31,800
什么是这里的操作顺序？

1464
01:03:31,800 --> 01:03:33,100
难道我们把第一个？

1465
01:03:33,100 --> 01:03:34,570
我们做的第一模？

1466
01:03:34,570 --> 01:03:38,730
所以模持有相同的优先级
作为部门或乘法，

1467
01:03:38,730 --> 01:03:39,940
和它的左结合。

1468
01:03:39,940 --> 01:03:41,730
所以它以同样的方式。

1469
01:03:41,730 --> 01:03:46,520
你总是做括号，
那么乘法，除法，

1470
01:03:46,520 --> 01:03:49,570
和模数，以便从左至右。

1471
01:03:49,570 --> 01:03:51,050
因此，标准的规则。

1472
01:03:51,050 --> 01:03:55,260
只要把它同日而语
作为除法和乘法。

1473
01:03:55,260 --> 01:03:59,040
>> 所以在这种情况下，我们将
有1加2给了我们3。

1474
01:03:59,040 --> 01:04:02,210
我们乘上2，这样我们就得到6。

1475
01:04:02,210 --> 01:04:05,050
我们的模2，这给我们吗？

1476
01:04:05,050 --> 01:04:06,042
>> 学生：0。

1477
01:04:06,042 --> 01:04:07,430
>> 艾里逊：0。

1478
01:04:07,430 --> 01:04:10,270
然后我们加2，所以我们
获得2在后一种情况下。

1479
01:04:10,270 --> 01:04:12,080

1480
01:04:12,080 --> 01:04:16,360
所以modulo--你肯定会
要考虑如何把

1481
01:04:16,360 --> 01:04:19,520
当你的包裹
周围的字母表。

1482
01:04:19,520 --> 01:04:24,210
如果你在Z和你需要移动
转发三个空格才能到C，

1483
01:04:24,210 --> 01:04:26,230
还有的认为整个概念
的缠绕。

1484
01:04:26,230 --> 01:04:28,790
所以我会离开它
你们要弄清楚

1485
01:04:28,790 --> 01:04:31,940
究竟你要使用它。

1486
01:04:31,940 --> 01:04:35,660
但绝对是一个很有用的工具
本周你的pset。

1487
01:04:35,660 --> 01:04:36,910

1488
01:04:36,910 --> 01:04:37,730
我真的很喜欢这一点。

1489
01:04:37,730 --> 01:04:39,480
这是我最喜欢的pset之一。

1490
01:04:39,480 --> 01:04:41,230
然后，你这样做之后，
如果你有朋友，

1491
01:04:41,230 --> 01:04:44,146
你可以一样，互送的秘密
消息并确保它的工作原理。

1492
01:04:44,146 --> 01:04:45,695
因为它会对其进行解密或什么的。

1493
01:04:45,695 --> 01:04:46,710

1494
01:04:46,710 --> 01:04:47,390
很多的乐趣。

1495
01:04:47,390 --> 01:04:48,840

1496
01:04:48,840 --> 01:04:51,220
>> 而且是部分的末尾。

1497
01:04:51,220 --> 01:04:52,430

1498
01:04:52,430 --> 01:04:54,040
我很早就完成了。

1499
01:04:54,040 --> 01:04:57,540
我还有15分钟
你们这些家伙，所以如果有什么事，

1500
01:04:57,540 --> 01:05:02,180
你想投奔
另外，我很乐意这样做。

1501
01:05:02,180 --> 01:05:04,340
任何其他问题
您PSET对于那些你

1502
01:05:04,340 --> 01:05:06,355
谁已开始或读取规格。

1503
01:05:06,355 --> 01:05:07,870

1504
01:05:07,870 --> 01:05:12,060
凡是我们已经谈
约在最后一小时

1505
01:05:12,060 --> 01:05:16,880
15分钟，你会喜欢我
以一种老调重弹，我很乐意。

1506
01:05:16,880 --> 01:05:20,790
或者，我们可以调用它退出，你可以
所有休假，采取更加糖果与你

1507
01:05:20,790 --> 01:05:21,650
当您去。

1508
01:05:21,650 --> 01:05:23,719

1509
01:05:23,719 --> 01:05:26,260
但是，如果有任何挥之不去
问题，请让我知道。

1510
01:05:26,260 --> 01:05:28,467
您也可以上来，
跟我算账。

1511
01:05:28,467 --> 01:05:29,425
我发誓我不咬。

1512
01:05:29,425 --> 01:05:32,140

1513
01:05:32,140 --> 01:05:32,795
还要别的吗？

1514
01:05:32,795 --> 01:05:33,890

1515
01:05:33,890 --> 01:05:35,240
大家的好？

1516
01:05:35,240 --> 01:05:37,540
就像每个人的感觉
他们可以处理这个PSET？

1517
01:05:37,540 --> 01:05:38,820

1518
01:05:38,820 --> 01:05:42,405
你会好起来的家伙。

1519
01:05:42,405 --> 01:05:43,905
办公时间是有原因的。

1520
01:05:43,905 --> 01:05:45,930

1521
01:05:45,930 --> 01:05:46,460
凉爽。

1522
01:05:46,460 --> 01:05:47,020
好吧。

1523
01:05:47,020 --> 01:05:49,680
>> 那么，在这种情况下，谢谢
大家的光临。

1524
01:05:49,680 --> 01:05:50,940
我希望看到你下周。

1525
01:05:50,940 --> 01:05:52,120
将会有更多的糖果。

1526
01:05:52,120 --> 01:05:53,495
可能还有其他很酷的事情。

1527
01:05:53,495 --> 01:05:55,010

1528
01:05:55,010 --> 01:05:59,090
我期待着得到
要知道你们今年。

1529
01:05:59,090 --> 01:06:00,320