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

2
00:00:05,530 --> 00:00:09,790
>> 教授：那么对于日程
这个星期，没有那么多的东西。

3
00:00:09,790 --> 00:00:12,801
但希望非常，非常有帮助
而相关的你们这个星期。

4
00:00:12,801 --> 00:00:15,550
但是，我们要花费可能15，
20分钟只是快速地说话

5
00:00:15,550 --> 00:00:17,370
有关链接列表。

6
00:00:17,370 --> 00:00:19,694
链接列表要
被覆盖在测验。

7
00:00:19,694 --> 00:00:22,610
因此，或许这将是非常有益
学习一些关于那是什么。

8
00:00:22,610 --> 00:00:25,210
>> 我们将花费巨大的
当今的大多数节

9
00:00:25,210 --> 00:00:27,640
去在测验零的实践问题。

10
00:00:27,640 --> 00:00:30,970
然后，我们可以节省大概有20，30分
在结束对所存疑问

11
00:00:30,970 --> 00:00:32,850
任何人有。

12
00:00:32,850 --> 00:00:34,610
>> 然后，最后
五分钟，我要去

13
00:00:34,610 --> 00:00:36,467
给泵了讲话测验。

14
00:00:36,467 --> 00:00:38,050
你们都希望在这里呆了。

15
00:00:38,050 --> 00:00:39,591
因为这将是一个好时机。

16
00:00:39,591 --> 00:00:42,650

17
00:00:42,650 --> 00:00:49,230
>> 好吧，所以一些
材料上的链接列表。

18
00:00:49,230 --> 00:00:52,620
他们是如何结构通常是
你有什么所谓的节点，对不对？

19
00:00:52,620 --> 00:00:54,870
你有这些东西叫做
节点，这是结构。

20
00:00:54,870 --> 00:00:57,360
我去了如何创建
在下一幻灯片的节点。

21
00:00:57,360 --> 00:01:00,680
但是基本上所有链接
列出的是数据

22
00:01:00,680 --> 00:01:03,340
通过指针已经被串在一起。

23
00:01:03,340 --> 00:01:09,110
>> 而这样做的好处，我们有
使用链表以上的，

24
00:01:09,110 --> 00:01:11,280
或许，像阵列，是
一个事实，即在一个阵列

25
00:01:11,280 --> 00:01:15,000
你需要一个连续的块
内存都在同一个地方，人们

26
00:01:15,000 --> 00:01:16,870
又一个，以便能够有。

27
00:01:16,870 --> 00:01:20,200
而一个链表，你可以
有记忆的随机小位

28
00:01:20,200 --> 00:01:23,020
在你的电脑
通过指针串成。

29
00:01:23,020 --> 00:01:26,270
>> 而这样你
可以访问信息

30
00:01:26,270 --> 00:01:28,610
附带一前一后
其他，后等

31
00:01:28,610 --> 00:01:32,720
而不需要的只是一大块
内存在计算机中的某个地方。

32
00:01:32,720 --> 00:01:35,910
所以这是一个主要的
原因我们使用链接列表。

33
00:01:35,910 --> 00:01:40,300
>> 其次，它很容易动态
调整，因为在数组中的链接列表，

34
00:01:40,300 --> 00:01:44,720
当你声明一个数组，
你有某一设定值。

35
00:01:44,720 --> 00:01:47,340
比方说，我想创建
10整数数组。

36
00:01:47,340 --> 00:01:49,970
我创建了10个阵列
整数，仅此而已。

37
00:01:49,970 --> 00:01:50,580
这是10。

38
00:01:50,580 --> 00:01:52,038
我不知道以后的事。

39
00:01:52,038 --> 00:01:53,680
如果我想让它11，不能做到这一点。

40
00:01:53,680 --> 00:01:55,710
如果我想使它9，不能做到这一点。

41
00:01:55,710 --> 00:01:59,910
>> 而在链接列表，你可以添加和
删除和插入任何你想要的。

42
00:01:59,910 --> 00:02:04,940
您可以动态地调整你的
构建这里，你的数据结构。

43
00:02:04,940 --> 00:02:08,370
这给了我们很多
更增加了灵活性

44
00:02:08,370 --> 00:02:11,320
我们通常不
有数组。

45
00:02:11,320 --> 00:02:15,210
>> 任何人混淆就基本
如何链接列表结构

46
00:02:15,210 --> 00:02:17,930
为什么我们要使用一个以上的阵列？

47
00:02:17,930 --> 00:02:20,330
是啊，我们就去了详细
如何真正创建一个。

48
00:02:20,330 --> 00:02:24,121
但是，这只是一种
一般意义上的现在。

49
00:02:24,121 --> 00:02:24,620
凉。

50
00:02:24,620 --> 00:02:28,770
所以阵列串成
这些可爱的小东西

51
00:02:28,770 --> 00:02:29,960
所谓的节点。

52
00:02:29,960 --> 00:02:32,210
所有节点的是一种结构的。

53
00:02:32,210 --> 00:02:36,090
请记住，一个结构是，如果你想
创造了一定类型的变量

54
00:02:36,090 --> 00:02:39,850
在C，它已经不
存在，你作为一个程序员，

55
00:02:39,850 --> 00:02:42,030
实际上可以创建自己。

56
00:02:42,030 --> 00:02:46,540
>> 因此这种类型的数据
结构被称为一个节点，

57
00:02:46,540 --> 00:02:50,770
实际上已经由我们创造，即
C内自身不存在。

58
00:02:50,770 --> 00:02:53,150
和使用的方式
创建一个是你有没有

59
00:02:53,150 --> 00:02:57,170
typedef结构的头部，
它告诉编译器，我

60
00:02:57,170 --> 00:02:59,640
要创建一个结构。

61
00:02:59,640 --> 00:03:00,830
>> 我们将其命名为“节点”。

62
00:03:00,830 --> 00:03:03,350
而且里面我们要
在声明一个变量，

63
00:03:03,350 --> 00:03:05,060
这是要存储的值。

64
00:03:05,060 --> 00:03:09,320
然后，我们也将
有人称指针“下一步”

65
00:03:09,320 --> 00:03:12,090
指向下一
节点在链接列表。

66
00:03:12,090 --> 00:03:14,730
然后你完成该关
通过只需再次重复节点，

67
00:03:14,730 --> 00:03:17,490
编译器知道，OK
这是我的结构的结束。

68
00:03:17,490 --> 00:03:22,540
>> 所以在这种方式，我们是一起
创建一个可爱的小阵列

69
00:03:22,540 --> 00:03:25,450
之类的话了
值和一个指针。

70
00:03:25,450 --> 00:03:27,757
你可以将它们链接全部
连同那些指针。

71
00:03:27,757 --> 00:03:30,090
使他们能够都挺会
串成链中。

72
00:03:30,090 --> 00:03:32,920

73
00:03:32,920 --> 00:03:34,162
>> 凉。

74
00:03:34,162 --> 00:03:35,453
你能听到好一点？

75
00:03:35,453 --> 00:03:36,140
>> 听众：是的。

76
00:03:36,140 --> 00:03:38,540
>> 教授：好的。

77
00:03:38,540 --> 00:03:44,280
因此，作为你们可以看到的样子，
一个典型的链表的结构

78
00:03:44,280 --> 00:03:45,500
是你有一个头。

79
00:03:45,500 --> 00:03:49,460
你有头值不
被指向任何其他指针。

80
00:03:49,460 --> 00:03:53,177
但它会指向，
或参考，另一个节点。

81
00:03:53,177 --> 00:03:56,510
该节点之后将要引用
在那之后，等等，等等节点

82
00:03:56,510 --> 00:03:59,170
直到你最终打
您的链接列表的末尾。

83
00:03:59,170 --> 00:04:00,980
而你是不会有一个指针在那里。

84
00:04:00,980 --> 00:04:04,659
>> 因此，认为像，在项链上，甚至
如果你们做球员，我不知道，

85
00:04:04,659 --> 00:04:06,450
喜欢用水果循环
当你还小。

86
00:04:06,450 --> 00:04:08,590
你愿意把它们串起来
并且穿起来挂在脖子上。

87
00:04:08,590 --> 00:04:09,840
认为这是同样的事情。

88
00:04:09,840 --> 00:04:12,964
你有这些小东西，你
可以串在一起的点一

89
00:04:12,964 --> 00:04:15,291
之后，以一前一后
它，等等，等等

90
00:04:15,291 --> 00:04:17,040
直到你有一个链
的数据结构的

91
00:04:17,040 --> 00:04:21,190
你可以使用你喜欢的。

92
00:04:21,190 --> 00:04:27,370
>> 因此，办法，这我们会
通常插入或删除

93
00:04:27,370 --> 00:04:30,020
从链路的任何节点
列表非常不同

94
00:04:30,020 --> 00:04:31,970
根据所在的节点。

95
00:04:31,970 --> 00:04:34,880
因此，例如，因为
指针总是

96
00:04:34,880 --> 00:04:38,645
指向一个特定的值，
当您删除或插入一个节点，

97
00:04:38,645 --> 00:04:41,770
你想确保该指针
在所有指向正确的事情。

98
00:04:41,770 --> 00:04:46,200
>> 所以，如果你想有可能插入
与一个的值的新的节点

99
00:04:46,200 --> 00:04:48,379
排序的内部链接
列表中，大家都知道在这里

100
00:04:48,379 --> 00:04:51,170
从图片中，那将
去头和两者之间的，对不对？

101
00:04:51,170 --> 00:04:52,620
因为一个适合那里。

102
00:04:52,620 --> 00:04:59,060
但以何种方式，我们会做的
是第一个取消引用指针

103
00:04:59,060 --> 00:05:02,160
从头部和发送那一个。

104
00:05:02,160 --> 00:05:05,040
>> 但是，我们进入了一个问题在这里。

105
00:05:05,040 --> 00:05:08,280
任何人都可以看看是什么问题
就是如果我们先提领

106
00:05:08,280 --> 00:05:10,090
从头部指针吗？

107
00:05:10,090 --> 00:05:14,202
有什么问题可以再碰上，如果我们试图
把它添加到我们的数组的前面？

108
00:05:14,202 --> 00:05:15,409
>> 听众：[听不清]

109
00:05:15,409 --> 00:05:16,200
教授：没错。

110
00:05:16,200 --> 00:05:20,000
所以在这里，我们有一个指针，是
一旦从头部指向两种。

111
00:05:20,000 --> 00:05:23,120
但是，如果你摆脱了
指针，你点它一个，

112
00:05:23,120 --> 00:05:26,500
我们现在不知道
去哪里找到两个。

113
00:05:26,500 --> 00:05:29,850
因为正如我之前说的，你已经有了一个
内存在计算机中巨块。

114
00:05:29,850 --> 00:05:31,860
所有这些节点可以
随机穿插

115
00:05:31,860 --> 00:05:33,350
在计算机上的任何地方。

116
00:05:33,350 --> 00:05:36,140
而你不知道如何
去寻找的。

117
00:05:36,140 --> 00:05:40,420
>> 所以，你需要有指针
指着在结束所有节点。

118
00:05:40,420 --> 00:05:42,420
否则，如果你不小心
提领1

119
00:05:42,420 --> 00:05:44,485
不先分配
价值第一，你

120
00:05:44,485 --> 00:05:47,410
只是要输
一切之后。

121
00:05:47,410 --> 00:05:49,720
>> 所以，我们要什么
做的是，你首先

122
00:05:49,720 --> 00:05:53,270
要在创建一个指针
节点要插入。

123
00:05:53,270 --> 00:05:55,270
它指向您
想将它插入到，

124
00:05:55,270 --> 00:05:59,410
然后事后你
能回点的头一个。

125
00:05:59,410 --> 00:06:02,800
>> 这是否有意义给大家吗？

126
00:06:02,800 --> 00:06:03,346
大。

127
00:06:03,346 --> 00:06:04,720
把它看成就像一个链条。

128
00:06:04,720 --> 00:06:07,420
如果添加链，
它是一种直观

129
00:06:07,420 --> 00:06:10,742
你如何去插入的。

130
00:06:10,742 --> 00:06:15,274
>> 好了，这实际上是多
更短的比我想象的还要好，

131
00:06:15,274 --> 00:06:16,690
在链接列出了五分钟的高谈阔论。

132
00:06:16,690 --> 00:06:19,960
只是让你们有
那是基本的想法。

133
00:06:19,960 --> 00:06:23,580
>> 下面我们就针对测验零议程。

134
00:06:23,580 --> 00:06:24,895
不要让这种恐吓你。

135
00:06:24,895 --> 00:06:26,270
我知道这是一个很大的信息。

136
00:06:26,270 --> 00:06:27,580
它看起来很吓人。

137
00:06:27,580 --> 00:06:33,130
这也是一个很大的，我
认为，CSC一种术语。

138
00:06:33,130 --> 00:06:37,440
事情是十六进制字符串，
指针，动态内存分配

139
00:06:37,440 --> 00:06:40,120
是非常可怕的冠冕堂皇的条款。

140
00:06:40,120 --> 00:06:42,700
>> 但是，我们要打破他们
下来，做一些练习题

141
00:06:42,700 --> 00:06:44,980
所以，你们所有
准备这个考试。

142
00:06:44,980 --> 00:06:47,104
怎么你们许多有
已经开始学习？

143
00:06:47,104 --> 00:06:50,040

144
00:06:50,040 --> 00:06:53,670
>> 好了，你们可能想
开始入门

145
00:06:53,670 --> 00:06:56,480
上，因为测验是明天。

146
00:06:56,480 --> 00:06:58,739
或者周四一些你。

147
00:06:58,739 --> 00:07:01,030
是啊，所以我们要去
对一些实际问题。

148
00:07:01,030 --> 00:07:04,600
如果你们都希望拿
出一张纸，一支铅笔。

149
00:07:04,600 --> 00:07:07,310
我们将只花了
今天的第绝大多数

150
00:07:07,310 --> 00:07:11,590
在看一些的，这么你们有
以期望在测验什么的想法。

151
00:07:11,590 --> 00:07:14,957

152
00:07:14,957 --> 00:07:16,890
>> 好。

153
00:07:16,890 --> 00:07:19,730
一对夫妇后勤
详细信息以及，任何人

154
00:07:19,730 --> 00:07:25,120
谁没有去过那个环节出现，如果
你去cs50.yale.edu，前面

155
00:07:25,120 --> 00:07:28,566
这个页面有一个链接
上面写着“关于测验零。”

156
00:07:28,566 --> 00:07:29,440
链接需要你。

157
00:07:29,440 --> 00:07:31,065
如果你还没有看过，请阅读。

158
00:07:31,065 --> 00:07:34,470
因为它告诉你真的很重要
有关测验的信息。

159
00:07:34,470 --> 00:07:37,410
>> 我要拔了这一点，从
只是因为，身体，

160
00:07:37,410 --> 00:07:40,200
如果你们不知道在哪里
走，我们都会有问题。

161
00:07:40,200 --> 00:07:44,220
所以，如果你在一个方面最后
以N，去法学院礼堂。

162
00:07:44,220 --> 00:07:47,500
如果你的最后一个开始以P
到Z，去戴维斯礼堂。

163
00:07:47,500 --> 00:07:50,240
而这仅适用于
人们在周三部分。

164
00:07:50,240 --> 00:07:53,420
>> 如果你正在服用的测验
周四，你去SSS 114

165
00:07:53,420 --> 00:07:55,078
在您的演讲通常是。

166
00:07:55,078 --> 00:07:55,953
听众：[听不清]

167
00:07:55,953 --> 00:07:59,316

168
00:07:59,316 --> 00:08:01,940
教授：o到Z，你会
前往戴维斯礼堂。

169
00:08:01,940 --> 00:08:03,273
我要改变这种状况，对吧？

170
00:08:03,273 --> 00:08:05,670

171
00:08:05,670 --> 00:08:09,698
>> 哦，对了，你刚才自动失效。

172
00:08:09,698 --> 00:08:11,753
>> 噢，那是你克里斯塔。

173
00:08:11,753 --> 00:08:15,190

174
00:08:15,190 --> 00:08:16,030
是啊，是我不好。

175
00:08:16,030 --> 00:08:17,610
是的，哦到Z，你会
前往戴维斯Auditorim。

176
00:08:17,610 --> 00:08:19,140
我要解决这个问题，一旦我上传。

177
00:08:19,140 --> 00:08:20,320
是啊。

178
00:08:20,320 --> 00:08:22,160
>> 然后也未尝
重要的是心态

179
00:08:22,160 --> 00:08:25,290
是那个星期三，如果你是正式
就读于周三部分，

180
00:08:25,290 --> 00:08:26,832
你必须把你的测验上周三。

181
00:08:26,832 --> 00:08:29,706
如果你参加了周四，
你必须把你的测验周四。

182
00:08:29,706 --> 00:08:31,000
而且它是在上课时间。

183
00:08:31,000 --> 00:08:35,970
其中，我觉得它就像1:00到
2:15周三和下午2:30至3:45

184
00:08:35,970 --> 00:08:37,220
在星期四。

185
00:08:37,220 --> 00:08:41,710
>> 如果你有一个不可调和的矛盾，
院长的借口是唯一的东西，

186
00:08:41,710 --> 00:08:43,030
不幸的是，我们可以采取。

187
00:08:43,030 --> 00:08:45,560
因为我们有一个
请求绝大部分

188
00:08:45,560 --> 00:08:47,970
到周三切换至周四。

189
00:08:47,970 --> 00:08:51,265
我们不能兑现，除非
我们有一个院长的请求。

190
00:08:51,265 --> 00:08:52,650
>> 好。

191
00:08:52,650 --> 00:08:57,000
这样我们就得到一个开始前
夫妇的实际问题，

192
00:08:57,000 --> 00:09:00,540
我刚准备走了过来
安迪的帮助提示成功。

193
00:09:00,540 --> 00:09:04,140
你这家伙，当你学习，你真的
想练手工编写代码。

194
00:09:04,140 --> 00:09:07,050
在我第一次
花了CS测验，我没有

195
00:09:07,050 --> 00:09:09,960
手练习写代码
之前，它是非常

196
00:09:09,960 --> 00:09:11,890
令人震惊的是多么困难。

197
00:09:11,890 --> 00:09:16,125
>> 当你们不要进入
打字的一切习惯，

198
00:09:16,125 --> 00:09:20,260
说到很自然的被
能有自动完成

199
00:09:20,260 --> 00:09:22,015
括号和分号那里。

200
00:09:22,015 --> 00:09:23,890
当你写出来
手，有时是

201
00:09:23,890 --> 00:09:27,100
很，很容易忘记一个分号，
或忘记关闭一个支架，

202
00:09:27,100 --> 00:09:30,970
或忘记关闭一个冒号，
或类似的东西。

203
00:09:30,970 --> 00:09:34,322
>> 所以，当你手工编写代码，
这是一个非常不同的感觉。

204
00:09:34,322 --> 00:09:37,280
所以你们这些家伙，当你工作
通过一些实际问题，

205
00:09:37,280 --> 00:09:38,904
那就好，真正实践的今天。

206
00:09:38,904 --> 00:09:41,770
或者明天，我想，如果你
同时在周四的测验。

207
00:09:41,770 --> 00:09:45,280
>> 其次，我们有上次一样，
8年的价值实践

208
00:09:45,280 --> 00:09:47,070
在线测验。

209
00:09:47,070 --> 00:09:50,759
今年的测验可能会
非常，非常相似，所有的人。

210
00:09:50,759 --> 00:09:51,800
他们都非常相似。

211
00:09:51,800 --> 00:09:54,220
有种你进入
问题的类型风格

212
00:09:54,220 --> 00:09:57,250
我们要求，类型
功能，我们将它写的，

213
00:09:57,250 --> 00:09:58,580
等等，等等。

214
00:09:58,580 --> 00:10:01,980
>> 因此，采取这种做法测验，
尤其是在时间上的限制。

215
00:10:01,980 --> 00:10:05,390
75分钟做小测验
没有很多的时间量。

216
00:10:05,390 --> 00:10:07,254
这是很长很长。

217
00:10:07,254 --> 00:10:09,670
所以你们真的想
以确保你们是

218
00:10:09,670 --> 00:10:11,990
在写作的习惯
手工代码快。

219
00:10:11,990 --> 00:10:15,070
因为你不希望第一
时间一看就知道长度的测验

220
00:10:15,070 --> 00:10:16,560
在你的测验。

221
00:10:16,560 --> 00:10:20,540
你们真的要确保
你事先练习。

222
00:10:20,540 --> 00:10:24,550
>> 第四，要查看该
讲座和部分幻灯片。

223
00:10:24,550 --> 00:10:25,980
你不必记住的东西。

224
00:10:25,980 --> 00:10:30,430
其实，每个人都被允许
一张白纸笔记，

225
00:10:30,430 --> 00:10:31,090
正面和背面。

226
00:10:31,090 --> 00:10:32,920
你们可以键入或写。

227
00:10:32,920 --> 00:10:37,070
如果你发现自己需要记忆
任何东西，把它倒在了表。

228
00:10:37,070 --> 00:10:40,810
>> 我向你保证，你不想
被卡在了竞猜的中间

229
00:10:40,810 --> 00:10:43,890
是象，哦，是的，有什么
运行时这种抗之类的。

230
00:10:43,890 --> 00:10:46,490
只要把它记下来，​​把它复制
直接从您的笔记纸。

231
00:10:46,490 --> 00:10:50,420
然后，你可以真正地使用你的
大脑思考的问题

232
00:10:50,420 --> 00:10:52,190
而不必记得事实。

233
00:10:52,190 --> 00:10:55,250
所以，真正的利用
任何利基细节

234
00:10:55,250 --> 00:11:00,140
你认为你需要记住，
扑通下来的审查表。

235
00:11:00,140 --> 00:11:02,680
>> 好了，任何问题后勤
关于测验

236
00:11:02,680 --> 00:11:05,510
在我们开始之前一些
竞猜问题的做法？

237
00:11:05,510 --> 00:11:06,416
是吗？

238
00:11:06,416 --> 00:11:10,040
>> 听众：我还没有机会
看测验[听不清]

239
00:11:10,040 --> 00:11:11,757
但它会是
应用居多，

240
00:11:11,757 --> 00:11:14,090
或者是有也将是，
像，知识的问题？

241
00:11:14,090 --> 00:11:14,940
>> 教授：这是一个很大。

242
00:11:14,940 --> 00:11:16,731
因此，该办法，我
将描述测验

243
00:11:16,731 --> 00:11:18,810
is--我放在一起
一些实际问题

244
00:11:18,810 --> 00:11:20,960
我从所有的测验拉。

245
00:11:20,960 --> 00:11:25,210
但你会看到有两个主要的
类型的问题，我们会问你。

246
00:11:25,210 --> 00:11:28,750
>> 一个是东西非常低的水平的细节。

247
00:11:28,750 --> 00:11:31,720
我们会给你一个小的代码块
并说，有一个错误在这里？

248
00:11:31,720 --> 00:11:33,110
什么会打印出在这里？

249
00:11:33,110 --> 00:11:35,980
什么将这段代码产生，等等。

250
00:11:35,980 --> 00:11:38,710
因此，非常低的水平信息的详细信息。

251
00:11:38,710 --> 00:11:42,700
>> 而在另一面，我们将有很
高层次的知识为基础的问题。

252
00:11:42,700 --> 00:11:45,190
你能解释一下
二进制搜索之间差

253
00:11:45,190 --> 00:11:46,148
和线性搜索？

254
00:11:46,148 --> 00:11:48,500
为什么我们要
使用一个比其他？

255
00:11:48,500 --> 00:11:49,960
也许，什么是GDB？

256
00:11:49,960 --> 00:11:51,560
为什么我们要使用GDB？

257
00:11:51,560 --> 00:11:54,590
更高的层次，更根本的
理解的问题。

258
00:11:54,590 --> 00:11:58,240
所以，你会看到的混合物
他们对你的测验两个。

259
00:11:58,240 --> 00:12:01,462
>> 任何其他操作之前，我们
直奔进去？

260
00:12:01,462 --> 00:12:02,879
好。

261
00:12:02,879 --> 00:12:03,670
听众：还有一个。

262
00:12:03,670 --> 00:12:04,030
教授：哦，多了一个。

263
00:12:04,030 --> 00:12:04,340
抱歉。

264
00:12:04,340 --> 00:12:05,631
>> 听众：是的，它的一切权利。

265
00:12:05,631 --> 00:12:10,140
所以你说75分钟是
过短，像这是不可能

266
00:12:10,140 --> 00:12:11,640
我们将完成？

267
00:12:11,640 --> 00:12:13,571
还是一样，75分钟
正是尽可能多的时间

268
00:12:13,571 --> 00:12:15,700
因为我们需要的，如果我们
适当的准备？

269
00:12:15,700 --> 00:12:17,450
教授：好了，所以
测验是具有挑战性的。

270
00:12:17,450 --> 00:12:19,550
这肯定是具有挑战性的。

271
00:12:19,550 --> 00:12:21,092
你会发现自己在很短的时间。

272
00:12:21,092 --> 00:12:24,341
你可能会打，像10，
要走15分钟，而且是喜欢，狗屎。

273
00:12:24,341 --> 00:12:25,520
我有那么多剩下的工作。

274
00:12:25,520 --> 00:12:26,520
而这完全罚款。

275
00:12:26,520 --> 00:12:28,740
每个人都会有同样的感觉。

276
00:12:28,740 --> 00:12:31,074
>> 只是很清楚
你有多少时间。

277
00:12:31,074 --> 00:12:33,490
所以这就是为什么我告诉你
你们做的练习测验。

278
00:12:33,490 --> 00:12:36,672
因为它确实给人一种很有成就感
什么样的测验将是喜欢。

279
00:12:36,672 --> 00:12:39,130
所以，如果你发现自己被
能够完成的做法

280
00:12:39,130 --> 00:12:41,671
在一个良好的金额测验
时间，你可以自己的步伐好，

281
00:12:41,671 --> 00:12:45,695
那么，你会不会有问题
在周三或周四。

282
00:12:45,695 --> 00:12:46,575
>> 凉。

283
00:12:46,575 --> 00:12:49,200
所以，如果每个人都wants--我想
大多数人都有的纸张

284
00:12:49,200 --> 00:12:49,810
出来了。

285
00:12:49,810 --> 00:12:52,604
我要去基本上只是
给你的样题，

286
00:12:52,604 --> 00:12:54,520
给你们一样，一
几分钟的时间做他们。

287
00:12:54,520 --> 00:12:59,610
而我们就去了作为一个阶级
什么是他们的答案是。

288
00:12:59,610 --> 00:13:02,860
>> 所以这是一个非常典型的
早期的问题，我们会

289
00:13:02,860 --> 00:13:06,720
问你，只是转换
不同的碱基之间的数字。

290
00:13:06,720 --> 00:13:09,070
二进制，因为你们可以
召回，是基地二期。

291
00:13:09,070 --> 00:13:12,470
十进制为基数10，或者我们
作为人类通常解释。

292
00:13:12,470 --> 00:13:17,120
十六进制是基地16，这是零
到九，以及A至F

293
00:13:17,120 --> 00:13:19,990
>> 因此，有四位数字我
要求你们在这里进行转换。

294
00:13:19,990 --> 00:13:23,909
我给你喜欢的，三
四分钟思考如何

295
00:13:23,909 --> 00:13:25,200
我们会去解决这一点。

296
00:13:25,200 --> 00:13:32,832

297
00:13:32,832 --> 00:13:35,710
>> 听众：我们现在可以计算器？

298
00:13:35,710 --> 00:13:37,630
>> 教授：你不会
需要计算器，是的。

299
00:13:37,630 --> 00:13:42,420
我想基本此外，我认为，是
所有你们会被要求做。

300
00:13:42,420 --> 00:14:41,700

301
00:14:41,700 --> 00:14:45,070
>> 而只是让我有种有意​​识
当大家都在做的，抬头，

302
00:14:45,070 --> 00:14:47,429
波，我不知道，微笑，
看起来很高兴，如果你就大功告成了。

303
00:14:47,429 --> 00:14:47,929
是啊。

304
00:14:47,929 --> 00:17:21,680

305
00:17:21,680 --> 00:17:23,945
也许两分钟。

306
00:17:23,945 --> 00:18:28,080

307
00:18:28,080 --> 00:18:29,600
>> 好吧，让我们把它研究。

308
00:18:29,600 --> 00:18:31,580
我特意去
给你们的时间更少

309
00:18:31,580 --> 00:18:33,760
比你可能需要
做的一些问题，

310
00:18:33,760 --> 00:18:37,124
只是因为我想确保
我们经历了一堆问题得到。

311
00:18:37,124 --> 00:18:39,290
因此，没有，如果你没有后顾之忧
有机会完成。

312
00:18:39,290 --> 00:18:43,770
只要你有完全确定
如何去了解这一点的想法。

313
00:18:43,770 --> 00:18:45,850
因此，让我们继续前进，做第一个。

314
00:18:45,850 --> 00:18:52,690

315
00:18:52,690 --> 00:18:57,870
>> 因此，首先，有没有人想告诉我
二进制，什么做所有这些数字

316
00:18:57,870 --> 00:19:00,484
代表他们的价值观方面？

317
00:19:00,484 --> 00:19:01,250
是吗？

318
00:19:01,250 --> 00:19:03,349
>> 听众：两到
功率零，二至之一。

319
00:19:03,349 --> 00:19:04,140
教授：没错。

320
00:19:04,140 --> 00:19:04,640
所以。

321
00:19:04,640 --> 00:19:13,430

322
00:19:13,430 --> 00:19:16,430
>> 对，所以一般
当我们以10

323
00:19:16,430 --> 00:19:20,580
所有这些代表都一样，
10到零的基础上，对不对？

324
00:19:20,580 --> 00:19:21,810
那是你一个人的地方。

325
00:19:21,810 --> 00:19:24,520
所有的10的地方是
10之一的功率。

326
00:19:24,520 --> 00:19:26,600
你100的地方是10
于两个的功率。

327
00:19:26,600 --> 00:19:29,570
>> 无论基地你在会
做同样的事情，

328
00:19:29,570 --> 00:19:31,480
只是用不同的基地。

329
00:19:31,480 --> 00:19:34,130
所以二进制，所有这些都是为基地二期。

330
00:19:34,130 --> 00:19:37,110
你要转换所有
数字分为二的任何权力

331
00:19:37,110 --> 00:19:38,190
那数字。

332
00:19:38,190 --> 00:19:41,450
因此在这个意义上说，我们
可以有一个更简单的方法

333
00:19:41,450 --> 00:19:43,800
是能够加起来或
总结所有号码，以便

334
00:19:43,800 --> 00:19:46,010
转换成基10。

335
00:19:46,010 --> 00:19:50,362
>> 因此，没有人想告诉我是什么
回答第一个是在基地10？

336
00:19:50,362 --> 00:19:51,674
>> 听众：二，[听不清]

337
00:19:51,674 --> 00:19:52,340
教授：是的。

338
00:19:52,340 --> 00:19:53,230
听众：42。

339
00:19:53,230 --> 00:19:56,560
教授：42，你去那里。

340
00:19:56,560 --> 00:20:00,660
因此，我们得到这个答案的方法是通过
在做两首，这是两个。

341
00:20:00,660 --> 00:20:02,760
加上两个第三，这是8。

342
00:20:02,760 --> 00:20:07,590
加上两个第五，这
是无论是遗留下来的。

343
00:20:07,590 --> 00:20:09,390
你总结起来，它是42。

344
00:20:09,390 --> 00:20:12,000
>> 有没有人困惑于我们如何得到呢？

345
00:20:12,000 --> 00:20:15,630
所以基本此外，像
我说，你应该确定。

346
00:20:15,630 --> 00:20:17,410
如果不是，那么，我们可以实践这一点。

347
00:20:17,410 --> 00:20:18,720
但是，这一切的权利。

348
00:20:18,720 --> 00:20:20,560
凉。

349
00:20:20,560 --> 00:20:25,570
>> 没有人想给我
回答第二个呢？

350
00:20:25,570 --> 00:20:26,860
>> 50？

351
00:20:26,860 --> 00:20:27,600
好。

352
00:20:27,600 --> 00:20:30,044
任何人都困惑于如何
我们得到了要么？

353
00:20:30,044 --> 00:20:31,960
酷，我将有
答案下一张幻灯片。

354
00:20:31,960 --> 00:20:34,440
如果让您无后顾之忧
需要复制下来。

355
00:20:34,440 --> 00:20:38,860
>> 好了，十六进制是一个有点棘手。

356
00:20:38,860 --> 00:20:41,840
但我要告诉你的家伙
对于如何做到这一点的快捷方式。

357
00:20:41,840 --> 00:20:44,800
所以十六进制，你
记住，所有这是是16。

358
00:20:44,800 --> 00:20:48,920
因为我们作为人类实际上并不
有16个数字来表示，

359
00:20:48,920 --> 00:20:56,940
我们从0到9，而我们的第一个
10的值，然后我们做A到F，

360
00:20:56,940 --> 00:20:58,630
这是接下来的六个值。

361
00:20:58,630 --> 00:21:03,040
>> 这样一来，最简单的方法从根本
任何二进制数为十六进制

362
00:21:03,040 --> 00:21:05,350
就是将它们分开成两部分。

363
00:21:05,350 --> 00:21:10,042
所以任何二进制数，我们会给
你可能会有八位数字。

364
00:21:10,042 --> 00:21:11,750
你可以只破
它们在中间。

365
00:21:11,750 --> 00:21:17,460
>> 所以第埃德蒙顿的一个，
一一，一，一，一一。

366
00:21:17,460 --> 00:21:21,340
有种想起来，你知道，画
斜线或它们之间的逗号。

367
00:21:21,340 --> 00:21:23,800
而且你可以只是转换
直接无论

368
00:21:23,800 --> 00:21:26,670
这是与第一
十六进制数，

369
00:21:26,670 --> 00:21:29,880
而无论这里是
十六进制的第二位。

370
00:21:29,880 --> 00:21:37,584
>> 因此，从通用符号记住，
做十六进制值开始是什么呢？

371
00:21:37,584 --> 00:21:38,460
>> 听众：零。

372
00:21:38,460 --> 00:21:39,270
>> 教授：0X。

373
00:21:39,270 --> 00:21:45,210
因此，我们知道，任何时候，我们问你
到任意数量转换为十六进制，

374
00:21:45,210 --> 00:21:48,230
或任何时候，你看不到任何
数以0x开始，

375
00:21:48,230 --> 00:21:50,230
你知道，这是一个十六进制值。

376
00:21:50,230 --> 00:21:54,160
>> 然后，你将被要求
确定这两个数字是。

377
00:21:54,160 --> 00:21:59,690
而你做的方式，总结出
一半和清点了一半。

378
00:21:59,690 --> 00:22:02,870
所以在这个例子中，什么
将一，一，一，一会？

379
00:22:02,870 --> 00:22:04,890
什么样的价值会是这样？

380
00:22:04,890 --> 00:22:06,040
这会是女，对不对？

381
00:22:06,040 --> 00:22:08,050
这会是15。

382
00:22:08,050 --> 00:22:11,780
>> 因此，这将是F.一，
一，一，人在这里也

383
00:22:11,780 --> 00:22:21,270
F.所以一，一，一，一，一，一，一，
之一，十六进制，全部是为0xFF。

384
00:22:21,270 --> 00:22:25,350
因为这一半代表
女，15的值，

385
00:22:25,350 --> 00:22:27,331
而这一半代表
F时，值15。

386
00:22:27,331 --> 00:22:29,456
因为记得，我们是
计数从0到9。

387
00:22:29,456 --> 00:22:35,290
A像10，B为11一样，F为15。

388
00:22:35,290 --> 00:22:41,690
>> 这是否有道理给大家如何
从我们得到的二进制十六进制？

389
00:22:41,690 --> 00:22:44,595
>> 听众：所以我们是怎么得到
15从一，一，一，一？

390
00:22:44,595 --> 00:22:46,220
教授：是的，这是二进制的，对不对？

391
00:22:46,220 --> 00:22:48,090
想象一下，这仅仅是一个二进制数。

392
00:22:48,090 --> 00:22:50,792
所以，你有两个到
零，这是其中之一。

393
00:22:50,792 --> 00:22:51,500
听众：哦，好。

394
00:22:51,500 --> 00:22:51,670
所以，你只要合计不出来。

395
00:22:51,670 --> 00:22:52,670
>> 教授：是的，然后
你刚才合计了这一点。

396
00:22:52,670 --> 00:22:53,380
这就是它。

397
00:22:53,380 --> 00:22:54,890
>> 听众：OK。

398
00:22:54,890 --> 00:22:55,830
>> 教授：OK。

399
00:22:55,830 --> 00:23:00,740
>> 听众：所以，如果你的二进制去
为十进制数为十六进制？

400
00:23:00,740 --> 00:23:04,590
>> 教授：这就是
最简单的方法，这样做，是的。

401
00:23:04,590 --> 00:23:11,390
你不会为十进制因为
十进制数只有0到9。

402
00:23:11,390 --> 00:23:13,410
我们只是种
这个分裂成两个。

403
00:23:13,410 --> 00:23:15,201
>> 听众：[听不清]
使用十进制找

404
00:23:15,201 --> 00:23:17,809
它匹配到十六进制什么。

405
00:23:17,809 --> 00:23:20,100
教授：我的意思是，你是
总结出利用基本的数学。

406
00:23:20,100 --> 00:23:20,725
听众：是的。

407
00:23:20,725 --> 00:23:22,300
教授：是啊，漂亮多了。

408
00:23:22,300 --> 00:23:23,630
这是一个有点混乱。

409
00:23:23,630 --> 00:23:26,410
但是，仅仅知道你
可以瓜分什么

410
00:23:26,410 --> 00:23:28,160
这个值是逼到一半。

411
00:23:28,160 --> 00:23:29,570
你看，这是什么二进制？

412
00:23:29,570 --> 00:23:30,610
什么号码是什么？

413
00:23:30,610 --> 00:23:33,270
这将是
事情从零到F.

414
00:23:33,270 --> 00:23:35,722
>> 这里也将是
事情从零到F.

415
00:23:35,722 --> 00:23:37,722
然后你可以把
这两个在那里。

416
00:23:37,722 --> 00:23:38,263
>> 听众：OK。

417
00:23:38,263 --> 00:23:38,910
教授：是的。

418
00:23:38,910 --> 00:23:39,410
好。

419
00:23:39,410 --> 00:23:42,320
所以你们要
尝试下一个呢？

420
00:23:42,320 --> 00:23:49,601
零，一，零壹，
1，零，一零。

421
00:23:49,601 --> 00:23:52,350
我给你们喜欢30秒
因为你可能不知道

422
00:23:52,350 --> 00:23:53,850
招要怎么做这点。

423
00:23:53,850 --> 00:24:24,950

424
00:24:24,950 --> 00:24:27,381
>> 好了，任何人都希望得到这一个镜头？

425
00:24:27,381 --> 00:24:28,774
>> 5AH即可。

426
00:24:28,774 --> 00:24:29,440
教授：5AH即可。

427
00:24:29,440 --> 00:24:30,470
5A。

428
00:24:30,470 --> 00:24:31,340
好。

429
00:24:31,340 --> 00:24:37,050
因此，这在这里将be--你想
告诉我们你是怎么得到的？

430
00:24:37,050 --> 00:24:38,920
首先，你怎么五个？

431
00:24:38,920 --> 00:24:42,030
>> 听众：因为零，
1，零个，一个是五。

432
00:24:42,030 --> 00:24:45,170
>> 教授：大家是否明白
为什么零，一，零个，一个是5？

433
00:24:45,170 --> 00:24:46,260
你有一个在这里。

434
00:24:46,260 --> 00:24:48,010
你有没有在两到第一。

435
00:24:48,010 --> 00:24:50,300
在二至第二，则
有一个，其为四。

436
00:24:50,300 --> 00:24:52,600
所以你加四加
一，您有五个。

437
00:24:52,600 --> 00:24:53,600
每个人都好？

438
00:24:53,600 --> 00:24:54,100
好。

439
00:24:54,100 --> 00:24:56,570
然后，这是什么，为什么？

440
00:24:56,570 --> 00:24:58,350
什么号码做了对应？

441
00:24:58,350 --> 00:24:59,350
>> 听众：10。

442
00:24:59,350 --> 00:25:00,976
>> 教授：而在基地二期这是什么？

443
00:25:00,976 --> 00:25:01,850
听众：[听不清]

444
00:25:01,850 --> 00:25:03,010
教授：没错。

445
00:25:03,010 --> 00:25:06,370
所以在这里第二个值是5AH即可。

446
00:25:06,370 --> 00:25:08,410
>> 大家好如何转换？

447
00:25:08,410 --> 00:25:10,770
这是一个简单了很多比你认为它是。

448
00:25:10,770 --> 00:25:13,330
我只是想确认
你知道有用的技巧

449
00:25:13,330 --> 00:25:14,950
和技巧如何做到这一点。

450
00:25:14,950 --> 00:25:18,432
>> 听众：为什么你只拆分
它在这样的中间？

451
00:25:18,432 --> 00:25:21,390
只要是这样，好吧，我只打算
关心这些第一[听不清]？

452
00:25:21,390 --> 00:25:24,240
>> 教授：因为这是真正的
这样的十六进制值表示。

453
00:25:24,240 --> 00:25:26,890
0X，这实际上意味着
没有什么比告诉你其他

454
00:25:26,890 --> 00:25:28,710
这是一个十六进制数。

455
00:25:28,710 --> 00:25:31,580
这始终代表
前四位数字。

456
00:25:31,580 --> 00:25:34,330
这始终代表
最后四位数字。

457
00:25:34,330 --> 00:25:37,835
所以，这两个数字只是
对应于不同比特。

458
00:25:37,835 --> 00:25:39,200
>> 听众：所以我们会always--

459
00:25:39,200 --> 00:25:41,830
>> 教授：你总是
要达到8位值。

460
00:25:41,830 --> 00:25:44,580
>> 听众：是，仅仅喜欢的事情
这里还是一个东西全？

461
00:25:44,580 --> 00:25:46,883
教授：这只是一个
在电脑的东西，是的。

462
00:25:46,883 --> 00:25:47,424
听众：OK。

463
00:25:47,424 --> 00:25:48,240
真棒。

464
00:25:48,240 --> 00:25:51,290
>> 教授：另外，因此在此示例
我们从二进制转换为十进制，

465
00:25:51,290 --> 00:25:53,290
从二进制为十六进制。

466
00:25:53,290 --> 00:25:56,610
你们想确保你也
练习周围走另一条路。

467
00:25:56,610 --> 00:26:03,370
所以，如果我给你0xFF时，你可以
得出了二进制，对吧？

468
00:26:03,370 --> 00:26:06,820
>> 您将˚F成二进制，
这是一，一，一，一，

469
00:26:06,820 --> 00:26:09,380
转换F到二进制，这
是一，一，一，一。

470
00:26:09,380 --> 00:26:11,310
>> 因此，我们可能会要求你做
另一种方式。

471
00:26:11,310 --> 00:26:14,817
因此，小数为二进制，或者
十六进制到二进制文件。

472
00:26:14,817 --> 00:26:16,650
所以，你想
一定要知道两者兼得。

473
00:26:16,650 --> 00:26:19,371
我们可能会问你一个
两者的结合。

474
00:26:19,371 --> 00:26:20,660
>> 是啊，你有问题吗？

475
00:26:20,660 --> 00:26:22,724
我可以see--你是好？

476
00:26:22,724 --> 00:26:23,348
听众：是的。

477
00:26:23,348 --> 00:26:24,560
教授：OK。

478
00:26:24,560 --> 00:26:26,101
我是好抹掉呢？

479
00:26:26,101 --> 00:26:26,600
大。

480
00:26:26,600 --> 00:26:33,965

481
00:26:33,965 --> 00:26:40,437
>> 好吧，那么答案在这里，如果有人
奇怪的是后来上感到困惑。

482
00:26:40,437 --> 00:26:41,844
好。

483
00:26:41,844 --> 00:26:46,070
>> 听众：它的问题，如果我们把
我们在国会大厦或小写字母？

484
00:26:46,070 --> 00:26:50,360
>> 教授：它确实是因为
十六进制，按照惯例，

485
00:26:50,360 --> 00:26:52,840
所有字符都大写。

486
00:26:52,840 --> 00:26:54,650
因此，A到F的
将是大写的。

487
00:26:54,650 --> 00:26:58,660
如果你把一个小写一个，我不知道
如果我们必然会将其标记为错误的。

488
00:26:58,660 --> 00:27:00,679
但理论上，
这不是技术上

489
00:27:00,679 --> 00:27:01,970
如何你应该有它。

490
00:27:01,970 --> 00:27:03,303
因此，他们都应该是大写的。

491
00:27:03,303 --> 00:27:05,910
是啊，好问题。

492
00:27:05,910 --> 00:27:07,780
>> 好。

493
00:27:07,780 --> 00:27:08,790
第二个问题。

494
00:27:08,790 --> 00:27:12,750
这里要考虑这个可爱的计划。

495
00:27:12,750 --> 00:27:15,180
我要问的问题，
我会回来这一点。

496
00:27:15,180 --> 00:27:23,170
>> 所以，第一，什么是标准的内
io.h这是感兴趣的项目？

497
00:27:23,170 --> 00:27:26,640
其次，什么是无效
表示在三线？

498
00:27:26,640 --> 00:27:30,572
第三，什么是无法返回零
主，如六号线，一般意味着什么？

499
00:27:30,572 --> 00:27:33,280
如果你们想写那些
下来，因为我要切换回

500
00:27:33,280 --> 00:27:36,810
以幻灯片只是让你可以看到代码。

501
00:27:36,810 --> 00:27:40,400
这是一样，也许是一个例子
更高层次的问题，我们要求你

502
00:27:40,400 --> 00:27:42,435
意味着一个节目是什么东西。

503
00:27:42,435 --> 00:27:47,290

504
00:27:47,290 --> 00:27:49,215
>> 每个人都对我好到
回到幻灯片？

505
00:27:49,215 --> 00:27:53,400

506
00:27:53,400 --> 00:27:54,361
嗯不错。

507
00:27:54,361 --> 00:27:57,610
所以，我给你们喜欢也许三
几分钟来看看这一个真正的快。

508
00:27:57,610 --> 00:28:41,330

509
00:28:41,330 --> 00:28:44,140
>> OK，所以这一块的像
相当容易，在概念上。

510
00:28:44,140 --> 00:28:49,280
没有人想告诉我什么是
首先通过内部哈希包括

511
00:28:49,280 --> 00:28:52,630
我们的标准io.h库文件？

512
00:28:52,630 --> 00:28:55,510
我们为什么需要该库
包括为这个计划？

513
00:28:55,510 --> 00:28:56,930
这里是什么我们需要它？

514
00:28:56,930 --> 00:28:56,980
>> 是吗？

515
00:28:56,980 --> 00:28:58,340
>> 听众：就是当
你把printf的？

516
00:28:58,340 --> 00:28:59,131
>> 教授：没错。

517
00:28:59,131 --> 00:29:01,780
所以printf的，任何时候你
取来自用户的输入

518
00:29:01,780 --> 00:29:04,140
和打印的东西
到屏幕上，这是

519
00:29:04,140 --> 00:29:05,600
标准输入，输出库。

520
00:29:05,600 --> 00:29:07,170
你可以把它的方式 - 输入，输出。

521
00:29:07,170 --> 00:29:08,430
>> 我有一个输出？

522
00:29:08,430 --> 00:29:09,207
是的，我愿意。

523
00:29:09,207 --> 00:29:12,040
所以，我知道，我总是会
需要标准化i.o库。

524
00:29:12,040 --> 00:29:16,400
>> 所以printf的是功能
由此我们需要访问

525
00:29:16,400 --> 00:29:19,370
和包括hashtag包括
标准i.o库。

526
00:29:19,370 --> 00:29:20,280
好。

527
00:29:20,280 --> 00:29:22,660
>> 其次，它是什么无效意味着什么？

528
00:29:22,660 --> 00:29:26,970
我们有INT主要（无效），哪些呢
在这里作废这里的意思三线？

529
00:29:26,970 --> 00:29:28,080
是啊，在后面。

530
00:29:28,080 --> 00:29:29,020
>> 听众：[听不清]

531
00:29:29,020 --> 00:29:29,920
>> 教授：没错。

532
00:29:29,920 --> 00:29:33,320
所以请记住，我们已经学会了
首先是我们的PSET

533
00:29:33,320 --> 00:29:35,360
实际上你可以
指定命令行

534
00:29:35,360 --> 00:29:39,010
论据，你的程序，你
主要功能，需要为你的用户，

535
00:29:39,010 --> 00:29:39,650
叫它。

536
00:29:39,650 --> 00:29:42,650
如果我们有空隙，这意味着你
可以只直接运行程序

537
00:29:42,650 --> 00:29:44,680
不带任何命令行参数。

538
00:29:44,680 --> 00:29:46,160
每个人都清楚这一点？

539
00:29:46,160 --> 00:29:46,660
好。

540
00:29:46,660 --> 00:29:52,850
>> 而最后为什么我们懒得做
这回零事儿吗？

541
00:29:52,850 --> 00:29:54,740
为什么我们甚至有一个int主？

542
00:29:54,740 --> 00:29:57,330
为什么我们不能只是有无效的主要无效？

543
00:29:57,330 --> 00:29:59,216
是吗？

544
00:29:59,216 --> 00:30:01,590
听众：为了让我们能
可以肯定的是，程序

545
00:30:01,590 --> 00:30:04,247
成功退出，如
相对于它是否被列。

546
00:30:04,247 --> 00:30:06,580
我们都知道，这是
不同类型的错误。

547
00:30:06,580 --> 00:30:07,621
>> 教授：是的，没错。

548
00:30:07,621 --> 00:30:10,670
这仅仅是一个很
常规的事情，我们做的，

549
00:30:10,670 --> 00:30:13,840
是，就在年底
你的程序，只是为了确保

550
00:30:13,840 --> 00:30:15,830
你的主要功能
运行正常，

551
00:30:15,830 --> 00:30:17,940
我们总是希望做回零。

552
00:30:17,940 --> 00:30:21,160
即使我们不一定
没有看到打印的任何地方。

553
00:30:21,160 --> 00:30:25,092
>> 因为作为程序员，你知道的，如果
你有很多不同的代码行

554
00:30:25,092 --> 00:30:27,050
你不知道在哪里
这些都走错了，

555
00:30:27,050 --> 00:30:30,240
如果发生错误的要
请确保你得到这个错误。

556
00:30:30,240 --> 00:30:33,240
所以，通常，如果出现
错了，我们将有一个返回一刚

557
00:30:33,240 --> 00:30:34,669
以确保我们知道它是。

558
00:30:34,669 --> 00:30:36,460
所以，如果你看一回
零，即通常

559
00:30:36,460 --> 00:30:38,293
意味着你的程序是
成功执行。

560
00:30:38,293 --> 00:30:40,490

561
00:30:40,490 --> 00:30:40,990
好？

562
00:30:40,990 --> 00:30:45,180

563
00:30:45,180 --> 00:30:45,680
凉。

564
00:30:45,680 --> 00:30:48,710

565
00:30:48,710 --> 00:30:52,680
>> 好了，下面第二个节目。

566
00:30:52,680 --> 00:30:54,827
考虑这一点。

567
00:30:54,827 --> 00:30:56,910
而且，如果你们看到一个
浮动，你们大概可以

568
00:30:56,910 --> 00:31:00,810
有一个很好的想法是什么
我要问你。

569
00:31:00,810 --> 00:31:05,200
>> 所以，当这个节目
执行，你可以看到，

570
00:31:05,200 --> 00:31:09,330
我声明一个浮点数
在我的主要功能。

571
00:31:09,330 --> 00:31:13,470
我将其命名为“回答，”而且我的设置
通过10，其等于一个分割。

572
00:31:13,470 --> 00:31:17,860
我打印出，一
小数位，即浮动。

573
00:31:17,860 --> 00:31:19,880
然后我回零。

574
00:31:19,880 --> 00:31:24,470
>> 所以在执行程序时，
回想起贪心现在，

575
00:31:24,470 --> 00:31:26,550
该程序将打印0.0。

576
00:31:26,550 --> 00:31:29,993
大家都知道，希望大家都
知道，一除以10不是0.00，

577
00:31:29,993 --> 00:31:32,350
它是0.1。

578
00:31:32,350 --> 00:31:37,810
但是，解释为什么这个方案认为
即1除以10打印0.1其他

579
00:31:37,810 --> 00:31:39,504
超过0.1？

580
00:31:39,504 --> 00:31:42,545
我给你们也许就像30
秒，只是快速地想想

581
00:31:42,545 --> 00:31:43,878
我会回去的计划。

582
00:31:43,878 --> 00:32:17,800

583
00:32:17,800 --> 00:32:20,290
>> 好。

584
00:32:20,290 --> 00:32:22,205
任何人想给它一个镜头？

585
00:32:22,205 --> 00:32:24,330
在三句话以内，
因为通常我们是

586
00:32:24,330 --> 00:32:27,650
要限制所有的答案
以三句话以内

587
00:32:27,650 --> 00:32:31,130
所以你不只是吐出
随机的东西到你的测验。

588
00:32:31,130 --> 00:32:32,740
>> 是的，采取了一枪。

589
00:32:32,740 --> 00:32:36,390
>> 听众：所以我觉得有这
所谓的，喜欢的东西，[听不清]

590
00:32:36,390 --> 00:32:42,320
所以有可能是，例如，
有可能是，象，0.09，

591
00:32:42,320 --> 00:32:47,250
但如你打印第一
位，这将是0.0？

592
00:32:47,250 --> 00:32:49,100
>> 教授：关闭，不完全是。

593
00:32:49,100 --> 00:32:49,810
Christabell？

594
00:32:49,810 --> 00:32:51,770
>> 听众：你把一和
10，他们俩都是整数。

595
00:32:51,770 --> 00:32:54,610
这样一来，方式，它是怎么回事
存储它是为一个整数。

596
00:32:54,610 --> 00:32:56,480
这样一来，最接近的整数将是0.0。

597
00:32:56,480 --> 00:32:57,471
所以这就是0.1。

598
00:32:57,471 --> 00:32:58,970
教授：是的，这是真的很好。

599
00:32:58,970 --> 00:33:00,040
这是正确的答案。

600
00:33:00,040 --> 00:33:03,597
所以这是一个非常混乱
概念很多孩子。

601
00:33:03,597 --> 00:33:06,680
我真的想确保
这是在每个人的头上加强。

602
00:33:06,680 --> 00:33:10,090
>> 因此，我们所说的浮动
点不精确，

603
00:33:10,090 --> 00:33:12,800
其中的原因有很多
在贪婪的程序

604
00:33:12,800 --> 00:33:17,010
没有工作，最初是因为
你忘了投你的变数。

605
00:33:17,010 --> 00:33:19,370
那么，什么Christabell说
是完全正确的。

606
00:33:19,370 --> 00:33:21,990
>> 一个浮点本质上是不准确的。

607
00:33:21,990 --> 00:33:26,400
因为在一台电脑，正确的，我们有
的存储器比特的有限数量

608
00:33:26,400 --> 00:33:28,480
我们可以用它来表示数字。

609
00:33:28,480 --> 00:33:33,480
因此，举例来说，此CS50 ID is--
我认为这是一个64位的计算机。

610
00:33:33,480 --> 00:33:37,520
>> 一个浮点只能代表
由这些比特的有限数量。

611
00:33:37,520 --> 00:33:42,260
所以0.1与无限的零，
这是0.1的，对不对？

612
00:33:42,260 --> 00:33:45,450
但是，我们不能真正存储
这个数字在我们的电脑。

613
00:33:45,450 --> 00:33:47,810
我们只是没有
足够的内存来这样做。

614
00:33:47,810 --> 00:33:52,340
>> 等的最近近似
什么是存储在内存中实际上是

615
00:33:52,340 --> 00:33:55,390
像0.000东西，
什么，什么，什么的。

616
00:33:55,390 --> 00:34:01,240
其中，一旦截断
它，几轮下来到0.0。

617
00:34:01,240 --> 00:34:05,640
>> 所以本实施例只是一个
这说明很多问题

618
00:34:05,640 --> 00:34:08,469
我们每当我们
尝试错误做数学

619
00:34:08,469 --> 00:34:11,000
而无需进行转换为不同的整数。

620
00:34:11,000 --> 00:34:14,870
所以才要警惕这种情况发生的。

621
00:34:14,870 --> 00:34:18,239
>> 在测验，如果我们给你
代码块，它的样子，

622
00:34:18,239 --> 00:34:19,510
什么打印出在结束了吗？

623
00:34:19,510 --> 00:34:24,096
如果它的一些随机值你
你们应该知道为什么会发生的事情。

624
00:34:24,096 --> 00:34:24,909
是吗？

625
00:34:24,909 --> 00:34:27,926
>> 听众：截断是摆脱
某一点后，一切吗？

626
00:34:27,926 --> 00:34:28,513
[听不清]

627
00:34:28,513 --> 00:34:30,929
教授：是的，所以实际上
这是一个非常坏的榜样，

628
00:34:30,929 --> 00:34:37,870
因为0.100无论实际
将截断下降到0.1。

629
00:34:37,870 --> 00:34:41,389
但是，如果你要运行它 - 我不知道
还记得，因为去年他们

630
00:34:41,389 --> 00:34:42,830
运行它在不同的程序。

631
00:34:42,830 --> 00:34:45,300
他们跑了一种叫做
在CS50电器，其

632
00:34:45,300 --> 00:34:46,389
是从ID不同。

633
00:34:46,389 --> 00:34:48,520
这是一个32位系统，我想。

634
00:34:48,520 --> 00:34:50,290
因此有不同的号码。

635
00:34:50,290 --> 00:34:53,330
>> 但实际上，只知道
截断的整个概念

636
00:34:53,330 --> 00:34:54,815
它只是如何削减的事情了。

637
00:34:54,815 --> 00:34:55,690
所以，如果它rounds--

638
00:34:55,690 --> 00:34:56,300
>> 听众：没有四舍五入。

639
00:34:56,300 --> 00:34:57,370
>> 教授：没错。

640
00:34:57,370 --> 00:34:57,870
是啊。

641
00:34:57,870 --> 00:35:02,330

642
00:35:02,330 --> 00:35:04,380
凉。

643
00:35:04,380 --> 00:35:05,250
>> 嗨，在后面。

644
00:35:05,250 --> 00:35:07,634
我们只是在看一些
测验复习题。

645
00:35:07,634 --> 00:35:08,430
>> 好吧。

646
00:35:08,430 --> 00:35:10,150
因此，这里要考虑一个不同的程序。

647
00:35:10,150 --> 00:35:12,797

648
00:35:12,797 --> 00:35:15,380
我想给你们一个
几分钟阅读过这一点。

649
00:35:15,380 --> 00:35:18,588
这是后话，这是一个非常
最近，我想吹了很多你

650
00:35:18,588 --> 00:35:19,142
人的头脑。

651
00:35:19,142 --> 00:35:21,100
但是，我们要谈
通过这又只是

652
00:35:21,100 --> 00:35:24,152
确保你
完全理解它。

653
00:35:24,152 --> 00:35:24,652
好。

654
00:35:24,652 --> 00:35:41,280

655
00:35:41,280 --> 00:35:41,780
好。

656
00:35:41,780 --> 00:35:44,342
任何人都需要更多的时间来
通过这个代码阅读？

657
00:35:44,342 --> 00:35:45,650
好。

658
00:35:45,650 --> 00:35:50,630
>> 因此，在我看来，
该程序中，我

659
00:35:50,630 --> 00:35:53,460
创建两个字符串使用的GetString。

660
00:35:53,460 --> 00:35:55,180
一位名为S和一个叫吨。

661
00:35:55,180 --> 00:35:58,680
如果他们是平等的
等于彼此

662
00:35:58,680 --> 00:36:00,880
它应该打印“你
键入同样的事情。“

663
00:36:00,880 --> 00:36:04,170
>> 但是elsewise，将打印，“你
输入不同的东西，“对不对？

664
00:36:04,170 --> 00:36:05,990
似乎非常，非常简单。

665
00:36:05,990 --> 00:36:08,720
但是，但是，如果我真的
尝试写这个程序，

666
00:36:08,720 --> 00:36:12,230
看来，即使我
输入完全相同的琴弦，

667
00:36:12,230 --> 00:36:15,490
它仍然打印出来，“你
输入不同的东西！“

668
00:36:15,490 --> 00:36:18,020
有谁要采取
射击为什么这个程序会

669
00:36:18,020 --> 00:36:20,370
响应该输入
是不同的，甚至

670
00:36:20,370 --> 00:36:22,090
当文字本身是一样的吗？

671
00:36:22,090 --> 00:36:24,870

672
00:36:24,870 --> 00:36:29,170
>> 所以，如果我是input--大卫·爱
用一个例子像妈妈，是吗？

673
00:36:29,170 --> 00:36:37,890
小写M-O-M的S，T
等于小写的M-O-M。

674
00:36:37,890 --> 00:36:40,340
如果说我是跑这
该代码，为什么会

675
00:36:40,340 --> 00:36:44,180
打印出“您输入不同的东西？”

676
00:36:44,180 --> 00:36:46,336
>> 有没有人需要更多的
时间去想呢？

677
00:36:46,336 --> 00:36:47,294
好吧，我想我们是很好的。

678
00:36:47,294 --> 00:36:48,716
是吗？

679
00:36:48,716 --> 00:36:53,930
>> 听众：好了，所以它的东西有关
在那里它存储在内存中，对不对？

680
00:36:53,930 --> 00:36:54,890
>> 教授：是的。

681
00:36:54,890 --> 00:37:00,400
>> 听众：当它像，如果这
字符串s存储在内存spot--

682
00:37:00,400 --> 00:37:01,689
我发明this--为零。

683
00:37:01,689 --> 00:37:02,355
教授：当然。

684
00:37:02,355 --> 00:37:05,290
听众：和串T
存储在内存现货，

685
00:37:05,290 --> 00:37:11,000
等，167，然后
零不等于167。

686
00:37:11,000 --> 00:37:12,610
>> 教授：没错。

687
00:37:12,610 --> 00:37:18,350
好了，记住这个令人难以置信
启示我们解释你们

688
00:37:18,350 --> 00:37:21,530
过去的这个星期，那
字符串不真的存在吗？

689
00:37:21,530 --> 00:37:25,380
当我们创建一些所谓的
字符串我们，在现实中，

690
00:37:25,380 --> 00:37:29,330
创造一种叫焦明星。

691
00:37:29,330 --> 00:37:34,470
所有这是一个指向
一个字符串或字符数组。

692
00:37:34,470 --> 00:37:39,480
>> 因此在这个例子中，如果我
要输入M-O-M的方式

693
00:37:39,480 --> 00:37:49,350
我的电脑会保存它
内存反斜线零之内，对不对？

694
00:37:49,350 --> 00:37:53,180
这四个字符，字符，
将存储在某个地方。

695
00:37:53,180 --> 00:37:59,290
>> 然后这四个
字符，反斜线零，

696
00:37:59,290 --> 00:38:01,275
存储别的地方，对不对？

697
00:38:01,275 --> 00:38:04,685
我不知道在哪里的地址
是，他们在我的电脑上的某个地方。

698
00:38:04,685 --> 00:38:07,080
但是，我并不确切地知道他们在哪里。

699
00:38:07,080 --> 00:38:10,170
>> 当我创建一个字符串
S，所有这确实是

700
00:38:10,170 --> 00:38:15,550
是一个指针，指向
启动这个字符串。

701
00:38:15,550 --> 00:38:21,130
当我创建这个吨价，
所有这些都是一个指向这里。

702
00:38:21,130 --> 00:38:23,980
所以，当你试图
划上等号，并检查

703
00:38:23,980 --> 00:38:27,710
看是否s是等于
等于T，计算机

704
00:38:27,710 --> 00:38:31,635
实际上只是回归
你这个M的地址

705
00:38:31,635 --> 00:38:33,390
且m的地址。

706
00:38:33,390 --> 00:38:36,230
而且因为他们是两个
独立的部分数据的

707
00:38:36,230 --> 00:38:38,750
存储在两个不同的
在您的计算机的地址，

708
00:38:38,750 --> 00:38:41,750
您的计算机永远不会
识别它们视为相同。

709
00:38:41,750 --> 00:38:43,500
有没有人要
给一个镜头一下我们

710
00:38:43,500 --> 00:38:46,900
必须做的，如果我们想纠正
这一点，有一个正确的正在运行的程序

711
00:38:46,900 --> 00:38:49,360
代替？

712
00:38:49,360 --> 00:38:52,070
想想看，一个几秒钟。

713
00:38:52,070 --> 00:38:54,929
我们究竟需要改变
得到这个程序运作

714
00:38:54,929 --> 00:38:56,220
我们希望它发挥作用的方式吗？

715
00:38:56,220 --> 00:39:17,260

716
00:39:17,260 --> 00:39:18,918
>> 是的，要采取刺伤它？

717
00:39:18,918 --> 00:39:24,082
>> 听众：我们可以尝试取消引用
指针和检查通过阵列？

718
00:39:24,082 --> 00:39:25,540
教授：这是做到这一点的方法之一。

719
00:39:25,540 --> 00:39:27,880
那么，你叫什么名字来着？

720
00:39:27,880 --> 00:39:29,010
对不起，提醒我。

721
00:39:29,010 --> 00:39:29,589
>> ZEE：ZEE。

722
00:39:29,589 --> 00:39:32,130
教授：是的，有什么Zee的
建议绝对会工作。

723
00:39:32,130 --> 00:39:32,629
对？

724
00:39:32,629 --> 00:39:35,730
我们可以取消引用指针
实际上去访问

725
00:39:35,730 --> 00:39:38,460
这里内部的物理数据。

726
00:39:38,460 --> 00:39:40,300
我们可以只是比较
整个屏幕。

727
00:39:40,300 --> 00:39:43,670
>> 我们可以说，OK，指针，
给我里面有什么在这里。

728
00:39:43,670 --> 00:39:44,960
它会返回一个m。

729
00:39:44,960 --> 00:39:47,168
我想说，指针，
给我里面有什么在这里。

730
00:39:47,168 --> 00:39:47,750
返回一个m。

731
00:39:47,750 --> 00:39:48,410
难道那些比赛？

732
00:39:48,410 --> 00:39:49,410
是。

733
00:39:49,410 --> 00:39:50,340
然后我们继续前进。

734
00:39:50,340 --> 00:39:54,240
>> 我们继续检查整双
字符串一路上扬，直到最后

735
00:39:54,240 --> 00:39:56,635
看看如果这些都是平等的，
如果所有的值是相等的。

736
00:39:56,635 --> 00:39:59,680
如果所有的值相等，
那么我们知道字符串是真实的。

737
00:39:59,680 --> 00:40:01,600
当然，这是我们如何做到这一点？

738
00:40:01,600 --> 00:40:03,930
>> 没有人感到困惑的任何的吗？

739
00:40:03,930 --> 00:40:06,970
如何将字符串的整个概念
其实只是指针，

740
00:40:06,970 --> 00:40:08,440
和他们怎么不真的存在吗？

741
00:40:08,440 --> 00:40:10,480
为什么我们得到的错误
就像我们得到它的方式吗？

742
00:40:10,480 --> 00:40:15,070
因为我保证你们，指针
和字符串分配和内存

743
00:40:15,070 --> 00:40:16,470
要上来了。

744
00:40:16,470 --> 00:40:17,410
>> 是吗？

745
00:40:17,410 --> 00:40:21,072
>> 听众：[听不清]提领
它，你只要把一个明星[听不清]

746
00:40:21,072 --> 00:40:21,780
教授：没错。

747
00:40:21,780 --> 00:40:28,430
因此，要derererence指针方式
去指示器的该地址

748
00:40:28,430 --> 00:40:30,390
将获得的数据时，值那里。

749
00:40:30,390 --> 00:40:32,700
而做到这一点的方法是明星的指针。

750
00:40:32,700 --> 00:40:34,262
不要混淆了。

751
00:40:34,262 --> 00:40:35,186
>> 听众：[听不清]。

752
00:40:35,186 --> 00:40:35,852
>> 教授：是的。

753
00:40:35,852 --> 00:40:39,750
听众：所以，你可以只写
如果明星享有平等平等明星吨。

754
00:40:39,750 --> 00:40:40,630
>> 教授：哦，不。

755
00:40:40,630 --> 00:40:40,960
没有。

756
00:40:40,960 --> 00:40:41,640
>> 听众：这是不够好，对不对？

757
00:40:41,640 --> 00:40:43,760
>> 教授：这不是，因为你
只检查的第一个字母。

758
00:40:43,760 --> 00:40:46,010
你可能会
需要某种循环的那

759
00:40:46,010 --> 00:40:49,055
通过每一个迭代
字符两个字符串。

760
00:40:49,055 --> 00:40:49,837
是啊。

761
00:40:49,837 --> 00:40:52,920
所以，如果你想只检查
如果他们开始使用同样的事情，

762
00:40:52,920 --> 00:40:58,220
如果，明星可以做
s等于星吨。

763
00:40:58,220 --> 00:41:01,300
然后，你知道，至少他们
开始使用相同的字符。

764
00:41:01,300 --> 00:41:01,952
>> 是吗？

765
00:41:01,952 --> 00:41:04,056
>> 听众：这样的方式
你这样做会

766
00:41:04,056 --> 00:41:06,064
像一个嵌入的for循环或指针？

767
00:41:06,064 --> 00:41:06,730
教授：是的。

768
00:41:06,730 --> 00:41:08,170
差不多就只有一个循环。

769
00:41:08,170 --> 00:41:12,430
请记住，大卫在课堂上提到的
免费的语法糖？

770
00:41:12,430 --> 00:41:17,690
而他有这个非常
明星的T令人困惑的事情

771
00:41:17,690 --> 00:41:22,030
加一，其中，将整合
通过它移动指针？

772
00:41:22,030 --> 00:41:29,910
这样做的更简单的方法
这是算了笔的我。

773
00:41:29,910 --> 00:41:31,090
>> 所以它只是一个数组。

774
00:41:31,090 --> 00:41:34,630
你会有一个对的方式
循环从零跑到我，在那里

775
00:41:34,630 --> 00:41:36,580
我是的长度
字符串，你可以只

776
00:41:36,580 --> 00:41:39,510
写的，而不是做
整个指针，引用的事。

777
00:41:39,510 --> 00:41:43,510
所以，这些事情是完全
相当于您的计算机。

778
00:41:43,510 --> 00:41:45,905
>> 你们可能不会
需要知道的是，

779
00:41:45,905 --> 00:41:48,280
但它的好，只是一种
在后面你的头脑。

780
00:41:48,280 --> 00:41:52,630
只要知道电脑
识别代码不同的块

781
00:41:52,630 --> 00:41:53,890
作为同样的事情。

782
00:41:53,890 --> 00:41:57,510
因为这仅仅是更为用户
友好的为我们展示它喜欢它的

783
00:41:57,510 --> 00:41:58,150
阵列。

784
00:41:58,150 --> 00:42:00,990
这只是更容易。

785
00:42:00,990 --> 00:42:02,719
>> 听众：所以使用strlen喜欢，get--

786
00:42:02,719 --> 00:42:03,385
教授：是的。

787
00:42:03,385 --> 00:42:03,926
听众：OK。

788
00:42:03,926 --> 00:42:05,940
教授：你可以
使用strlen或者，如果你

789
00:42:05,940 --> 00:42:10,420
没有strlen的，你可以做起来
直到你打反斜线零为。

790
00:42:10,420 --> 00:42:11,568
要么会工作。

791
00:42:11,568 --> 00:42:12,068
是啊。

792
00:42:12,068 --> 00:42:14,871

793
00:42:14,871 --> 00:42:17,996
听众：所以这是取消引用每
单个字符，如果我们实际上

794
00:42:17,996 --> 00:42:21,044
编写这些代码，我们
可能只是做T支架我

795
00:42:21,044 --> 00:42:22,460
喜欢跟在它前面的明星？

796
00:42:22,460 --> 00:42:27,700
>> 教授：是的，等于等于小号
支架我，然后继续前进我

797
00:42:27,700 --> 00:42:29,790
下来，直到你打到最后。

798
00:42:29,790 --> 00:42:31,286
啊，这是你会做什么。

799
00:42:31,286 --> 00:42:33,660
我会其实有下一个
实际例子中，我们当

800
00:42:33,660 --> 00:42:36,740
写的strlen所以你们会种
对得到它玩了一下周围。

801
00:42:36,740 --> 00:42:43,567
>> 那么，在刚刚内存大家清楚，
字符串，指针，质量地址？

802
00:42:43,567 --> 00:42:46,650
一些更高层次的概念，你
将肯定需要知道测验

803
00:42:46,650 --> 00:42:48,928
明天。

804
00:42:48,928 --> 00:42:49,904
>> 好吧。

805
00:42:49,904 --> 00:42:50,404
好。

806
00:42:50,404 --> 00:42:54,824

807
00:42:54,824 --> 00:42:55,324
是的。

808
00:42:55,324 --> 00:42:58,770

809
00:42:58,770 --> 00:43:04,180
好了，一件事，我们也会问
你，因为我们每年都会做一个测验，是，

810
00:43:04,180 --> 00:43:08,340
假设你已经忘记了（这
我们似乎忘记每年做）

811
00:43:08,340 --> 00:43:10,810
在头文件strlen的声明。

812
00:43:10,810 --> 00:43:13,860
因此，我们不得不重写它自己。

813
00:43:13,860 --> 00:43:16,350
>> 下面是指南列表
我们可以为您介绍

814
00:43:16,350 --> 00:43:20,660
男人，你去假设
S中的字符串不能为空。

815
00:43:20,660 --> 00:43:23,830
你可以假设旨意是
以反斜线结束零。

816
00:43:23,830 --> 00:43:26,670
所以，你知道那是什么
这将结束与。

817
00:43:26,670 --> 00:43:29,500
>> 及，例如，该
您好长度为五位。

818
00:43:29,500 --> 00:43:32,890
所以，你可以假设，你好
将有5，H-E-L-L-O。

819
00:43:32,890 --> 00:43:35,890
你不必假设
擦屁股零占的长度。

820
00:43:35,890 --> 00:43:39,720

821
00:43:39,720 --> 00:43:42,300
>> 这里这最后一件事，不
担心整数溢出。

822
00:43:42,300 --> 00:43:45,270
曾记否
什么整数溢出是？

823
00:43:45,270 --> 00:43:48,041
>> 听众：超越
的[听不清]的长度。

824
00:43:48,041 --> 00:43:50,740
>> 教授：是的，你能解释一下
了一下，这是什么意思？

825
00:43:50,740 --> 00:43:55,330
>> 听众：所以，我想它可以追溯到
前面的截断的例子。

826
00:43:55,330 --> 00:43:58,380
但是，如果你只有这么多的数字
超越比特数

827
00:43:58,380 --> 00:44:01,409
实际上你可以为它分配
那种它只是切断。

828
00:44:01,409 --> 00:44:04,242
教授：是啊，所以一个典型的
电脑，有多少位我们有吗？

829
00:44:04,242 --> 00:44:05,306
听众：32？

830
00:44:05,306 --> 00:44:06,430
教授：是的，32了吧。

831
00:44:06,430 --> 00:44:10,030
所以这是什么，四
十亿，二十亿？

832
00:44:10,030 --> 00:44:13,579
四十亿，最多四十亿
正整数，对不对？

833
00:44:13,579 --> 00:44:15,370
二十亿负，
的两个十亿积极的，

834
00:44:15,370 --> 00:44:16,900
要看你怎么想这样做。

835
00:44:16,900 --> 00:44:21,470
>> 所以，基本上我们可以有
足够的整数，可以上去

836
00:44:21,470 --> 00:44:25,800
两到第31减1，对吧？

837
00:44:25,800 --> 00:44:27,980
因为一旦我们打了两
第32届，我们不

838
00:44:27,980 --> 00:44:30,040
有那么多的记忆在我们的电脑。

839
00:44:30,040 --> 00:44:32,310
>> 因此，从理论上说，我
可以用一个数字来向上

840
00:44:32,310 --> 00:44:34,560
即，像，二至第46次。

841
00:44:34,560 --> 00:44:38,040
这是一个巨大的屁股数，但
理论上可以。

842
00:44:38,040 --> 00:44:42,730
所以，整数溢出是，如果你尝试
创建一个整数，超出了

843
00:44:42,730 --> 00:44:44,790
您的计算机能够存储。

844
00:44:44,790 --> 00:44:46,590
>> 所以你们的
本实施例不具有

845
00:44:46,590 --> 00:44:51,330
担心我们给你一个巨大的
字符串，它是两到第32个字符

846
00:44:51,330 --> 00:44:51,830
长。

847
00:44:51,830 --> 00:44:54,010
这将是真正的意思。

848
00:44:54,010 --> 00:44:59,430
>> 好吧，所以我只是想给
你们此基础结构。

849
00:44:59,430 --> 00:45:02,020
你要创建一个
所谓函数int strlen的，其中

850
00:45:02,020 --> 00:45:08,436
一通，一个char明星，或字符串，
指向字符串称为第

851
00:45:08,436 --> 00:45:10,820
>> 好吧，每个人都复制下来。

852
00:45:10,820 --> 00:45:13,550

853
00:45:13,550 --> 00:45:14,850
凉。

854
00:45:14,850 --> 00:45:17,020
Oops--其他方式。

855
00:45:17,020 --> 00:45:21,360
>> 因此，这是一种像
这块难问题，

856
00:45:21,360 --> 00:45:25,320
所以我给你们也许五到
六分钟那种头脑风暴

857
00:45:25,320 --> 00:45:27,478
写这个功能了。

858
00:45:27,478 --> 00:45:29,710
>> 听众：我们不
账户[听不清]

859
00:45:29,710 --> 00:45:30,200
我们不必使用整数？

860
00:45:30,200 --> 00:45:31,241
>> 教授：不，你没有。

861
00:45:31,241 --> 00:48:05,847

862
00:48:05,847 --> 00:48:06,930
我给你们一个提示。

863
00:48:06,930 --> 00:48:12,325
while循环可能会非常有用的在这里。

864
00:48:12,325 --> 00:48:12,825
是啊。

865
00:48:12,825 --> 00:48:44,995

866
00:48:44,995 --> 00:48:45,495
这里的

867
00:48:45,495 --> 00:48:45,995
糖果。

868
00:48:45,995 --> 00:48:49,980

869
00:48:49,980 --> 00:48:53,410
糖果也将是可利用
对于测验，我想。

870
00:48:53,410 --> 00:48:55,315
所以，你们将全部
加糖的明天。

871
00:48:55,315 --> 00:49:01,110

872
00:49:01,110 --> 00:49:02,962
可我 - 你得到它。

873
00:49:02,962 --> 00:49:03,718
>> 听众：OK。

874
00:49:03,718 --> 00:49:04,384
教授：是的。

875
00:49:04,384 --> 00:49:10,550

876
00:49:10,550 --> 00:49:11,870
>> 也许30秒钟左右。

877
00:49:11,870 --> 00:50:02,220

878
00:50:02,220 --> 00:50:07,340
>> 好吧，如果你
不这样做，无后顾之忧。

879
00:50:07,340 --> 00:50:08,810
我们将通过移动了一起。

880
00:50:08,810 --> 00:50:09,310
好。

881
00:50:09,310 --> 00:50:13,800
所以我要去刚刚布局
基本结构此功能在这里。

882
00:50:13,800 --> 00:50:17,255
诠释strlen的。

883
00:50:17,255 --> 00:50:20,040

884
00:50:20,040 --> 00:50:23,460
首先，没有人想告诉
我什么INT表示？

885
00:50:23,460 --> 00:50:25,160
我们需要有在此功能。

886
00:50:25,160 --> 00:50:26,709
>> 听众：STRLEN [听不清]。

887
00:50:26,709 --> 00:50:27,500
教授：没错。

888
00:50:27,500 --> 00:50:31,140
因此，在这里无论发生什么事情，
我们需要返回一个整数。

889
00:50:31,140 --> 00:50:36,367
和作为指定
规范，我们要return--

890
00:50:36,367 --> 00:50:37,700
为它去的家伙，只是继续前进。

891
00:50:37,700 --> 00:50:40,480
都很好。

892
00:50:40,480 --> 00:50:42,960
吃这一切，所以我没有
拿回来，其实。

893
00:50:42,960 --> 00:50:46,022

894
00:50:46,022 --> 00:50:48,855
通过int只是意味着你
将要返回一个整数。

895
00:50:48,855 --> 00:50:55,350

896
00:50:55,350 --> 00:50:57,106
>> 这是什么字符星级S'

897
00:50:57,106 --> 00:50:58,640
这意味着什么？

898
00:50:58,640 --> 00:51:00,879
>> 听众：喜欢，什么是投入研究。

899
00:51:00,879 --> 00:51:01,670
教授：没错。

900
00:51:01,670 --> 00:51:04,142
什么是差不多的
同样的事情为char明星？

901
00:51:04,142 --> 00:51:04,850
听众：字符串？

902
00:51:04,850 --> 00:51:05,641
教授：没错。

903
00:51:05,641 --> 00:51:09,080
因此，所有我们正在做的是给
这是一个指向字符串的指针。

904
00:51:09,080 --> 00:51:09,580
好。

905
00:51:09,580 --> 00:51:12,860

906
00:51:12,860 --> 00:51:13,360
凉。

907
00:51:13,360 --> 00:51:16,650
>> 另外，不要忘了，如果我们忘记了
给你这些支架，

908
00:51:16,650 --> 00:51:18,330
不要忘了给自己写。

909
00:51:18,330 --> 00:51:20,720
因为从理论上讲，你的代码是
如果你忘了把它们写不正确。

910
00:51:20,720 --> 00:51:21,803
只要时刻注意。

911
00:51:21,803 --> 00:51:23,750
象，小东西
你不通知

912
00:51:23,750 --> 00:51:26,917
当你编写你的笔记本电脑，
因为你的笔记本电脑会为你？

913
00:51:26,917 --> 00:51:28,624
不要忘记，当
你写的手。

914
00:51:28,624 --> 00:51:29,170
是吗？

915
00:51:29,170 --> 00:51:30,954
>> 听众：但如何不正确的？

916
00:51:30,954 --> 00:51:33,190
就像，我们得到了整个问题错了吗？

917
00:51:33,190 --> 00:51:34,190
>> 教授：没有，没有。

918
00:51:34,190 --> 00:51:34,860
不要担心。

919
00:51:34,860 --> 00:51:39,270
它实际上是理论上的可能
让你得到一个问题满点

920
00:51:39,270 --> 00:51:41,980
即使你的代码
从未在现实生活中运行。

921
00:51:41,980 --> 00:51:46,052
我建议你​​不要尝试
要做到这一点。

922
00:51:46,052 --> 00:51:48,260
例如，像如果一切
这是这里是正确的，

923
00:51:48,260 --> 00:51:51,850
但你忘了冒号或支架，
您的代码将不会运行。

924
00:51:51,850 --> 00:51:53,740
但是，我们可能是仁慈的。

925
00:51:53,740 --> 00:51:54,394
>> 是吗？

926
00:51:54,394 --> 00:51:56,050
>> 听众：你必须
我们的笔迹对此有何评论？

927
00:51:56,050 --> 00:51:57,758
>> 教授：不，不，不
有关后顾之忧。

928
00:51:57,758 --> 00:51:58,440
没有评论。

929
00:51:58,440 --> 00:51:59,400
风格应该是不错的。

930
00:51:59,400 --> 00:52:01,470
喜欢就不要斯马什
一切都在同一行。

931
00:52:01,470 --> 00:52:04,580
我们也不会开心
与你，如果你做到这一点。

932
00:52:04,580 --> 00:52:07,250
>> 有没有人要
给我的第一行？

933
00:52:07,250 --> 00:52:08,633
提示，这是非常容易的。

934
00:52:08,633 --> 00:52:09,320
>> 是吗？

935
00:52:09,320 --> 00:52:11,920
>> 听众：智力，正等于零。

936
00:52:11,920 --> 00:52:13,734
刚刚成立了柜台。

937
00:52:13,734 --> 00:52:15,900
教授：所以我们需要一些
这类反了吧？

938
00:52:15,900 --> 00:52:19,780
我只是将它命名为“算”
为了可读性。

939
00:52:19,780 --> 00:52:21,265
什么是我们想将它设置为？

940
00:52:21,265 --> 00:52:21,890
>> 听众：零。

941
00:52:21,890 --> 00:52:23,840
教授：是的。

942
00:52:23,840 --> 00:52:24,340
分号。

943
00:52:24,340 --> 00:52:26,250
这也是很奇怪的图纸分号。

944
00:52:26,250 --> 00:52:28,870
只是练习这样做。

945
00:52:28,870 --> 00:52:31,990
>> 因此，我们要首先
int类型的计数器。

946
00:52:31,990 --> 00:52:35,360
因为我们要计数如何
许多字符或字母

947
00:52:35,360 --> 00:52:36,780
在这个字符串，对不对？

948
00:52:36,780 --> 00:52:38,330
很容易的第一步。

949
00:52:38,330 --> 00:52:42,140
>> 好吧，也许有点更复杂
现在，我们怎么办呢？

950
00:52:42,140 --> 00:52:45,400
有没有人要
给我的代码行

951
00:52:45,400 --> 00:52:48,450
这或许能够帮助环
通过什么这是？

952
00:52:48,450 --> 00:52:54,540

953
00:52:54,540 --> 00:52:56,900
>> 是啊，在后面勇敢的灵魂？

954
00:52:56,900 --> 00:53:06,832
>> 听众：好了，而点
星号了呀，星号，

955
00:53:06,832 --> 00:53:09,465
不等于零，然后做什么？

956
00:53:09,465 --> 00:53:11,090
教授：这是真的，真的非常接近。

957
00:53:11,090 --> 00:53:11,835
真的很近。

958
00:53:11,835 --> 00:53:13,710
所以，我要解决
两件事情这一点。

959
00:53:13,710 --> 00:53:18,240
首先，它不完全为零。

960
00:53:18,240 --> 00:53:20,110
它是什么？

961
00:53:20,110 --> 00:53:22,550
这是空终止，
这是反斜线零。

962
00:53:22,550 --> 00:53:24,960
因此，他们在不同的
术语的他们是如何存储。

963
00:53:24,960 --> 00:53:26,270
所以，你真的很近。

964
00:53:26,270 --> 00:53:30,330
>> 其次，我们不希望
只是移动指针。

965
00:53:30,330 --> 00:53:32,320
我们要以实际
访问值，对不对？

966
00:53:32,320 --> 00:53:34,050
所以，我们怎么办呢？

967
00:53:34,050 --> 00:53:34,550
好简单。

968
00:53:34,550 --> 00:53:36,841
不要去想指针，
没有想到的回忆。

969
00:53:36,841 --> 00:53:38,525
回到本场的2星期

970
00:53:38,525 --> 00:53:39,555
>> 听众：[听不清]。

971
00:53:39,555 --> 00:53:40,680
教授：作为，还记得吗？

972
00:53:40,680 --> 00:53:41,400
什么是弦？

973
00:53:41,400 --> 00:53:42,650
他们是如何存储在内存中？

974
00:53:42,650 --> 00:53:43,300
>> 听众：他们提出的。

975
00:53:43,300 --> 00:53:43,810
>> 教授：他们提出。

976
00:53:43,810 --> 00:53:45,550
那么，如何才能获得
每个角色里面？

977
00:53:45,550 --> 00:53:46,466
>> 听众：[听不清]。

978
00:53:46,466 --> 00:53:47,530
教授：没错。

979
00:53:47,530 --> 00:53:53,195
所以while--发生的事情里面吗？

980
00:53:53,195 --> 00:53:54,940
为S  - 

981
00:53:54,940 --> 00:53:55,920
>> 听众：一。

982
00:53:55,920 --> 00:53:58,216
>> 教授：哦，我不存在，不是吗？

983
00:53:58,216 --> 00:53:59,620
>> 听众：哦，算什么？

984
00:53:59,620 --> 00:54:01,640
>> 教授：我们可以只
使用计数，我们不能？

985
00:54:01,640 --> 00:54:03,050
>> 听众：对不起，我把它叫做我。

986
00:54:03,050 --> 00:54:04,341
>> 教授：是的，这一切都很好。

987
00:54:04,341 --> 00:54:06,710

988
00:54:06,710 --> 00:54:10,760
我们有一个变量在这里这就是
已被宣布为我们的柜台。

989
00:54:10,760 --> 00:54:13,650
那么，为什么我们不使用
移动通过while循环？

990
00:54:13,650 --> 00:54:15,230
那有意义吗？

991
00:54:15,230 --> 00:54:20,864
>> 因此，尽管count--第有谁想
给我后，这里发生了什么？

992
00:54:20,864 --> 00:54:22,030
听众：这不等于。

993
00:54:22,030 --> 00:54:23,405
教授：不等于，对不对？

994
00:54:23,405 --> 00:54:26,200
这是爆炸等于，
感叹号等于，

995
00:54:26,200 --> 00:54:28,500
无论你们想
叫它不equal--

996
00:54:28,500 --> 00:54:29,496
>> 听众：[听不清]。

997
00:54:29,496 --> 00:54:30,990
>> 教授：是的。

998
00:54:30,990 --> 00:54:37,110
记住单引号是一个字符，
双引号是一个字符串。

999
00:54:37,110 --> 00:54:38,630
在使用它们时要小心。

1000
00:54:38,630 --> 00:54:42,430
所以，当我们正在寻找通过
阵列，最后一个字符，

1001
00:54:42,430 --> 00:54:46,420
我们知道我们不希望
它是反斜线为零。

1002
00:54:46,420 --> 00:54:47,340
>> 因此，虽然。

1003
00:54:47,340 --> 00:54:48,840
我们不是在字符串的结尾。

1004
00:54:48,840 --> 00:54:52,335
什么是我们想要做的里面？

1005
00:54:52,335 --> 00:54:55,269
>> 听众：我们要添加到
计数器所以它计数加上加？

1006
00:54:55,269 --> 00:54:56,060
教授：没错。

1007
00:54:56,060 --> 00:55:03,064
所以在这里，我们要做的
计数，计数加再加。

1008
00:55:03,064 --> 00:55:03,980
缺少下一行。

1009
00:55:03,980 --> 00:55:05,090
我们快到了。

1010
00:55:05,090 --> 00:55:07,398
什么是我们忘了怎么办？

1011
00:55:07,398 --> 00:55:08,770
>> 听众：返回零？

1012
00:55:08,770 --> 00:55:10,820
>> 教授：你想回到零？

1013
00:55:10,820 --> 00:55:12,962
>> 听众：没有，返回的strlen。

1014
00:55:12,962 --> 00:55:13,511
等待。

1015
00:55:13,511 --> 00:55:14,760
教授：存储在？

1016
00:55:14,760 --> 00:55:15,090
听众：计数。

1017
00:55:15,090 --> 00:55:15,589
计数。

1018
00:55:15,589 --> 00:55:17,150
教授：没错。

1019
00:55:17,150 --> 00:55:20,760
所以在这里我们要返回计数。

1020
00:55:20,760 --> 00:55:23,450

1021
00:55:23,450 --> 00:55:25,380
>> 因为我们是
在这里做ultimately--

1022
00:55:25,380 --> 00:55:29,780
我们有一个计数器变量那
要通过增加我们的字符串。

1023
00:55:29,780 --> 00:55:33,050
我们要继续前进，保持
去，一圈又一圈在这个循环。

1024
00:55:33,050 --> 00:55:37,700
虽然我们不是在本月底
字符串，它是空终止。

1025
00:55:37,700 --> 00:55:40,410
>> 我们每次经过的时间
它，我们加入到我们的专柜。

1026
00:55:40,410 --> 00:55:42,640
而且我们要进一步
沿着这个数组。

1027
00:55:42,640 --> 00:55:44,880
而在最后，一旦我们
打空终结，

1028
00:55:44,880 --> 00:55:48,469
我们知道，哦，我们可以
打破，返回计数。

1029
00:55:48,469 --> 00:55:49,260
我们有我们的strlen。

1030
00:55:49,260 --> 00:55:52,280

1031
00:55:52,280 --> 00:55:56,400
>> 是否每个人都得到如何
这是实施？

1032
00:55:56,400 --> 00:55:58,830
虽然loops--我知道我们有没有
做了太多的他们，

1033
00:55:58,830 --> 00:56:01,240
但它们通常
如果你非常非常有用

1034
00:56:01,240 --> 00:56:05,390
不知道你在什么停止
条件不一定必须是。

1035
00:56:05,390 --> 00:56:06,220
>> 题？

1036
00:56:06,220 --> 00:56:10,080
>> 听众：我们可以写空
在while条件？

1037
00:56:10,080 --> 00:56:10,940
>> 教授：当？

1038
00:56:10,940 --> 00:56:15,304
是啊，所以这个问题我有你
球员认为旨意不能为空。

1039
00:56:15,304 --> 00:56:17,220
因为记得，
从理论上说，如果我给你

1040
00:56:17,220 --> 00:56:21,180
一个指针，过大的内存，
它会给你空了吧？

1041
00:56:21,180 --> 00:56:23,770
这就是操作
系统会做。

1042
00:56:23,770 --> 00:56:26,960
>> 所以，如果我没告诉你承担
s就为空，则需要检查。

1043
00:56:26,960 --> 00:56:32,050
所以在这里，你会怎么做，如果s
等于等于空，返回之一。

1044
00:56:32,050 --> 00:56:33,028
类似的东西。

1045
00:56:33,028 --> 00:56:34,153
听众：[听不清]为零。

1046
00:56:34,153 --> 00:56:37,287

1047
00:56:37,287 --> 00:56:39,370
教授：好的，我会告诉
你为什么我们不能这样做。

1048
00:56:39,370 --> 00:56:43,357
因为记得在内存中，正确的，在这里。

1049
00:56:43,357 --> 00:56:43,940
我们会去这里。

1050
00:56:43,940 --> 00:56:49,940

1051
00:56:49,940 --> 00:56:54,090
>> 你有巨大的块
内存的所有使用网格

1052
00:56:54,090 --> 00:56:56,680
那家店不同的价值观，对不对？

1053
00:56:56,680 --> 00:57:00,110
因此所有的字符串is--为
例如，如果我们要输入你好，

1054
00:57:00,110 --> 00:57:05,490
这将是H-E-L-L-O
反斜杠零，对不对？

1055
00:57:05,490 --> 00:57:09,570
然后谁知道，就像是随机的
东西都是在这里经过了。

1056
00:57:09,570 --> 00:57:11,220
>> 我们真的不知道那里的东西。

1057
00:57:11,220 --> 00:57:13,350
所以，如果你做的
而不是反斜杠零，

1058
00:57:13,350 --> 00:57:15,590
空，但不可以为null。

1059
00:57:15,590 --> 00:57:17,680
因为它只是意味着
一些随机其他的东西

1060
00:57:17,680 --> 00:57:19,270
不属于在字符串中。

1061
00:57:19,270 --> 00:57:23,219
这样一来，方式，我们一直都知道
一个字符串结尾是用反斜杠零。

1062
00:57:23,219 --> 00:57:25,760
所以这总是我们如何
检查以查看一个字符串的末尾。

1063
00:57:25,760 --> 00:57:30,820
>> 空，一切也就意味着，如果你有
一个不存在的指针，首先，

1064
00:57:30,820 --> 00:57:36,160
或者如果你的内存仅仅是如此之大，
你不能返回，那么这将会是零。

1065
00:57:36,160 --> 00:57:40,150
因此，差异化的时候要非常小心
空之间的差

1066
00:57:40,150 --> 00:57:42,130
和反斜线零。

1067
00:57:42,130 --> 00:57:43,670
是啊。

1068
00:57:43,670 --> 00:57:46,886
>> 每个人都用这个好不好？

1069
00:57:46,886 --> 00:57:48,150
好。

1070
00:57:48,150 --> 00:57:50,440
>> 所以，我有你们的strlen写出来的。

1071
00:57:50,440 --> 00:57:53,790
切实我们也可以问你写的
从A到我，请记住，“Atwoa”

1072
00:57:53,790 --> 00:57:55,400
或不管你们怎么称呼它？

1073
00:57:55,400 --> 00:57:58,010
该函数
的Vigenere和恺撒，这

1074
00:57:58,010 --> 00:58:00,900
转换成ASCII值的整数？

1075
00:58:00,900 --> 00:58:04,360
这也已经拿出了以往的测验
功能我们要求你写。

1076
00:58:04,360 --> 00:58:08,280
>> 几乎所有的功能
你已经使用，是

1077
00:58:08,280 --> 00:58:11,660
很容易写自己，
传感器，如低，

1078
00:58:11,660 --> 00:58:14,620
为上，以降低，到上层。

1079
00:58:14,620 --> 00:58:17,964
功能，将转换
从小写的字符串为大写。

1080
00:58:17,964 --> 00:58:19,380
我们都知道该怎么做了吧？

1081
00:58:19,380 --> 00:58:21,100
这是很容易的。

1082
00:58:21,100 --> 00:58:24,770
只是想确保你
can--它是相同的思维过程。

1083
00:58:24,770 --> 00:58:26,940
你只要通过迭代
你扭转乾坤。

1084
00:58:26,940 --> 00:58:30,190
你要么计数或当
你把不同的事情。

1085
00:58:30,190 --> 00:58:32,280
>> 我会suggest--我
不知道，如果我们要

1086
00:58:32,280 --> 00:58:39,080
请你记住什么资本A或
资本Z或小写字母A或小写

1087
00:58:39,080 --> 00:58:42,640
z是在ASCII，但我会建议
也许写下来的情况下，

1088
00:58:42,640 --> 00:58:44,124
我们的确是。

1089
00:58:44,124 --> 00:58:45,540
只是让你们有一个参考。

1090
00:58:45,540 --> 00:58:47,180
像大写字母A是什么，197？

1091
00:58:47,180 --> 00:58:51,320
然后小写就像50的东西。

1092
00:58:51,320 --> 00:58:52,492
65，是啊，你去那里。

1093
00:58:52,492 --> 00:58:54,950
所以才非常了解
它们之间的区别是32。

1094
00:58:54,950 --> 00:58:57,670
这是非常重要的。

1095
00:58:57,670 --> 00:58:58,170
是啊。

1096
00:58:58,170 --> 00:59:01,445
我是好上呢？

1097
00:59:01,445 --> 00:59:01,945
好。

1098
00:59:01,945 --> 00:59:03,109
>> 听众：我们可以
理论上写一些

1099
00:59:03,109 --> 00:59:04,410
这些下降，以及对我们的little--

1100
00:59:04,410 --> 00:59:07,035
>> 教授：你从理论上
可以只复制功能下降。

1101
00:59:07,035 --> 00:59:08,482
确实如此。

1102
00:59:08,482 --> 00:59:11,080
>> 听众：不[听不清]。

1103
00:59:11,080 --> 00:59:12,720
>> 教授：你们有一个表。

1104
00:59:12,720 --> 00:59:14,194
你们有一个笔记纸。

1105
00:59:14,194 --> 00:59:14,860
您可以键入它。

1106
00:59:14,860 --> 00:59:15,490
你可以把它写。

1107
00:59:15,490 --> 00:59:17,031
你可以做任何你想做的事情。

1108
00:59:17,031 --> 00:59:18,530
是啊。

1109
00:59:18,530 --> 00:59:21,406
因此从理论上说，如果
你想，去的。

1110
00:59:21,406 --> 00:59:23,338
>> 听众：[听不清]
但我们真的不

1111
00:59:23,338 --> 00:59:25,994
一定要记住
值，我们可以只

1112
00:59:25,994 --> 00:59:28,914
使用于上或
较低的功能，对不对？

1113
00:59:28,914 --> 00:59:29,580
教授：是的。

1114
00:59:29,580 --> 00:59:32,740
但是，如果我们给你个问题
上面写着写上，

1115
00:59:32,740 --> 00:59:34,350
那么你就需要把它写。

1116
00:59:34,350 --> 00:59:38,150
所以你们可以假设你
人可以访问所有功能，

1117
00:59:38,150 --> 00:59:41,523
但如果你要使用上或
较低的，你怎么还可以做什么？

1118
00:59:41,523 --> 00:59:43,840
>> 听众：[听不清]
使用CS50 [听不清]

1119
00:59:43,840 --> 00:59:44,840
>> 教授：是不是CS50.h？

1120
00:59:44,840 --> 00:59:47,320

1121
00:59:47,320 --> 00:59:48,310
要小心在那里。

1122
00:59:48,310 --> 00:59:50,640
>> 所以要上，以降低，
为上，较低，

1123
00:59:50,640 --> 00:59:52,990
涉及功能
字符串操作是

1124
00:59:52,990 --> 00:59:55,490
所有在任一ASCII码
或数学库中

1125
00:59:55,490 --> 00:59:57,350
或串库中。

1126
00:59:57,350 --> 01:00:00,290
所以，如果你们使用那些
功能，小心要记住

1127
01:00:00,290 --> 01:00:01,451
以包括报头。

1128
01:00:01,451 --> 01:00:03,950
因此，或许也未尝您
希望在您的工作表，包括，

1129
01:00:03,950 --> 01:00:04,892
什么是头？

1130
01:00:04,892 --> 01:00:06,600
什么是图书馆
你一直在使用？

1131
01:00:06,600 --> 01:00:08,550
什么功能
里面那些库？

1132
01:00:08,550 --> 01:00:09,230
这一点很重要。

1133
01:00:09,230 --> 01:00:10,420
>> 是吗？

1134
01:00:10,420 --> 01:00:12,570
>> 听众：我们能不能​​只
警察出去做包括hashtag

1135
01:00:12,570 --> 01:00:14,955
通过绝对
每次我们有生以来信

1136
01:00:14,955 --> 01:00:17,340
见过像所有的问题吗？

1137
01:00:17,340 --> 01:00:18,320
>> 教授：你可以。

1138
01:00:18,320 --> 01:00:20,361
我不知道有多开心
我们要成为等级

1139
01:00:20,361 --> 01:00:25,090
该测验时每一段代码
是两倍长它需要。

1140
01:00:25,090 --> 01:00:27,200
我不知道，我们可能
腾飞点的风格。

1141
01:00:27,200 --> 01:00:28,790
但理论上你
代码将是正确的。

1142
01:00:28,790 --> 01:00:30,915
你们能警察出来，
只包含一切。

1143
01:00:30,915 --> 01:00:32,044
这是一件好事，是的。

1144
01:00:32,044 --> 01:00:32,960
听众：[听不清]。

1145
01:00:32,960 --> 01:00:33,270
教授：是的。

1146
01:00:33,270 --> 01:00:34,900
我建议不这样做，虽然。

1147
01:00:34,900 --> 01:00:35,505
是啊。

1148
01:00:35,505 --> 01:00:36,130
听众：酷。

1149
01:00:36,130 --> 01:00:36,620
教授：这个问题问得好。

1150
01:00:36,620 --> 01:00:37,480
听众：所以，最坏的情况。

1151
01:00:37,480 --> 01:00:38,563
教授：在最坏的情况下。

1152
01:00:38,563 --> 01:00:40,350
如果你完全忘记了，
你能做到这一点。

1153
01:00:40,350 --> 01:00:40,850
是啊。

1154
01:00:40,850 --> 01:00:43,870

1155
01:00:43,870 --> 01:00:45,400
>> 是的，代码就在这里。

1156
01:00:45,400 --> 01:00:49,176
我使用的n个，而不是计数，但你
知道的，不管你的船浮筒。

1157
01:00:49,176 --> 01:00:51,092
听众：等等，所以我们
就不必＃标签

1158
01:00:51,092 --> 01:00:53,460
包括因为我们
在开始的诠释？

1159
01:00:53,460 --> 01:00:56,150

1160
01:00:56,150 --> 01:00:59,924
>> 教授：是的，我只是假设
我们被要求写的功能。

1161
01:00:59,924 --> 01:01:02,340
如果你想成为安全起见，你
也许可以把它放在那里。

1162
01:01:02,340 --> 01:01:05,650
但我只是没有理会，是的。

1163
01:01:05,650 --> 01:01:09,919
>> 我甚至不知道你
不需要任何库这一点。

1164
01:01:09,919 --> 01:01:12,710
因为你没有真正打印
出任何事或任何东西，对不对？

1165
01:01:12,710 --> 01:01:16,500

1166
01:01:16,500 --> 01:01:19,568
是啊，我不知道
你需要一个图书馆。

1167
01:01:19,568 --> 01:01:22,400
>> 好。

1168
01:01:22,400 --> 01:01:26,020
这也是多一点沿
对内存的处理线。

1169
01:01:26,020 --> 01:01:27,400
这种有点棘手了。

1170
01:01:27,400 --> 01:01:28,960
想想这一点。

1171
01:01:28,960 --> 01:01:30,580
你有一个叫做FUNC功能。

1172
01:01:30,580 --> 01:01:33,570
我可以把它命名什么的，
但我选择FUNC命名。

1173
01:01:33,570 --> 01:01:36,000
我有我上面的主力。

1174
01:01:36,000 --> 01:01:39,790
请记住，你想拥有
主后的函数，

1175
01:01:39,790 --> 01:01:42,370
你要确保你
包括顶的雏形。

1176
01:01:42,370 --> 01:01:45,750
>> 但在这种情况下，它是如此之短
我觉得我可以只

1177
01:01:45,750 --> 01:01:47,260
包括它上盖的主。

1178
01:01:47,260 --> 01:01:51,170
我并不需要有原型的，
因为它已经上面写的。

1179
01:01:51,170 --> 01:01:55,430
因此，所有我做我的主要功能
正在创建整数x等于10。

1180
01:01:55,430 --> 01:02:00,490
我打电话给我的FUNC功能，
然后打印一些东西。

1181
01:02:00,490 --> 01:02:02,840
>> 然后这实际上
什么FUNC做。

1182
01:02:02,840 --> 01:02:04,340
你们要思考这一点。

1183
01:02:04,340 --> 01:02:05,423
因为它是一个有点棘手。

1184
01:02:05,423 --> 01:02:07,220
这是非常，非常棘手，其实。

1185
01:02:07,220 --> 01:02:09,549
想通过这是什么
程序会输出。

1186
01:02:09,549 --> 01:02:10,840
我给你们两分钟。

1187
01:02:10,840 --> 01:03:36,660

1188
01:03:36,660 --> 01:03:37,891
>> 良好的讨论？

1189
01:03:37,891 --> 01:03:38,853
>> 听众：是的。

1190
01:03:38,853 --> 01:03:39,815
>> 教授：是的。

1191
01:03:39,815 --> 01:03:42,220
好了，所以这是
棘手的一个原因。

1192
01:03:42,220 --> 01:03:44,845
这就是为什么我想带
这对大家的关注。

1193
01:03:44,845 --> 01:03:47,870

1194
01:03:47,870 --> 01:03:51,147
没有人想给我
一个建议，企图？

1195
01:03:51,147 --> 01:03:52,230
什么会这样打印出来？

1196
01:03:52,230 --> 01:03:53,930
如果你错了完全罚款。

1197
01:03:53,930 --> 01:03:55,619
是吗？

1198
01:03:55,619 --> 01:03:59,483
>> 观众：我认为这是100和
然后在两个10分开行。

1199
01:03:59,483 --> 01:04:00,940
>> 教授：和一个10？

1200
01:04:00,940 --> 01:04:03,154
没有人有任何其他的猜测？

1201
01:04:03,154 --> 01:04:04,150
是吗？

1202
01:04:04,150 --> 01:04:09,040
>> 听众：也许只是10，因为
FUNC没有返回什么？

1203
01:04:09,040 --> 01:04:11,610
>> 教授：好了，我们
有猜测头号

1204
01:04:11,610 --> 01:04:14,990
是猜数二是
只是要打印出10。

1205
01:04:14,990 --> 01:04:17,623
没有人有任何其他的猜测？

1206
01:04:17,623 --> 01:04:19,654
好。

1207
01:04:19,654 --> 01:04:21,070
因此，让我们穿行这一点，对不对？

1208
01:04:21,070 --> 01:04:23,903
每当你得到一段代码，
不只是看它和像，

1209
01:04:23,903 --> 01:04:25,060
啊，那这么多东西！

1210
01:04:25,060 --> 01:04:26,460
我很困惑！

1211
01:04:26,460 --> 01:04:28,220
像，让自己平静下来。

1212
01:04:28,220 --> 01:04:31,602
只要知道你可以只
期待通过代码一行行。

1213
01:04:31,602 --> 01:04:32,310
这就是它。

1214
01:04:32,310 --> 01:04:33,840
这就像读一本书。

1215
01:04:33,840 --> 01:04:38,000
>> 因此，与任何功能，
我们总是从主。

1216
01:04:38,000 --> 01:04:40,860
所以，我们要
开始INT主要无效，

1217
01:04:40,860 --> 01:04:43,010
即使该程序的
已经办下来了吧？

1218
01:04:43,010 --> 01:04:45,070
开始在主无效。

1219
01:04:45,070 --> 01:04:48,030
诠释x等于10。

1220
01:04:48,030 --> 01:04:50,400
>> 所以，我要删除这一点。

1221
01:04:50,400 --> 01:04:55,179

1222
01:04:55,179 --> 01:04:58,470
我要画的内存，所以您
样的人能看到发生了什么。

1223
01:04:58,470 --> 01:05:02,190
>> 记得到这里，我们有我们的堆栈？

1224
01:05:02,190 --> 01:05:05,810
在这里，我们有我们的
热闹的地方在这里。

1225
01:05:05,810 --> 01:05:07,470
堆栈长大，对不对？

1226
01:05:07,470 --> 01:05:10,150
而在栈中，你有
电源的功能，以及

1227
01:05:10,150 --> 01:05:12,230
所有电源局部变量。

1228
01:05:12,230 --> 01:05:14,310
>> 所以在这里，诠释x等于10。

1229
01:05:14,310 --> 01:05:17,670
在我们的主函数我们
创建了一个变量x。

1230
01:05:17,670 --> 01:05:20,590
我们设置了等于10。

1231
01:05:20,590 --> 01:05:24,200
在这里，你有一些x和你
设置这等于10，没错，

1232
01:05:24,200 --> 01:05:25,400
内为主。

1233
01:05:25,400 --> 01:05:27,430
每个人都好？

1234
01:05:27,430 --> 01:05:28,070
>> 功能。

1235
01:05:28,070 --> 01:05:30,330
所以，现在，我们的主要内
功能，我们称之为

1236
01:05:30,330 --> 01:05:31,810
我们已经写了上面的功能。

1237
01:05:31,810 --> 01:05:34,550
所以，我们现在进入了第二个功能。

1238
01:05:34,550 --> 01:05:40,120
我们要创建另一个
变量int x等于100。

1239
01:05:40,120 --> 01:05:42,410
这里发生的堆栈？

1240
01:05:42,410 --> 01:05:46,980
当你调用一个会发生什么
函数创建新的变量？

1241
01:05:46,980 --> 01:05:50,038
在堆在这里发生了什么？

1242
01:05:50,038 --> 01:05:52,134
>> 听众：[听不清]堆在上面？

1243
01:05:52,134 --> 01:05:52,800
教授：是的。

1244
01:05:52,800 --> 01:05:54,050
因此，它实际上创建了一个副本。

1245
01:05:54,050 --> 01:05:56,560

1246
01:05:56,560 --> 01:05:57,740
它种在上面桩。

1247
01:05:57,740 --> 01:06:00,700
想想stack--一叠
书，一叠任何东西。

1248
01:06:00,700 --> 01:06:06,520
桩之上，先在上
出，后进先出。

1249
01:06:06,520 --> 01:06:08,471
>> 因此，这将在这里打造一个x。

1250
01:06:08,471 --> 01:06:12,080

1251
01:06:12,080 --> 01:06:14,450
>> 这将有
所有funcs中的变量。

1252
01:06:14,450 --> 01:06:14,950
大。

1253
01:06:14,950 --> 01:06:20,980
所以，现在我们有两个不同的x的是
代表了两种不同的事物。

1254
01:06:20,980 --> 01:06:24,470
然后我们要打印
出x的整数。

1255
01:06:24,470 --> 01:06:26,430
因此，让我们打印100，对吧？

1256
01:06:26,430 --> 01:06:29,389
因为这里是100。

1257
01:06:29,389 --> 01:06:31,680
所以这是第一件事情
这是怎么回事打印出来。

1258
01:06:31,680 --> 01:06:35,710
由于此函数返回什么，
既然功能，主要是线

1259
01:06:35,710 --> 01:06:37,070
已经完成了。

1260
01:06:37,070 --> 01:06:39,160
大家好我这么远吗？

1261
01:06:39,160 --> 01:06:43,034
>> 所以我们现在是通过两个出
三行我们的主要功能。

1262
01:06:43,034 --> 01:06:44,450
现在，我们要在第三行。

1263
01:06:44,450 --> 01:06:46,350
我们要去给printf。

1264
01:06:46,350 --> 01:06:48,222
什么是主内该X？

1265
01:06:48,222 --> 01:06:49,263
这是什么代表什么呢？

1266
01:06:49,263 --> 01:06:52,720

1267
01:06:52,720 --> 01:06:54,280
>> 什么值为x呢？

1268
01:06:54,280 --> 01:06:55,220
>> 听众：100。

1269
01:06:55,220 --> 01:06:56,799
>> 教授：这是100？

1270
01:06:56,799 --> 01:06:57,590
听众：仍有10。

1271
01:06:57,590 --> 01:06:58,878
教授：还是10。

1272
01:06:58,878 --> 01:07:00,870
是啊。

1273
01:07:00,870 --> 01:07:06,810
因为还记得，在
我们的FUNC，x等于100。

1274
01:07:06,810 --> 01:07:09,690
但是，如果我们返回
我们的主要功能，

1275
01:07:09,690 --> 01:07:12,440
该变量被存储在一个
不同的地方，我们的堆栈。

1276
01:07:12,440 --> 01:07:16,250
>> 所以，现在我们需要回到
主堆栈，电源局部变量。

1277
01:07:16,250 --> 01:07:18,460
和这里x等于10。

1278
01:07:18,460 --> 01:07:20,300
所以，我们要打印出10。

1279
01:07:20,300 --> 01:07:22,530
>> 于是，她是绝对正确的。

1280
01:07:22,530 --> 01:07:25,053
我们将有
输出的100和10。

1281
01:07:25,053 --> 01:07:25,553
是吗？

1282
01:07:25,553 --> 01:07:28,700
听众：当你的malloc，是它的
堆或堆栈中[听不清]？

1283
01:07:28,700 --> 01:07:31,950
教授：当你的malloc，
你从堆取内存

1284
01:07:31,950 --> 01:07:32,830
和分配它。

1285
01:07:32,830 --> 01:07:34,950
所以，你不必
惹任何这一点。

1286
01:07:34,950 --> 01:07:38,100
所以我想更大的外卖
这里是一些所谓的范围。

1287
01:07:38,100 --> 01:07:39,650
>> 对于那些你们谁是在
审查会议昨晚，

1288
01:07:39,650 --> 01:07:41,080
我们短暂交谈这件事。

1289
01:07:41,080 --> 01:07:45,380
范围定义了如何和
当你的变量存在。

1290
01:07:45,380 --> 01:07:48,050
或在什么框架
做你的变量存在。

1291
01:07:48,050 --> 01:07:51,690
>> 拇指差不多一般规则
是，你variables--如果你创建它们

1292
01:07:51,690 --> 01:07:56,660
大braces--里面却存在
只在那些大括号内。

1293
01:07:56,660 --> 01:08:00,312
>> 因此，例如在我们的功能
FUNC，你看这两个大括号。

1294
01:08:00,312 --> 01:08:02,020
如果您正在创建
它里面的东西，

1295
01:08:02,020 --> 01:08:06,500
没准你正在做的是
创建堆栈和存储有。

1296
01:08:06,500 --> 01:08:07,430
同样的事情在主。

1297
01:08:07,430 --> 01:08:09,950
这只是存储的主要内。

1298
01:08:09,950 --> 01:08:13,560
>> 你也想​​成为
非常，非常小心这里。

1299
01:08:13,560 --> 01:08:18,310
由于范围还借给
本身不同的例子。

1300
01:08:18,310 --> 01:08:25,950
因此，例如，一个用于
循环，对于int i等于0。

1301
01:08:25,950 --> 01:08:28,460
我不到，我不知道，10。

1302
01:08:28,460 --> 01:08:32,111
我加再加。

1303
01:08:32,111 --> 01:08:34,560
而你得到了它的内部代码，对不对？

1304
01:08:34,560 --> 01:08:38,830
>> 在什么地方这个变量，
我，居然只存在吗？

1305
01:08:38,830 --> 01:08:40,510
只有里面的for循环。

1306
01:08:40,510 --> 01:08:43,640
所以，我敢打赌，你们的许多球员都有
可能遇到此错误时，

1307
01:08:43,640 --> 01:08:45,930
你在做节目的pset中。

1308
01:08:45,930 --> 01:08:49,990
有多少你们都试图利用我
for循环外有一个错误？

1309
01:08:49,990 --> 01:08:53,310
就像一个未引用的整数
或类似的东西？

1310
01:08:53,310 --> 01:08:56,069
>> 之所以出现这种情况
是因为在这里你

1311
01:08:56,069 --> 01:08:59,109
创造的东西，只有
存在在你的for循环。

1312
01:08:59,109 --> 01:09:01,972
如果你尝试使用它，我不
它的外面确实存在。

1313
01:09:01,972 --> 01:09:04,930
因此，基本上一台电脑说，我
不知道你在说什么。

1314
01:09:04,930 --> 01:09:08,689
我所知道的是，一个我是
在这里，但现在已不再。

1315
01:09:08,689 --> 01:09:12,580
>> 所以，如果我要创建一个
对于循环内，对不对？

1316
01:09:12,580 --> 01:09:19,080
而且我要创建一个，
如int j和有它做什么。

1317
01:09:19,080 --> 01:09:23,689
和你有内部的代码
这个循环，J只存在这里。

1318
01:09:23,689 --> 01:09:26,029
但是，这也存在内我。

1319
01:09:26,029 --> 01:09:29,310
所以Ĵ只存在
在这个循环，

1320
01:09:29,310 --> 01:09:33,850
而我存在于整个事情。

1321
01:09:33,850 --> 01:09:34,500
>> 大家都清楚了吗？

1322
01:09:34,500 --> 01:09:37,416
同样的事情与条件语句
如果您要创建什么。

1323
01:09:37,416 --> 01:09:40,390
同样的事情while循环，如果
您要创建什么。

1324
01:09:40,390 --> 01:09:42,390
这是一件值得
非常，非常小心。

1325
01:09:42,390 --> 01:09:45,681
因此，这是一个很好的问题，在
某种意义上说，它证明了两件事情。

1326
01:09:45,681 --> 01:09:47,160
这表明第一，适用范围。

1327
01:09:47,160 --> 01:09:49,550
它证明
同时内存分配。

1328
01:09:49,550 --> 01:09:54,130
因为你们应该知道，
函数栈向上生长。

1329
01:09:54,130 --> 01:09:56,710
而且，当你调用
功能，您正在创建

1330
01:09:56,710 --> 01:09:59,060
内存基本上是一个新的堆栈。

1331
01:09:59,060 --> 01:10:02,100
即从非常不同
你的主内存是什么。

1332
01:10:02,100 --> 01:10:03,300
是啊。

1333
01:10:03,300 --> 01:10:03,800
呼！

1334
01:10:03,800 --> 01:10:05,470
每个人都在说好不好？

1335
01:10:05,470 --> 01:10:06,750
这是令人困惑的。

1336
01:10:06,750 --> 01:10:09,380
很好的话题走了过来，
因为你可能

1337
01:10:09,380 --> 01:10:12,255
会得到一些棘手
这样的事情在测验。

1338
01:10:12,255 --> 01:10:13,350
是啊。

1339
01:10:13,350 --> 01:10:13,850
凉。

1340
01:10:13,850 --> 01:10:16,014

1341
01:10:16,014 --> 01:10:18,430
我会把你一送100
行，然后10上的其他。

1342
01:10:18,430 --> 01:10:21,468
是啊，很不错。

1343
01:10:21,468 --> 01:10:26,350
>> 好了，现在你们将得到
有机会成为助教。

1344
01:10:26,350 --> 01:10:30,600
你得到回答所有可爱
电子邮件，我有时会。

1345
01:10:30,600 --> 01:10:34,290
>> 所以，亲爱的安迪，我看，我认为有些事情是
与我的编译器会出错。

1346
01:10:34,290 --> 01:10:37,910
我敢肯定，我的代码是正确的，
但我不断收到分段错误

1347
01:10:37,910 --> 01:10:39,074
我每次运行。

1348
01:10:39,074 --> 01:10:39,740
这是怎么回事？

1349
01:10:39,740 --> 01:10:42,844
请帮帮忙，很多的爱。

1350
01:10:42,844 --> 01:10:45,740

1351
01:10:45,740 --> 01:10:49,410
>> 如果你们得到的东西像
那你会如何应对？

1352
01:10:49,410 --> 01:10:51,860
这些其实都是很常见
的问题，我们会问你。

1353
01:10:51,860 --> 01:10:54,090
如果是，我们会给你一个
情况下，我们会给我们

1354
01:10:54,090 --> 01:10:56,350
在发生了什么事情你最好的猜测。

1355
01:10:56,350 --> 01:11:00,710
任何人都有一个刺在这是怎么回事？

1356
01:11:00,710 --> 01:11:02,654
是吗？

1357
01:11:02,654 --> 01:11:06,056
>> 听众：也许废弃的
空，像指针

1358
01:11:06,056 --> 01:11:08,924
指着一些空。

1359
01:11:08,924 --> 01:11:11,590
教授：是啊，这会是一个
例如，当这会发生的。

1360
01:11:11,590 --> 01:11:14,467
但是，什么是较大的图片
正在发生的事情就在这里？

1361
01:11:14,467 --> 01:11:17,050
听众：难道你想
访问内存，你是不是

1362
01:11:17,050 --> 01:11:18,175
应该可以访问？

1363
01:11:18,175 --> 01:11:19,200
教授：没错。

1364
01:11:19,200 --> 01:11:24,800
因此，认为一个赛格故障，关断
限制，在存储器禁区

1365
01:11:24,800 --> 01:11:27,780
你不应该动人。

1366
01:11:27,780 --> 01:11:31,670
>> 所以，当你试图几乎
到index--像例如

1367
01:11:31,670 --> 01:11:34,110
您已经声明了
阵从0到9。

1368
01:11:34,110 --> 01:11:37,360
但你尝试触摸的第10
价值，你没有访问该。

1369
01:11:37,360 --> 01:11:38,694
因为你还没有宣布它。

1370
01:11:38,694 --> 01:11:40,943
所以，你的电脑是怎么回事
看那个像，

1371
01:11:40,943 --> 01:11:43,440
嗯哦，你试图去
外的索引的边界。

1372
01:11:43,440 --> 01:11:45,270
我想给你
段错误。

1373
01:11:45,270 --> 01:11:46,590
>> 想想作为分段，对不对？

1374
01:11:46,590 --> 01:11:49,665
一个额外的段，该故障是
当您试图突破的东西

1375
01:11:49,665 --> 01:11:50,790
你不应该在那里。

1376
01:11:50,790 --> 01:11:53,660
段错误是随时
您尝试触摸的东西

1377
01:11:53,660 --> 01:11:54,970
你不应该动人。

1378
01:11:54,970 --> 01:11:56,815
>> 因此，常见的例子是一个索引。

1379
01:11:56,815 --> 01:11:58,940
当然，如果你想
触摸到了那颗为空，

1380
01:11:58,940 --> 01:12:00,220
这也将正常工作。

1381
01:12:00,220 --> 01:12:02,300
如果你的指针试图
触摸的东西，不应该接触，

1382
01:12:02,300 --> 01:12:03,730
也可以正常工作。

1383
01:12:03,730 --> 01:12:07,120
最典型的你会
看到这个数组。

1384
01:12:07,120 --> 01:12:07,740
每个人都好？

1385
01:12:07,740 --> 01:12:10,374
>> 听众：所以，如果你想
进入10点

1386
01:12:10,374 --> 01:12:12,290
而且也只有一个极限
九什么的。

1387
01:12:12,290 --> 01:12:13,160
>> 教授：是的，没错。

1388
01:12:13,160 --> 01:12:13,660
漂亮多了。

1389
01:12:13,660 --> 01:12:15,930

1390
01:12:15,930 --> 01:12:16,430
凉。

1391
01:12:16,430 --> 01:12:19,070

1392
01:12:19,070 --> 01:12:19,920
>> 亲爱的安迪。

1393
01:12:19,920 --> 01:12:23,440
所以，我们已经得到了这些精彩
东西叫做排序。

1394
01:12:23,440 --> 01:12:25,472
如果合并类别 - 正如我们
例如，当在锯

1395
01:12:25,472 --> 01:12:27,180
大卫做了全
在分类 - 东西为什么，

1396
01:12:27,180 --> 01:12:29,760
如果它是比如此之快
任何其他类型的，

1397
01:12:29,760 --> 01:12:33,310
为什么我们甚至不屑知道
任何其他类型的？

1398
01:12:33,310 --> 01:12:35,100
>> 这个问题真是问你是什么？

1399
01:12:35,100 --> 01:12:36,659
什么是三word--

1400
01:12:36,659 --> 01:12:37,950
听众：什么是取舍？

1401
01:12:37,950 --> 01:12:38,530
教授：没错。

1402
01:12:38,530 --> 01:12:39,946
这是什么的问题在问。

1403
01:12:39,946 --> 01:12:43,682
什么是之间的权衡
合并排序的诗句任何其他类型的？

1404
01:12:43,682 --> 01:12:45,850
>> 听众：取内存，对不对？

1405
01:12:45,850 --> 01:12:47,720
>> 教授：你
解释说，多一点？

1406
01:12:47,720 --> 01:12:49,490
首先，让我们解释合并店。

1407
01:12:49,490 --> 01:12:50,970
如何合并排序工作？

1408
01:12:50,970 --> 01:12:55,220
>> 听众：所以它的工作方式
一切都划分成半

1409
01:12:55,220 --> 01:13:00,660
然后将其组合在一起
并重新分配它的秩序，

1410
01:13:00,660 --> 01:13:02,862
就像每次合并集。

1411
01:13:02,862 --> 01:13:03,820
教授：差不多。

1412
01:13:03,820 --> 01:13:06,861
所以，我可以借鉴这一点，但它会
带我五分钟就画出来。

1413
01:13:06,861 --> 01:13:10,220
回首一节幻灯片
在这里我们讨论合并排序。

1414
01:13:10,220 --> 01:13:10,790
究竟。

1415
01:13:10,790 --> 01:13:13,406
>> 于是方式合并排序工作
它是把事情的一半，

1416
01:13:13,406 --> 01:13:15,780
然后它只是着眼于
所有这些的第一值

1417
01:13:15,780 --> 01:13:17,000
只有进行排序。

1418
01:13:17,000 --> 01:13:20,364
不断创造新的阵列和
使事情越来越多，为了。

1419
01:13:20,364 --> 01:13:23,030
因此而真的，真的
快，因为你知道it's--，

1420
01:13:23,030 --> 01:13:25,380
二进制搜索是n的n log。

1421
01:13:25,380 --> 01:13:27,880
你创造这么多
你是不同的阵列

1422
01:13:27,880 --> 01:13:29,700
使用大量的内存。

1423
01:13:29,700 --> 01:13:33,080
因此，虽然它更快，权衡
这里要说的是，你正在使用更多的内存。

1424
01:13:33,080 --> 01:13:38,490
>> 因此，提示，排序和搜索
今年更是涵盖了很多

1425
01:13:38,490 --> 01:13:41,610
比他们已经在几年以前。

1426
01:13:41,610 --> 01:13:45,100
你们应该看到，
因此在测验反映。

1427
01:13:45,100 --> 01:13:49,160
我一定会花时间去
在什么所有不同种类

1428
01:13:49,160 --> 01:13:52,320
是，如何二进制搜索，
如何线性搜索工作。

1429
01:13:52,320 --> 01:13:54,750
如何也许是伪代码
这些代码了。

1430
01:13:54,750 --> 01:13:55,950
什么是运行时间？

1431
01:13:55,950 --> 01:13:59,210
类似的运行时间很
容易复制下来到笔记板，

1432
01:13:59,210 --> 01:13:59,710
对？

1433
01:13:59,710 --> 01:14:01,420
>> 这真的很难，当你
在中间试验

1434
01:14:01,420 --> 01:14:02,390
你必须明白这一点。

1435
01:14:02,390 --> 01:14:03,160
它复制下来。

1436
01:14:03,160 --> 01:14:05,550
我向你保证你
将需要知道。

1437
01:14:05,550 --> 01:14:06,860
哪些取舍？

1438
01:14:06,860 --> 01:14:10,064
最糟糕的情况下，最好的情况下，场景
对所有的人都非常了解。

1439
01:14:10,064 --> 01:14:10,564
是吗？

1440
01:14:10,564 --> 01:14:12,730
>> 听众：我们是否需要
知道如何编写合并排​​序？

1441
01:14:12,730 --> 01:14:15,470
喜欢，我们需要
记得递归？

1442
01:14:15,470 --> 01:14:18,950
>> 教授：我很怀疑，只是
因为它像相当复杂的。

1443
01:14:18,950 --> 01:14:22,282
但它可能不是不可行，如果我们
请你用伪出来。

1444
01:14:22,282 --> 01:14:22,781
是啊。

1445
01:14:22,781 --> 01:14:25,470

1446
01:14:25,470 --> 01:14:29,170
>> 是的，好了，多一个。

1447
01:14:29,170 --> 01:14:31,387
这可能已经拿出了
你最后一块在一个位。

1448
01:14:31,387 --> 01:14:42,101

1449
01:14:42,101 --> 01:14:43,090
是吗？

1450
01:14:43,090 --> 01:14:44,930
难道大家听到了吗？

1451
01:14:44,930 --> 01:14:48,360
>> 好了，几乎第一
程序的所有，什么类型

1452
01:14:48,360 --> 01:14:51,000
将让你像这样的输出？

1453
01:14:51,000 --> 01:14:54,350
请记住，我们要求你了解
这种新型的调试工具？

1454
01:14:54,350 --> 01:14:57,340
什么是它的名字？

1455
01:14:57,340 --> 01:14:59,460
Valgrind的，正确的

1456
01:14:59,460 --> 01:15:02,600
>> 这是一个程序，
你可以调用，可以

1457
01:15:02,600 --> 01:15:05,940
保留所有你的记忆轨迹
使用你的程序，并是怎么回事。

1458
01:15:05,940 --> 01:15:11,090
所以，如果你已经得到的东西，比如，
肯定输了，40个字节的一个块。

1459
01:15:11,090 --> 01:15:14,870
也许你不
记住释放它。

1460
01:15:14,870 --> 01:15:18,710
因为如果你使用的字节的内存，
这意味着你已经访问内存，

1461
01:15:18,710 --> 01:15:20,240
但一直没能释放。

1462
01:15:20,240 --> 01:15:21,948
所以，你想
相信你也

1463
01:15:21,948 --> 01:15:31,420
使用free--这是一个
function--释放所有

1464
01:15:31,420 --> 01:15:34,930
的由malloc重新分配的存储器。

1465
01:15:34,930 --> 01:15:35,500
>> 凉。

1466
01:15:35,500 --> 01:15:37,140
这张幻灯片，我要它。

1467
01:15:37,140 --> 01:15:41,050
它无处不在很多
讲座，在很多部分幻灯片。

1468
01:15:41,050 --> 01:15:44,254
你真的要确保
你只知道这一切。

1469
01:15:44,254 --> 01:15:47,170
无论是在你的笔记板，或者如果你
要记住它，随意。

1470
01:15:47,170 --> 01:15:48,836
这是真的，真的，真的很重要。

1471
01:15:48,836 --> 01:15:53,200

1472
01:15:53,200 --> 01:15:56,890
>> 也是一个非常好的
问题是，我们可能会问。

1473
01:15:56,890 --> 01:16:00,320
为什么选择类别 - 看看
选择类别 - 所有运行时的

1474
01:16:00,320 --> 01:16:02,060
n个平方。

1475
01:16:02,060 --> 01:16:06,714
不管如何列表来
你是，那么为什么选择类别 - 

1476
01:16:06,714 --> 01:16:08,630
我给你们30
第二想一想。

1477
01:16:08,630 --> 01:16:10,700
因为那种它的混乱。

1478
01:16:10,700 --> 01:16:12,710
它涉及到一些概念上的想法。

1479
01:16:12,710 --> 01:16:16,470
为什么会运行时间是在同
二者最差和最好情况场景？

1480
01:16:16,470 --> 01:16:28,850

1481
01:16:28,850 --> 01:16:30,000
>> 是吗？

1482
01:16:30,000 --> 01:16:38,084
>> 听众：因为选择排序每个
在这个小阵位或空间

1483
01:16:38,084 --> 01:16:40,350
事或什么的。

1484
01:16:40,350 --> 01:16:44,430
因此，即使在最好的情况下，
即使它完全排序，

1485
01:16:44,430 --> 01:16:47,380
它仍然只能是这样，好吧，之一。

1486
01:16:47,380 --> 01:16:49,000
在我的第一个地方，我有一个。

1487
01:16:49,000 --> 01:16:50,250
并通过他们。

1488
01:16:50,250 --> 01:16:51,249
OK，一个是最小的。

1489
01:16:51,249 --> 01:16:53,053
然后它又来了
是想，好，二

1490
01:16:53,053 --> 01:16:54,594
是最小的所有的东西。

1491
01:16:54,594 --> 01:16:56,804
但它仍然有
检查每一个人。

1492
01:16:56,804 --> 01:16:57,470
教授：是的。

1493
01:16:57,470 --> 01:17:00,490
因此，例如，让我们只说
我们有一个列表，已经排序，

1494
01:17:00,490 --> 01:17:03,390
阵列一至五个。

1495
01:17:03,390 --> 01:17:07,100
的方式来选择排序是
它通过，它会检查这两个。

1496
01:17:07,100 --> 01:17:08,234
然后检查这两个。

1497
01:17:08,234 --> 01:17:09,650
然后它会检查，而且检查。

1498
01:17:09,650 --> 01:17:13,285
它不断检查所有的人，
不管是否

1499
01:17:13,285 --> 01:17:14,160
它的实际排序。

1500
01:17:14,160 --> 01:17:16,450
因为这是根本
排序的工作方式。

1501
01:17:16,450 --> 01:17:19,530
>> 所以这个问题是一种像
一个概念性的问题，我们会问。

1502
01:17:19,530 --> 01:17:21,430
其中第一，你
知道什么选择排序

1503
01:17:21,430 --> 01:17:23,304
是吧，要能
回答这个问题。

1504
01:17:23,304 --> 01:17:26,200
你必须要能够理解
从概念上发生了什么事情。

1505
01:17:26,200 --> 01:17:30,760
然后你可以将它和思考，确定
让我们试想一下，最糟糕的情况。

1506
01:17:30,760 --> 01:17:32,230
他们都是按降序排列。

1507
01:17:32,230 --> 01:17:33,290
将如何影响呢？

1508
01:17:33,290 --> 01:17:34,650
>> 如果它是升序排列？

1509
01:17:34,650 --> 01:17:35,640
如果它已经排序？

1510
01:17:35,640 --> 01:17:37,240
将如何影响运行时？

1511
01:17:37,240 --> 01:17:40,270
然后选择排序，你会发现
它实际上并不重要。

1512
01:17:40,270 --> 01:17:43,500
因为你正在检查所有的
值不管发生了什么。

1513
01:17:43,500 --> 01:17:45,810
>> 所以，好东西要记住。

1514
01:17:45,810 --> 01:17:50,290
为什么某些种类从别人不同
以及如何最好的和最坏的情况

1515
01:17:50,290 --> 01:17:52,740
会影响到所有的人。

1516
01:17:52,740 --> 01:17:56,700
>> 我要真打的种类
因为这将是对测验。

1517
01:17:56,700 --> 01:17:57,199
是啊。

1518
01:17:57,199 --> 01:18:00,820

1519
01:18:00,820 --> 01:18:01,320
好。

1520
01:18:01,320 --> 01:18:05,590
还有剩下六分钟时间。

1521
01:18:05,590 --> 01:18:09,880
我可以采取三分钟的问题。

1522
01:18:09,880 --> 01:18:12,290
我也可以流连
像第20分钟后

1523
01:18:12,290 --> 01:18:13,850
如果你要问的问题也是如此。

1524
01:18:13,850 --> 01:18:16,330
有谁只是真的简单
疑问或概念问题

1525
01:18:16,330 --> 01:18:17,360
他们是不清楚的权利吗？

1526
01:18:17,360 --> 01:18:17,832
是吗？

1527
01:18:17,832 --> 01:18:19,720
>> 听众：你能谈一点
关于位运算符位？

1528
01:18:19,720 --> 01:18:20,280
>> 教授：是的。

1529
01:18:20,280 --> 01:18:22,446
所以按位运算符
一些你可能

1530
01:18:22,446 --> 01:18:24,170
可能只是想要把你的表。

1531
01:18:24,170 --> 01:18:27,540
所以quickly--我不想
深入进去太多

1532
01:18:27,540 --> 01:18:31,164
因为哈佛，在其审查
会议上，遮盖得很好。

1533
01:18:31,164 --> 01:18:33,080
位运算符，还有
五人，对不对？

1534
01:18:33,080 --> 01:18:41,370
>> 有这一点，这是x或功能，
有符号，它是和。

1535
01:18:41,370 --> 01:18:44,050
管，这是或。

1536
01:18:44,050 --> 01:18:46,790
然后你有两个
不同类型的班次。

1537
01:18:46,790 --> 01:18:50,610
>> 如果我给你两个值，如果
我给你一样，一个又一个。

1538
01:18:50,610 --> 01:18:52,390
你会计算结果为？

1539
01:18:52,390 --> 01:18:55,490
如果我给你真实，真实，是真的吗？

1540
01:18:55,490 --> 01:18:56,930
那么真的还是假的？

1541
01:18:56,930 --> 01:18:57,830
不过真的吧？

1542
01:18:57,830 --> 01:18:59,762
由于有一个或。

1543
01:18:59,762 --> 01:19:01,220
我们将最有可能给你​​的数字。

1544
01:19:01,220 --> 01:19:03,780
所以请记住，一等于
如此，零等于false。

1545
01:19:03,780 --> 01:19:07,407
我们可能会给你这些东西
并请您告诉我们发生了什么。

1546
01:19:07,407 --> 01:19:10,240
哈佛覆盖它内部的第一
10分钟他们的研究会议

1547
01:19:10,240 --> 01:19:11,230
真的，真的很好。

1548
01:19:11,230 --> 01:19:14,260
所以，你们要进行
确保您回首这一点。

1549
01:19:14,260 --> 01:19:16,387
>> 听众：是pisa5
将要在测验？

1550
01:19:16,387 --> 01:19:16,970
教授：第

1551
01:19:16,970 --> 01:19:18,240
甚至不看pisa5现在。

1552
01:19:18,240 --> 01:19:18,810
这个很难（硬。

1553
01:19:18,810 --> 01:19:22,830
只是不甚至懒得看pisa5。

1554
01:19:22,830 --> 01:19:25,665
>> 然而，由于一些提示
和建议，我

1555
01:19:25,665 --> 01:19:28,320
建议你开始pisa5
只要测验结束。

1556
01:19:28,320 --> 01:19:30,319
这将是最困难的
上周，但你们

1557
01:19:30,319 --> 01:19:34,590
将通过它在山上
连绵起伏的绿色和小狗的，

1558
01:19:34,590 --> 01:19:36,115
和它的罚款。

1559
01:19:36,115 --> 01:19:39,810
>> 该类得到显著
第五PSET后更容易。

1560
01:19:39,810 --> 01:19:41,560
听众：办公时间
星期日，星期一？

1561
01:19:41,560 --> 01:19:44,260
教授：是啊，所以办公时间会
周日到周一为PSET。

1562
01:19:44,260 --> 01:19:47,009
今晚办公时间基本
也只是审查测验。

1563
01:19:47,009 --> 01:19:50,350
如果有人想进来，问
助教的问题，我们将在那里。

1564
01:19:50,350 --> 01:19:53,220
>> 我带你去也许一个问题
如果任何人有问题？

1565
01:19:53,220 --> 01:19:53,809
是吗？

1566
01:19:53,809 --> 01:19:55,850
听众：当你
定义节点，[听不清]

1567
01:19:55,850 --> 01:20:00,700
如果你说下一个节点明星，然后，
自动执行电脑

1568
01:20:00,700 --> 01:20:03,610
了解您
谈到另一个指针？

1569
01:20:03,610 --> 01:20:04,580
>> 教授：第

1570
01:20:04,580 --> 01:20:06,710
>> 听众：你必须
重新链接[听不清]？

1571
01:20:06,710 --> 01:20:09,270
>> 教授：所以基本上
一个节点的结构是，记住，

1572
01:20:09,270 --> 01:20:12,620
这就像你创建的节点，
那么你有一个被称为下一个指针。

1573
01:20:12,620 --> 01:20:14,630
所有你正在做的是具有
结构出现。

1574
01:20:14,630 --> 01:20:16,387
您必须分配
该指针的地方。

1575
01:20:16,387 --> 01:20:18,470
因此，计算机不
知道它在做什么呢。

1576
01:20:18,470 --> 01:20:20,250
你有实际的时候给它分配
你创建你的链接列表。

1577
01:20:20,250 --> 01:20:22,170
这就是主要
PSET 5将上。

1578
01:20:22,170 --> 01:20:24,106
所以不愁
任何现在的权利。

1579
01:20:24,106 --> 01:20:26,380
>> 听众：所以我们并不需要
过于注重链接列表，只

1580
01:20:26,380 --> 01:20:27,440
一般的概念？

1581
01:20:27,440 --> 01:20:30,980
>> 教授：刚才几乎栈，
队列，链表，树，哈希表。

1582
01:20:30,980 --> 01:20:33,639
只要能够知道它们是什么。

1583
01:20:33,639 --> 01:20:35,680
我们不会问
你喜欢什么具体

1584
01:20:35,680 --> 01:20:39,300
因为我们还没有真正做了
PSET的涵盖任何的呢。

1585
01:20:39,300 --> 01:20:45,540
>> 因此，在最后两分钟前
我给你自由，来杀死这个测验。

1586
01:20:45,540 --> 01:20:49,370
差不多一样，想想怎么
到目前为止你们已经走在这个类。

1587
01:20:49,370 --> 01:20:52,820
>> 我记得当2周
这个类，有些人的

1588
01:20:52,820 --> 01:20:55,720
花3小时写水。

1589
01:20:55,720 --> 01:20:57,970
多久会带你
球员现在写的水？

1590
01:20:57,970 --> 01:20:59,670
30秒后，也许？

1591
01:20:59,670 --> 01:21:01,810
想想多少
你们已经学会了。

1592
01:21:01,810 --> 01:21:04,320
CS是真的，真的很难受。

1593
01:21:04,320 --> 01:21:06,190
还有的是毫无疑问的。

1594
01:21:06,190 --> 01:21:09,160
这很难，这就是为什么没有人研究它。

1595
01:21:09,160 --> 01:21:10,730
这只是很难。

1596
01:21:10,730 --> 01:21:11,650
而且它是完全罚款。

1597
01:21:11,650 --> 01:21:14,150
>> 而且我真的很自豪的是，
每个人都已经走到今天这一步。

1598
01:21:14,150 --> 01:21:16,380
的pset是不容易的。

1599
01:21:16,380 --> 01:21:17,790
他们采取了很多时间。

1600
01:21:17,790 --> 01:21:22,580
你这家伙，我绝不会要求你写
15人的Vigenere在PSET游戏。

1601
01:21:22,580 --> 01:21:24,160
没有必要只是吓坏了这一点。

1602
01:21:24,160 --> 01:21:28,080
所有我们这里测试是评估
您的概念性知识，以及

1603
01:21:28,080 --> 01:21:31,524
由于部分编码的基本技能。

1604
01:21:31,524 --> 01:21:33,440
该试验的目的是
真正具有挑战性的。

1605
01:21:33,440 --> 01:21:36,180
像，它被设计
你拿不到100。

1606
01:21:36,180 --> 01:21:39,880
它的设计也为您可能
不能够在75分钟结束。

1607
01:21:39,880 --> 01:21:41,995
而这完全罚款。

1608
01:21:41,995 --> 01:21:42,870
我是学生自己。

1609
01:21:42,870 --> 01:21:45,960
我知道，我恨它，当我走
出测验是这样，狗屎。

1610
01:21:45,960 --> 01:21:47,044
这是真的很难。

1611
01:21:47,044 --> 01:21:49,460
大概什么会
happen--而这完全罚款，

1612
01:21:49,460 --> 01:21:50,751
我告诉你们，现在。

1613
01:21:50,751 --> 01:21:53,190
这些东西的手段
不高的。

1614
01:21:53,190 --> 01:21:55,360
>> 而对于那些你们谁
已经越来越像，

1615
01:21:55,360 --> 01:21:57,870
您的问题集三分球，
这并不意味着你

1616
01:21:57,870 --> 01:21:59,536
会得到60％的此类。

1617
01:21:59,536 --> 01:22:01,440
如果你在获得60％
测验，这不

1618
01:22:01,440 --> 01:22:03,330
意思是你要
获得A D在这个类。

1619
01:22:03,330 --> 01:22:05,740
我们看到，尤其是我，对于
在我的部分那些你，

1620
01:22:05,740 --> 01:22:07,406
我看怎么努力，你们都在努力。

1621
01:22:07,406 --> 01:22:09,190
我跟踪了。

1622
01:22:09,190 --> 01:22:11,420
>> 你们将被罚款。

1623
01:22:11,420 --> 01:22:14,580
有没有机构记忆
幸福在学期结束。

1624
01:22:14,580 --> 01:22:16,840
因为所有的哈佛孩子们讲
他们的朋友，哦，你会没事的。

1625
01:22:16,840 --> 01:22:18,381
没有人告诉你们，在这里。

1626
01:22:18,381 --> 01:22:20,950
所以，我要告诉你们，在这里。

1627
01:22:20,950 --> 01:22:22,280
>> 你们将被罚款。

1628
01:22:22,280 --> 01:22:24,080
我很自豪所有你们的。

1629
01:22:24,080 --> 01:22:25,680
该测试将是困难的。

1630
01:22:25,680 --> 01:22:28,140
研究它，事后
只是把它扔掉。

1631
01:22:28,140 --> 01:22:31,280
准备好学习新的东西。

1632
01:22:31,280 --> 01:22:33,990
吃糖果。

1633
01:22:33,990 --> 01:22:35,940
我们已经有很多的糖果。

1634
01:22:35,940 --> 01:22:37,760
>> 得到一个良好的夜间睡眠。

1635
01:22:37,760 --> 01:22:40,420
不要不睡觉，因为
那会是非常糟糕的。

1636
01:22:40,420 --> 01:22:41,490
CS是一个很大的逻辑。

1637
01:22:41,490 --> 01:22:44,960
如果你不睡觉，你就无法运作，
你的大脑不能正常工作。

1638
01:22:44,960 --> 01:22:48,780
而且我会在这里为下一个20
分钟，如果有人想流连。

1639
01:22:48,780 --> 01:22:51,150
你们要杀死它。

1640
01:22:51,150 --> 01:22:53,000
祝你好运。

1641
01:22:53,000 --> 01:22:55,663