1
00:00:00,000 --> 00:00:06,180

2
00:00:06,180 --> 00:00:07,820
>> JASON HIRSCHHORN：欢迎
到A5，大家好。

3
00:00:07,820 --> 00:00:11,270
我们有一个令人兴奋的一周摆在我们面前，
主要是因为有这么多新

4
00:00:11,270 --> 00:00:12,350
面临着在这个房间里。

5
00:00:12,350 --> 00:00:12,920
这是美妙的。

6
00:00:12,920 --> 00:00:15,740
很多你在这里意外，
这是更好的。

7
00:00:15,740 --> 00:00:18,220
所以希望你会继续加入我们的行列。

8
00:00:18,220 --> 00:00:20,220
>> 本周我们将花
大头的部分

9
00:00:20,220 --> 00:00:21,870
准备测验。

10
00:00:21,870 --> 00:00:26,580
因此，根据我们的议程，我们要谈
一点关于该类资源，

11
00:00:26,580 --> 00:00:30,350
而且对测验，然后，再次
花大量类的说话

12
00:00:30,350 --> 00:00:31,390
有关的问题。

13
00:00:31,390 --> 00:00:33,900
一旦我们做了回答您的
的问题，或者如果您的问题

14
00:00:33,900 --> 00:00:39,010
自然使我们联想到一些编码，我
有从期中考试样题

15
00:00:39,010 --> 00:00:43,180
过去，我们将在部分实时代码
同时也带来了一些其他的

16
00:00:43,180 --> 00:00:45,420
好的选题覆盖。

17
00:00:45,420 --> 00:00:48,280
>> 因此，首先，因为我们已经经历了
过去几周来提醒​​你

18
00:00:48,280 --> 00:00:51,700
伙计们，有一吨的资源
提供此课程。

19
00:00:51,700 --> 00:00:55,020
他们中的许多将是难以置信的帮助
你为你继续

20
00:00:55,020 --> 00:00:57,280
对于学习测验0，因为
这是周二下午。

21
00:00:57,280 --> 00:00:59,630
因此，所有的你一直
研究了一下。

22
00:00:59,630 --> 00:01:02,640
>> 有讲义和源
代码，您应该

23
00:01:02,640 --> 00:01:04,050
一定要看看。

24
00:01:04,050 --> 00:01:05,019
观看短裤。

25
00:01:05,019 --> 00:01:07,470
退房study.cs50.net。

26
00:01:07,470 --> 00:01:11,770
然后，在下面列出，一​​个数
的其他资源。

27
00:01:11,770 --> 00:01:14,020
>> 再次，测验0就是明天
1点。

28
00:01:14,020 --> 00:01:18,230
如果你还没有这样做的话，请检查
列于本公司测验0文档

29
00:01:18,230 --> 00:01:21,370
当然主页搞清楚
在那里你正在做测验。

30
00:01:21,370 --> 00:01:25,770
测验开始于1:10和
端70分钟后。

31
00:01:25,770 --> 00:01:29,610
所以，如果你1:10以后出现，你
会得到很多更少分钟

32
00:01:29,610 --> 00:01:30,940
70比拿测验。

33
00:01:30,940 --> 00:01:33,570
所以一定要确保你有时间。

34
00:01:33,570 --> 00:01:38,690
如果你是一个扩展学生或有
其他一些测试方面的考虑，它

35
00:01:38,690 --> 00:01:40,400
可能不会在明天凌晨1点。

36
00:01:40,400 --> 00:01:43,540
但同样，检查关于测验0
记录，以确保你知道什么时候

37
00:01:43,540 --> 00:01:44,760
你服用的测验。

38
00:01:44,760 --> 00:01:46,440
我写75分钟在这里。

39
00:01:46,440 --> 00:01:48,580
我认为这是正确的，而不是70。

40
00:01:48,580 --> 00:01:53,420
>> 它涵盖了所有的材料从一个星期0
在周三上周的演讲。

41
00:01:53,420 --> 00:01:59,350
再次，这个测验，即每
文件，你得到一个双面和8

42
00:01:59,350 --> 00:02:03,770
1/2 11张纸上，你得到
测验期间，作为笔记使用。

43
00:02:03,770 --> 00:02:08,570
很多人，如果不是大多数人来说，有
发现的一个最有用的方法

44
00:02:08,570 --> 00:02:11,970
以研究为竞猜是
做一个研究表，

45
00:02:11,970 --> 00:02:13,730
1-Sider的自己。

46
00:02:13,730 --> 00:02:17,710
所以看过去的，如果
你看过过去的。

47
00:02:17,710 --> 00:02:19,960
接触到的朋友，看看有什么
他们穿上他们的。

48
00:02:19,960 --> 00:02:23,610
>> 但实际操作下来，最好的办法，你可以
学习是要经过的一切，

49
00:02:23,610 --> 00:02:26,530
惠特尔下来到什么应该或不应该
不属于重要的是表

50
00:02:26,530 --> 00:02:30,570
纸，因为这只是一个非常
有用的方式为您确保

51
00:02:30,570 --> 00:02:33,620
你正在经历的一切，
与它有一定的了解。

52
00:02:33,620 --> 00:02:36,690
大多数人来说，我们发现，即使它们
已在纸张右边坐着

53
00:02:36,690 --> 00:02:39,840
在他们旁边的测验，不转
它，因为，同样的，这很

54
00:02:39,840 --> 00:02:43,290
在经历了信息化进程
帮助他们学习。

55
00:02:43,290 --> 00:02:45,370
>> 没有任何人有任何疑问，
有关测验0？

56
00:02:45,370 --> 00:02:50,120

57
00:02:50,120 --> 00:02:51,450
有大家 - 

58
00:02:51,450 --> 00:02:53,230
我不会做举手。

59
00:02:53,230 --> 00:02:53,550
没关系。

60
00:02:53,550 --> 00:02:54,790
我正想问问谁
开始学习。

61
00:02:54,790 --> 00:02:58,360
但我不想让你
所有不请举手。

62
00:02:58,360 --> 00:03:01,290
所以，就像我说的 - 是的，AVI，勇往直前。

63
00:03:01,290 --> 00:03:04,205
>> AVI：什么会是一个有用的东西
穿上一个寻呼机？

64
00:03:04,205 --> 00:03:05,875
>> 学生：这是给你的。

65
00:03:05,875 --> 00:03:08,210
>> JASON HIRSCHHORN：你得到
使用你的判断。

66
00:03:08,210 --> 00:03:13,220
有用的东西要放在一个寻呼机，
如果你感到困惑的大O

67
00:03:13,220 --> 00:03:17,510
不同类型的搜索的运行时间
和排序，把那上有一个中

68
00:03:17,510 --> 00:03:18,760
方便的花花公子图。

69
00:03:18,760 --> 00:03:22,250
这样一来，如果你问的
小测验，你不需要尝试和数字

70
00:03:22,250 --> 00:03:23,560
它或理由通过运行时。

71
00:03:23,560 --> 00:03:24,730
你可以把它复制下来。

72
00:03:24,730 --> 00:03:28,320
如果你看看过去的测验，很多
次，还有的运行时间问题。

73
00:03:28,320 --> 00:03:34,150
因此，这将是一个很好的一个例子
东西放在你的一个寻呼机。

74
00:03:34,150 --> 00:03:37,450
>> 其他好东西穿上，如果你
困惑如何声明

75
00:03:37,450 --> 00:03:40,570
功能或什么的不同部分
函数的声明是，写

76
00:03:40,570 --> 00:03:43,400
那在那里，一个通用版本
然后也许一个例子。

77
00:03:43,400 --> 00:03:47,290
如果你感到困惑的指针，
如何指针工作是示

78
00:03:47,290 --> 00:03:48,660
大概真的很有帮助。

79
00:03:48,660 --> 00:03:52,440
如果你感到困惑递归，一个
样本上有递归函数

80
00:03:52,440 --> 00:03:54,980
也可能被证明是真正有用的。

81
00:03:54,980 --> 00:03:57,290
这是否给你一些想法？

82
00:03:57,290 --> 00:04:01,820
>> AVI：你需要了解的
整个编译过程，就像

83
00:04:01,820 --> 00:04:03,220
怎么所有的作品？

84
00:04:03,220 --> 00:04:06,620
>> JASON HIRSCHHORN：一切
已经可以覆盖

85
00:04:06,620 --> 00:04:08,060
显示的测验。

86
00:04:08,060 --> 00:04:08,930
问题 - 

87
00:04:08,930 --> 00:04:11,300
但同样，有些事情会
权重比其他人。

88
00:04:11,300 --> 00:04:14,330
有些事情已经再次出现
并再次在课堂上，在

89
00:04:14,330 --> 00:04:15,590
讲座，以及部分。

90
00:04:15,590 --> 00:04:17,220
其他的东西都没有
想出经常。

91
00:04:17,220 --> 00:04:22,900
>> 我们已经谈了很多关于＃include和
-L的东西，这些东西在的意思

92
00:04:22,900 --> 00:04:24,390
编译过程。

93
00:04:24,390 --> 00:04:29,120
我们已经谈了很多关于GDB，保鲜，
那些我们用不同的标志时，

94
00:04:29,120 --> 00:04:33,100
我们编译的东西，什么
make15，例如，真正

95
00:04:33,100 --> 00:04:34,510
手段和确实。

96
00:04:34,510 --> 00:04:38,110
我们还没有谈论的很多关于
在每一个步骤

97
00:04:38,110 --> 00:04:39,240
编译过程。

98
00:04:39,240 --> 00:04:40,410
我们仍然谈论它。

99
00:04:40,410 --> 00:04:42,550
所以它仍然是东西，你
应该熟悉。

100
00:04:42,550 --> 00:04:44,610
但同样，我们不会是 - 

101
00:04:44,610 --> 00:04:49,140
事情往往拿出在课堂上
更有可能想出更多

102
00:04:49,140 --> 00:04:52,495
常和更重
加权测验。

103
00:04:52,495 --> 00:04:53,280
>> 凉爽。

104
00:04:53,280 --> 00:04:54,580
有关测验0没有其他问题？

105
00:04:54,580 --> 00:04:57,660

106
00:04:57,660 --> 00:05:00,050
>> 好了，我把名单
题目在黑板上。

107
00:05:00,050 --> 00:05:01,550
我通过教学大纲去了。

108
00:05:01,550 --> 00:05:07,340
我通过从审查部分去
昨晚那些幻灯片上来

109
00:05:07,340 --> 00:05:13,710
与主题的不完全清单
我们已经介绍了迄今为止在CS50

110
00:05:13,710 --> 00:05:16,800
而事情可能
出现在测验。

111
00:05:16,800 --> 00:05:19,900
所以我不打算去通过
这些每一个。

112
00:05:19,900 --> 00:05:22,370
这将需要更多的
时间比我们现在有。

113
00:05:22,370 --> 00:05:26,880
但我要把这段话在这里希望慢跑
你的内存，以事情，可能

114
00:05:26,880 --> 00:05:28,420
或可能不熟悉你。

115
00:05:28,420 --> 00:05:32,850
>> 而且我很乐意花大量的
部分回答你的问题有关

116
00:05:32,850 --> 00:05:35,130
这些题目，主题，
这里不包括在内。

117
00:05:35,130 --> 00:05:36,130
我们可以写伪代码。

118
00:05:36,130 --> 00:05:40,010
我们可以编写真正的代码
以确保您 - 

119
00:05:40,010 --> 00:05:44,280
我可以回答你的问题，并帮助
每个人都从根本上理解

120
00:05:44,280 --> 00:05:48,330
很多这样的主题让你会觉得
准备和舒适进入

121
00:05:48,330 --> 00:05:50,150
测验的明天。

122
00:05:50,150 --> 00:05:52,300
所以，在阅读列表。

123
00:05:52,300 --> 00:05:54,780
希望你们都来节
有一些问题也是如此。

124
00:05:54,780 --> 00:05:58,480
当你准备好，举起你的手
我们将开始。

125
00:05:58,480 --> 00:06:01,590

126
00:06:01,590 --> 00:06:05,200
>> 请记住，这些问题你有，
没有愚蠢的问题。

127
00:06:05,200 --> 00:06:06,250
我们已经听说了很多。

128
00:06:06,250 --> 00:06:09,490
和你有问题，我愿意
打赌，很多人既

129
00:06:09,490 --> 00:06:11,740
坐在这里，看
网上也一样。

130
00:06:11,740 --> 00:06:13,770
所以你只能帮助人们
通过提问。

131
00:06:13,770 --> 00:06:15,070
马库斯。

132
00:06:15,070 --> 00:06:18,040
>> MARCUS：堆栈之间的
堆，就是有一个预分配

133
00:06:18,040 --> 00:06:22,880
这被定义为内存的百分比
这是堆栈或堆？

134
00:06:22,880 --> 00:06:25,010
或者，请问是怎么工作的，到底是什么？

135
00:06:25,010 --> 00:06:26,230
>> JASON HIRSCHHORN：大问题。

136
00:06:26,230 --> 00:06:28,640
我要回追查一点点。

137
00:06:28,640 --> 00:06:30,910
请问大家 - 

138
00:06:30,910 --> 00:06:31,660
请在这里是诚实的。

139
00:06:31,660 --> 00:06:34,130
我知道我在问你提高你的
手在你同行的前面。

140
00:06:34,130 --> 00:06:38,510
但有没有人觉得谁
难受的是栈和堆

141
00:06:38,510 --> 00:06:42,980
并想说明一下
和那些什么意思？

142
00:06:42,980 --> 00:06:43,880
如果举起你的手 - 

143
00:06:43,880 --> 00:06:44,420
确定。

144
00:06:44,420 --> 00:06:45,120
谢谢。

145
00:06:45,120 --> 00:06:48,420
所以，我们要投奔的堆栈和
堆真的很快，然后

146
00:06:48,420 --> 00:06:50,370
进入回答你的问题。

147
00:06:50,370 --> 00:06:58,250
>> 所以，如果我们画了一个框来表示
内存在计算机上，都有些什么

148
00:06:58,250 --> 00:07:02,160
事情往这个盒子？

149
00:07:02,160 --> 00:07:03,630
主。

150
00:07:03,630 --> 00:07:04,020
一个主要功能。

151
00:07:04,020 --> 00:07:05,890
哪里主去了？

152
00:07:05,890 --> 00:07:08,090
>> 学生：[听不清]。

153
00:07:08,090 --> 00:07:09,390
>> JASON HIRSCHHORN：所以我们会
把主要这儿吧。

154
00:07:09,390 --> 00:07:12,180

155
00:07:12,180 --> 00:07:13,430
在此框中去还有什么呢？

156
00:07:13,430 --> 00:07:16,000

157
00:07:16,000 --> 00:07:18,140
>> 学生：你调用的函数。

158
00:07:18,140 --> 00:07:19,020
>> JASON HIRSCHHORN：该功能
我们称之为。

159
00:07:19,020 --> 00:07:20,440
他们去哪儿去了？

160
00:07:20,440 --> 00:07:21,300
>> 生：在堆栈中。

161
00:07:21,300 --> 00:07:22,380
>> JASON HIRSCHHORN：他们
走在栈中。

162
00:07:22,380 --> 00:07:27,350
所以，我们要调用这个
这儿的事情堆栈。

163
00:07:27,350 --> 00:07:31,880
而往上顶，我们有堆。

164
00:07:31,880 --> 00:07:35,450
所以内存是不是就像这样一个盒子。

165
00:07:35,450 --> 00:07:37,330
但它实际上是非常相似的。

166
00:07:37,330 --> 00:07:40,840
这将是一个很大的箱子超过
并且，这取决于有多大你

167
00:07:40,840 --> 00:07:43,730
计算机是或有多大你的内存是。

168
00:07:43,730 --> 00:07:46,950
>> 在报价引文结束“底”
是堆栈。

169
00:07:46,950 --> 00:07:50,880
并有多个事
即进入堆叠。

170
00:07:50,880 --> 00:07:53,840
而那些依赖于功能
你在你的代码。

171
00:07:53,840 --> 00:07:57,780
你总是有一个功能在你的
代码中调用主，所以总有一个

172
00:07:57,780 --> 00:08:00,480
下节在这里
堆栈致力于主。

173
00:08:00,480 --> 00:08:03,980
>> 这些部分在堆栈
被称为堆栈帧。

174
00:08:03,980 --> 00:08:09,580
当你调用另一个函数，主要说
调用一个二进制搜索功能，

175
00:08:09,580 --> 00:08:11,075
我们把另一帧堆栈上。

176
00:08:11,075 --> 00:08:13,830

177
00:08:13,830 --> 00:08:17,320
更具体地说，我们要
捐赠的内存块在我们的

178
00:08:17,320 --> 00:08:22,960
计算机存储二进制搜索的地方
变量和运行的二进制

179
00:08:22,960 --> 00:08:24,150
搜索代码。

180
00:08:24,150 --> 00:08:26,810
>> 所以我们称之为二进制搜索。

181
00:08:26,810 --> 00:08:30,440

182
00:08:30,440 --> 00:08:33,340
在这种大块的内存，我们要
来存储它的局部变量。

183
00:08:33,340 --> 00:08:35,270
我们要存储其printf的调用。

184
00:08:35,270 --> 00:08:38,159
无论发生什么事，该函数是
将被存储在那里。

185
00:08:38,159 --> 00:08:40,350
二进制搜索是要执行。

186
00:08:40,350 --> 00:08:42,210
它要完成执行。

187
00:08:42,210 --> 00:08:47,450
什么是C语言的单词，标志着
一个函数

188
00:08:47,450 --> 00:08:49,306
完成它的执行？

189
00:08:49,306 --> 00:08:50,040
>> 学生：返回。

190
00:08:50,040 --> 00:08:50,870
>> JASON HIRSCHHORN：返回。

191
00:08:50,870 --> 00:08:53,230
所以每当你看到一个return语句，
函数结束

192
00:08:53,230 --> 00:08:54,350
当它击中了。

193
00:08:54,350 --> 00:08:56,740
所以二进制搜索将达到其返回。

194
00:08:56,740 --> 00:09:01,360
这部分内存基本上会
被释放了。

195
00:09:01,360 --> 00:09:03,510
而主要将回到执行。

196
00:09:03,510 --> 00:09:07,240
所以主要将暂停的地方是，调用
二进制搜索，得到一些返回值，

197
00:09:07,240 --> 00:09:08,700
并继续执行。

198
00:09:08,700 --> 00:09:10,840
这个栈帧会自行消失。

199
00:09:10,840 --> 00:09:14,810
>> 如果我们调用一个递归函数，该函数
是一个函数调用自身在

200
00:09:14,810 --> 00:09:18,480
并且，我们可能会得到 - 我们说
递归做二进制搜索。

201
00:09:18,480 --> 00:09:21,520
我们可能会得到一个二分查找的版本，
二进制搜索二，二分查找

202
00:09:21,520 --> 00:09:24,090
3，二进制搜索4，
二进制搜索五位。

203
00:09:24,090 --> 00:09:27,950
然后这最后的二进制搜索5
将撞击基的情况下，与层叠

204
00:09:27,950 --> 00:09:31,010
帧会回去，并保持关闭
直到我们回到主。

205
00:09:31,010 --> 00:09:32,530
我们可以走了过来递归的一点。

206
00:09:32,530 --> 00:09:35,530
但是，这一切是说，如果你是
调用多种功能的时间，

207
00:09:35,530 --> 00:09:39,250
就会有多个栈
在堆栈帧。

208
00:09:39,250 --> 00:09:42,900
>> 堆，另一方面，升
这里，不是功能，

209
00:09:42,900 --> 00:09:44,380
不为局部变量。

210
00:09:44,380 --> 00:09:48,920
这是动态分配
变量。

211
00:09:48,920 --> 00:09:57,210
因此，这些变量可以是
在任何主要或初始化

212
00:09:57,210 --> 00:09:58,640
函数主要调用。

213
00:09:58,640 --> 00:10:00,790
在任何地方你的代码，它们
可以初始化。

214
00:10:00,790 --> 00:10:04,360
并初始化一个动态
分配的变量。

215
00:10:04,360 --> 00:10:06,970
我们使用什么函数C语言？

216
00:10:06,970 --> 00:10:07,600
>> 学生：malloc的。

217
00:10:07,600 --> 00:10:09,240
>> JASON HIRSCHHORN：malloc的。

218
00:10:09,240 --> 00:10:10,800
你调用malloc。

219
00:10:10,800 --> 00:10:12,260
你得到的内存空间。

220
00:10:12,260 --> 00:10:15,020
和内存空间
是在堆上。

221
00:10:15,020 --> 00:10:18,840
和内存空间保持
在那里，直到你打电话免费。

222
00:10:18,840 --> 00:10:22,670
>> 在这样动态分配的变量
将堆，只要存在你

223
00:10:22,670 --> 00:10:25,250
希望他们存在，他们不会
走开，直到您明确

224
00:10:25,250 --> 00:10:26,760
告诉他们走开。

225
00:10:26,760 --> 00:10:29,670
你可以在一个函数中创建它们。

226
00:10:29,670 --> 00:10:31,930
该函数的栈
框架会自动消失。

227
00:10:31,930 --> 00:10:35,490
但该变量仍然存在
在堆中，直到它被释放，

228
00:10:35,490 --> 00:10:39,650
可能通过调用该函数
二进制搜索或什么的。

229
00:10:39,650 --> 00:10:42,580
>> 因此，那些堆变量呆在那里
只要你想

230
00:10:42,580 --> 00:10:43,490
他们呆在那里。

231
00:10:43,490 --> 00:10:46,090
而他们得到放在这里。

232
00:10:46,090 --> 00:10:47,450
然后下一个被放在那里。

233
00:10:47,450 --> 00:10:50,210
他们不断得到填补，而他们
呆在那里，直到你调用free。

234
00:10:50,210 --> 00:10:52,870
>> 而且基本上，堆和栈，
让马库斯的问题，

235
00:10:52,870 --> 00:10:54,500
增长向对方。

236
00:10:54,500 --> 00:10:57,730
如果他们碰上彼此，你已经
用完了所有的记忆在你的

237
00:10:57,730 --> 00:11:01,330
电脑，你的程序将退出
因为你没有任何更多的内存

238
00:11:01,330 --> 00:11:02,420
左边使用。

239
00:11:02,420 --> 00:11:07,290
在它们之间，有
可能其他的东西。

240
00:11:07,290 --> 00:11:10,980
但对于本课程的范围，你
不必担心。

241
00:11:10,980 --> 00:11:12,020
>> 所以这就是答案
你的问题。

242
00:11:12,020 --> 00:11:13,520
不用担心这个。

243
00:11:13,520 --> 00:11:15,550
但是，这是长远的答案。

244
00:11:15,550 --> 00:11:17,800
所有你需要知道的是
堆和堆栈 - 

245
00:11:17,800 --> 00:11:18,900
一开始在底部。

246
00:11:18,900 --> 00:11:19,570
堆栈一样。

247
00:11:19,570 --> 00:11:20,790
堆是在那里。

248
00:11:20,790 --> 00:11:21,990
他们也会越来越密切彼此。

249
00:11:21,990 --> 00:11:23,110
>> 如果他们碰，这是一个问题。

250
00:11:23,110 --> 00:11:24,500
你耗尽了内存。

251
00:11:24,500 --> 00:11:28,760
但同时，除了知道在哪里
它们是什么被存储在两个

252
00:11:28,760 --> 00:11:30,512
栈和堆。

253
00:11:30,512 --> 00:11:31,410
柯蒂斯。

254
00:11:31,410 --> 00:11:33,570
>> 柯蒂斯：当他们碰撞，
是一个堆栈溢出？

255
00:11:33,570 --> 00:11:35,670
>> JASON HIRSCHHORN：当他们碰撞，
这不是一个堆栈溢出。

256
00:11:35,670 --> 00:11:38,340
堆栈溢出是一个不同的区域
我们可以走了过来，如果你想。

257
00:11:38,340 --> 00:11:40,020
OK，我们会回来，在一个位。

258
00:11:40,020 --> 00:11:42,730
>> 学生：什么叫字
当他们击中对方，

259
00:11:42,730 --> 00:11:44,450
栈和堆？

260
00:11:44,450 --> 00:11:46,640
>> JASON HIRSCHHORN：就目前而言，
不用担心。

261
00:11:46,640 --> 00:11:47,750
只知道 - 

262
00:11:47,750 --> 00:11:50,530
我会回答这个问题
下课。

263
00:11:50,530 --> 00:11:52,680
如果他们碰上对方，你跑出来
的内存，因为没有更多的

264
00:11:52,680 --> 00:11:53,330
空间在那里。

265
00:11:53,330 --> 00:11:55,450
>> 学生：对不起，什么是赛格故障？

266
00:11:55,450 --> 00:11:58,710
>> JASON HIRSCHHORN：分部
故障可要求 - 

267
00:11:58,710 --> 00:12:02,240
这取决于为什么赛格故障的调用。

268
00:12:02,240 --> 00:12:06,260
有时候，你的堆栈溢出，它会
说赛格故障的错误。

269
00:12:06,260 --> 00:12:08,180
>> 学生：约提领什么
一个空的变量？

270
00:12:08,180 --> 00:12:10,040
那是段错误？

271
00:12:10,040 --> 00:12:11,480
>> JASON HIRSCHHORN：提领
一个空指针 - 

272
00:12:11,480 --> 00:12:17,850
好了，如果你有一个指针，你
设置为null，指针，调用，

273
00:12:17,850 --> 00:12:20,270
存储内存地址
作为它们的值。

274
00:12:20,270 --> 00:12:23,660
和一个空指针本质上是
存储0，在第0个

275
00:12:23,660 --> 00:12:26,670
解决该变量。

276
00:12:26,670 --> 00:12:30,010
所以为0x，0，0，0，0，等等。

277
00:12:30,010 --> 00:12:35,030
这0个内存地址，这不是
在我们的画面，那是在那里

278
00:12:35,030 --> 00:12:38,800
在某处，这是保留
对于计算机。

279
00:12:38,800 --> 00:12:40,130
我们没有被允许去触摸它。

280
00:12:40,130 --> 00:12:44,680
>> 所以，当你的程序的执行，如果
事情是试图去记忆

281
00:12:44,680 --> 00:12:48,990
地址0时，它知道
那是一个空值。

282
00:12:48,990 --> 00:12:50,820
它什么都不知道应该在那里。

283
00:12:50,820 --> 00:12:53,420
所以，如果你尝试使用的东西有
并把喜欢的东西或有

284
00:12:53,420 --> 00:12:58,355
试图去那个位置，你是
要得到一个段故障或错误。

285
00:12:58,355 --> 00:13:00,520
这是否回答你的问题？

286
00:13:00,520 --> 00:13:03,170
>> 现在我们就回去
堆栈溢出。

287
00:13:03,170 --> 00:13:09,560
事情在栈中，因为你们有
以前看过，在 - 让我们得出一个接近

288
00:13:09,560 --> 00:13:11,966
一个堆栈帧。

289
00:13:11,966 --> 00:13:15,050
可大家都看到了吗？

290
00:13:15,050 --> 00:13:16,650
因此，我们有我们的堆栈帧。

291
00:13:16,650 --> 00:13:23,260
是在拯救一个数组作为一个地方
变量在该函数。

292
00:13:23,260 --> 00:13:29,510
所以说，我们的阵列有五点。

293
00:13:29,510 --> 00:13:33,230
所有5的那些将被存储
在堆栈帧。

294
00:13:33,230 --> 00:13:37,540
>> 如果我们开始编写超越
这个数组越界 - 

295
00:13:37,540 --> 00:13:43,990
因此，如果我们开始写进去，
让我们说这是0。

296
00:13:43,990 --> 00:13:46,800
这些都是五项指标
我们的数组。

297
00:13:46,800 --> 00:13:50,980
如果我们开始编写成指标5，其中
我们没有，当我们有一个

298
00:13:50,980 --> 00:13:55,900
大小为5的数组，我们开始编写成
指标6，7，8，9，我们可以得到一个堆栈

299
00:13:55,900 --> 00:13:57,960
溢出错误。

300
00:13:57,960 --> 00:14:00,510
>> 通常它不是 - 

301
00:14:00,510 --> 00:14:04,910
你可能会惹上麻烦
如果你一走了过来。

302
00:14:04,910 --> 00:14:08,640
但是总体来说，您将获得进入
如果你有很多去了最麻烦

303
00:14:08,640 --> 00:14:12,770
和你这么远了，你去写
超过了返回地址

304
00:14:12,770 --> 00:14:16,080
函数，它是位于
栈帧的底部。

305
00:14:16,080 --> 00:14:16,520
>> 因为，对不对？

306
00:14:16,520 --> 00:14:17,670
你 - 在 - 对不起。

307
00:14:17,670 --> 00:14:18,550
不“，因为正确的。”

308
00:14:18,550 --> 00:14:20,470
>> 在栈帧中，你有
你的局部变量。

309
00:14:20,470 --> 00:14:27,090
在堆栈的最底层
帧的返回地址。

310
00:14:27,090 --> 00:14:28,790
这其中的功能
去当它结束了。

311
00:14:28,790 --> 00:14:33,750
如果你覆写回报
地址，那么当这个堆栈帧，

312
00:14:33,750 --> 00:14:36,680
当你正在经历的堆栈
框架和执行的每一行，你

313
00:14:36,680 --> 00:14:40,350
会去你的新的返回地址
这是写的，而不是有

314
00:14:40,350 --> 00:14:40,910
实际之一。

315
00:14:40,910 --> 00:14:45,050
这就是我们如何见过
一些安全漏洞

316
00:14:45,050 --> 00:14:46,780
可以与计算机发生。

317
00:14:46,780 --> 00:14:52,760
>> 所以堆栈溢出，总之，是当
您覆盖的部分在堆栈

318
00:14:52,760 --> 00:14:55,440
你应该使用的地方
变量你应该使用，并

319
00:14:55,440 --> 00:14:58,070
特别是当你开始覆盖
像重要的事情

320
00:14:58,070 --> 00:14:59,100
返回地址。

321
00:14:59,100 --> 00:15:00,090
而这也正是你会得到一个错误。

322
00:15:00,090 --> 00:15:03,980
或者甚至你可以开始
即使写入 - 

323
00:15:03,980 --> 00:15:05,370
说二进制搜索是
正上方主。

324
00:15:05,370 --> 00:15:07,790
如果覆盖了很多，你
可以写为主力。

325
00:15:07,790 --> 00:15:10,230
但是总体来说，你以前得到一个错误
然后，由于计算机知道

326
00:15:10,230 --> 00:15:12,270
你正在做的事情你
不应该做的事情。

327
00:15:12,270 --> 00:15:12,560
是啊。

328
00:15:12,560 --> 00:15:13,910
>> 学生：有什么区别
堆栈溢出之间

329
00:15:13,910 --> 00:15:16,940
和缓冲区溢出？

330
00:15:16,940 --> 00:15:19,420
>> JASON HIRSCHHORN：缓冲区溢出
是一个更通用的类型

331
00:15:19,420 --> 00:15:20,395
我刚刚描述。

332
00:15:20,395 --> 00:15:22,610
>> 学生：所以一个堆栈溢出是一种
例如缓冲区溢出。

333
00:15:22,610 --> 00:15:23,420
>> JASON HIRSCHHORN：没错。

334
00:15:23,420 --> 00:15:28,700
这是一个数组，我们可以认为，作为一个
缓冲，事情进去的空间

335
00:15:28,700 --> 00:15:30,600
这是一个堆栈缓冲区溢出。

336
00:15:30,600 --> 00:15:33,210
我们可以有一个堆缓冲区溢出。

337
00:15:33,210 --> 00:15:36,870
如果有一个缓冲器，它有常
是一个数组堆，而我们

338
00:15:36,870 --> 00:15:40,600
重写了这些界限，那么我们会
有一个堆缓冲区溢出。

339
00:15:40,600 --> 00:15:44,870
>> 和不在本课程的范围，
他们发现有点不同。

340
00:15:44,870 --> 00:15:48,040
编译器有特殊
方法检测各。

341
00:15:48,040 --> 00:15:50,660
但缓冲区溢出是一种更通用的
型我描述的，

342
00:15:50,660 --> 00:15:54,090
这是一个堆栈缓冲区溢出。

343
00:15:54,090 --> 00:15:56,240
这是否回答你的问题？

344
00:15:56,240 --> 00:15:57,910
甜蜜。

345
00:15:57,910 --> 00:16:01,850
>> 有没有什么其他的相关问题
到堆栈或堆？

346
00:16:01,850 --> 00:16:04,920

347
00:16:04,920 --> 00:16:05,510
是啊。

348
00:16:05,510 --> 00:16:08,220
>> 学生：我知道你有免费的字符串
因为他们是在堆

349
00:16:08,220 --> 00:16:09,305
而你不想泄漏内存。

350
00:16:09,305 --> 00:16:12,240
但你必须释放全局变量
和类似的东西？

351
00:16:12,240 --> 00:16:14,335
或者他们会自动释放？

352
00:16:14,335 --> 00:16:15,700
>> JASON HIRSCHHORN：好问题。

353
00:16:15,700 --> 00:16:22,340
所以在CS50.H，我们创建这个东西
你叫一个字符串。

354
00:16:22,340 --> 00:16:23,800
字符串是真的么？

355
00:16:23,800 --> 00:16:24,810
>> 学生：字数明星。

356
00:16:24,810 --> 00:16:29,180
>> JASON HIRSCHHORN：一个char明星，一个指针
到一个字符，一个指针到

357
00:16:29,180 --> 00:16:30,650
字符数组。

358
00:16:30,650 --> 00:16:32,210
这是该字符串是什么。

359
00:16:32,210 --> 00:16:36,050
因此，我们需要释放它，因为
GetString的，我们用了很多 - 

360
00:16:36,050 --> 00:16:38,370
字符串名称等于GetString的 - 

361
00:16:38,370 --> 00:16:43,560
这mallocs对我们的一些记忆
堆，然后返回一个指向

362
00:16:43,560 --> 00:16:47,230
那第一个字符
字符串，一个char明星。

363
00:16:47,230 --> 00:16:52,760
>> 所以表面上，如果你还没有
您的任何字符串的自由写作

364
00:16:52,760 --> 00:16:55,600
那你叫到目前为止，你有
被泄露一些内存。

365
00:16:55,600 --> 00:16:57,430
当然，我们还没有谈到
它，所以没有人在得到

366
00:16:57,430 --> 00:16:58,520
对于这样做的麻烦。

367
00:16:58,520 --> 00:16:59,980
但展望未来，是的。

368
00:16:59,980 --> 00:17:03,990
当你调用GetString的，你
mallocing一些空间在堆上。

369
00:17:03,990 --> 00:17:07,640
如果你不打电话免费以后的
字符串，你有内存泄漏。

370
00:17:07,640 --> 00:17:09,440
这回答你的问题？

371
00:17:09,440 --> 00:17:10,606
>> 是啊

372
00:17:10,606 --> 00:17:15,020
>> 学生：所以要做到这一点，我们使用
返回之前免费对不对？

373
00:17:15,020 --> 00:17:18,510
象，范围内的，我想，如果
我们说的一样，INT为主，内

374
00:17:18,510 --> 00:17:24,410
该代码是在那些范围
大括号，右前 - 

375
00:17:24,410 --> 00:17:26,140
你知道你会
通常把回报。

376
00:17:26,140 --> 00:17:27,950
你把自由之前？

377
00:17:27,950 --> 00:17:31,000
>> JASON HIRSCHHORN：所以，你可以把免费
无论你想要把自由。

378
00:17:31,000 --> 00:17:33,810
因为这些都是动态分配
变量，因为他们可以

379
00:17:33,810 --> 00:17:39,170
活过一个特定的范围
功能，如果你调用malloc在

380
00:17:39,170 --> 00:17:44,140
独立的功能，例如
GetString的，你可以在主调用free。

381
00:17:44,140 --> 00:17:46,050
你不需要调用它
在所述特定功能

382
00:17:46,050 --> 00:17:47,570
其中调用malloc。

383
00:17:47,570 --> 00:17:50,340
但是，你需要调用它
之前主要的回报。

384
00:17:50,340 --> 00:17:51,120
>> 它实际上取决于。

385
00:17:51,120 --> 00:17:54,960
这要看你为什么malloced的
空间摆在首位。

386
00:17:54,960 --> 00:17:57,320
有些人会打电话
释放很快。

387
00:17:57,320 --> 00:17:59,220
有些人会不叫自由，直到
他们的节目的结束。

388
00:17:59,220 --> 00:18:00,660
而且他们会通过
和自由的一切。

389
00:18:00,660 --> 00:18:03,597
这要看你为什么叫malloc的。

390
00:18:03,597 --> 00:18:11,270
>> 学生：你会说什么
如果你用所谓的GetString？

391
00:18:11,270 --> 00:18:13,320
你会说什么自由？

392
00:18:13,320 --> 00:18:20,040
>> JASON HIRSCHHORN：所以语法免费
简直是免费的，开放的括号，关闭

393
00:18:20,040 --> 00:18:22,130
括号，并且指针的名称。

394
00:18:22,130 --> 00:18:26,410
所以，如果你写的字符串名称等于
GetString的，你把名字在这里。

395
00:18:26,410 --> 00:18:27,760
这就是指针的名称。

396
00:18:27,760 --> 00:18:30,570
它知道来释放内存。

397
00:18:30,570 --> 00:18:33,920
>> 学生：所以，当它释放内存，
指针仍然指向那个地方

398
00:18:33,920 --> 00:18:34,970
在内存中？

399
00:18:34,970 --> 00:18:39,020
或者是指针也走光
它指向的地址。

400
00:18:39,020 --> 00:18:40,290
>> JASON HIRSCHHORN：我们应该尝试一下。

401
00:18:40,290 --> 00:18:41,430
我们要编写的。

402
00:18:41,430 --> 00:18:43,880
让我们回来的时候，我们得到
编码，并且让代码的。

403
00:18:43,880 --> 00:18:46,000
如果你想找出答案
这一点，你也可以代码

404
00:18:46,000 --> 00:18:46,690
在此期间。

405
00:18:46,690 --> 00:18:49,100
但是，这是一个很大的问题。

406
00:18:49,100 --> 00:18:53,480
>> 学生：有没有可能
免费的东西太快？

407
00:18:53,480 --> 00:18:58,530
所以你仍然需要它为你的程序，
而你释放内存空间？

408
00:18:58,530 --> 00:18:59,200
>> JASON HIRSCHHORN：是的。

409
00:18:59,200 --> 00:19:03,020
这是可能的，如果你免费的东西
然后你再次使用它，你会

410
00:19:03,020 --> 00:19:06,890
碰到一个错误。

411
00:19:06,890 --> 00:19:10,810
但是，这对你，因为你释放
的东西，再后来把它称为。

412
00:19:10,810 --> 00:19:13,940
所以这是一个程序员的失误。

413
00:19:13,940 --> 00:19:14,780
但肯定的。

414
00:19:14,780 --> 00:19:17,760
你可以写。

415
00:19:17,760 --> 00:19:19,240
>> 任何更多的问题 - 

416
00:19:19,240 --> 00:19:19,760
是。

417
00:19:19,760 --> 00:19:22,820
>> 学生：所以，如果你都应该只是
释放它一般前

418
00:19:22,820 --> 00:19:25,490
程序结束，是否意味着如果
程序结束，你不释放它，

419
00:19:25,490 --> 00:19:27,580
该内存仍分配呢？

420
00:19:27,580 --> 00:19:31,330
>> JASON HIRSCHHORN：如果你的程序结束
你忘记释放的东西，那么

421
00:19:31,330 --> 00:19:34,390
这整个内存分配
你的程序的生命周期。

422
00:19:34,390 --> 00:19:37,670
当你的程序完全关闭，
该内存是不会

423
00:19:37,670 --> 00:19:39,490
要永远呆在那里。

424
00:19:39,490 --> 00:19:42,080
计算机是足够聪明，知道
该程序关闭时，它

425
00:19:42,080 --> 00:19:46,440
要摆脱所有的内存的那
是与该程序相关联。

426
00:19:46,440 --> 00:19:51,240
>> 不过，也有可以运行的工具
在一个程序来检测，如果当

427
00:19:51,240 --> 00:19:54,720
程序完成后，您忘了
以释放一些内存。

428
00:19:54,720 --> 00:19:57,960
并为你的下一个问题集，其中
您将要使用的malloc和使用

429
00:19:57,960 --> 00:20:02,610
指针，你将要运行此
编写你的程序，如果看到，

430
00:20:02,610 --> 00:20:06,530
当主的回报，你有一些
所剩下未释放的东西。

431
00:20:06,530 --> 00:20:09,130
>> 所以他们不会留malloced
永远留在你的电脑上。

432
00:20:09,130 --> 00:20:11,720
这将是浪费的，因为
很快，电脑

433
00:20:11,720 --> 00:20:12,960
会耗尽内存。

434
00:20:12,960 --> 00:20:16,450
但是，如果他们跑，直到你的结尾
编程和他们不释放，你的

435
00:20:16,450 --> 00:20:20,260
程序退出，这仍然是一个问题
这一工具将帮助您解决。

436
00:20:20,260 --> 00:20:21,520
>> 学生：那是Valgrind的？

437
00:20:21,520 --> 00:20:22,910
>> JASON HIRSCHHORN：这是
所谓Valgrind的。

438
00:20:22,910 --> 00:20:23,520
，你会 - 

439
00:20:23,520 --> 00:20:25,780
>> 学生：但是，我们不必知道
对于测验有关系吗？

440
00:20:25,780 --> 00:20:27,600
我的意思是，有人谈到了
在演讲一点点。

441
00:20:27,600 --> 00:20:33,600
>> JASON HIRSCHHORN：所以Valgrind的
是，工具的名称。

442
00:20:33,600 --> 00:20:37,180
知道它的作用是
足够的测验。

443
00:20:37,180 --> 00:20:40,200
可是你有没有使用它在您的
问题的设置，因为我们还没有一个

444
00:20:40,200 --> 00:20:43,520
已明确处理问题集
使用malloc或您使用malloc。

445
00:20:43,520 --> 00:20:45,330
所以，你还没有使用Valgrind的呢。

446
00:20:45,330 --> 00:20:47,760
但你迟早会使用它
而不是以后。

447
00:20:47,760 --> 00:20:48,710
>> 学生：你能重复
什么Valgrind是？

448
00:20:48,710 --> 00:20:49,190
>> JASON HIRSCHHORN：对不起？

449
00:20:49,190 --> 00:20:51,240
>> 学生：你能重复
Valgring的目的是什么？

450
00:20:51,240 --> 00:20:53,100
>> JASON HIRSCHHORN：Valgrind的
是名称 - 

451
00:20:53,100 --> 00:20:59,890
像GDB可以帮助你调试你的程序，
Valgrind的可以帮助你计算出，如果

452
00:20:59,890 --> 00:21:03,210
事情还没有被释放
当你的程序关闭。

453
00:21:03,210 --> 00:21:05,110
所以，你会在你的程序运行它。

454
00:21:05,110 --> 00:21:09,230
和你的程序退出时，它会说
你的程序调用malloc的这么多

455
00:21:09,230 --> 00:21:13,670
时间这么多字节，而你
只有所谓的自由很多次。

456
00:21:13,670 --> 00:21:16,520
所以你离开了这些多少字节
没有被释放。

457
00:21:16,520 --> 00:21:18,050
或者，它会说你已经释放了一切。

458
00:21:18,050 --> 00:21:19,070
干得好。

459
00:21:19,070 --> 00:21:19,480
>> 学生：确定。

460
00:21:19,480 --> 00:21:21,060
它叫做Valgring？

461
00:21:21,060 --> 00:21:24,940
>> JASON HIRSCHHORN：V-A-L-G-R-I-N-D。

462
00:21:24,940 --> 00:21:25,970
>> 学生：关于指针的一个问题。

463
00:21:25,970 --> 00:21:30,080
所以说你有N个明星
x等于什么。

464
00:21:30,080 --> 00:21:33,330
这相当于，不管你把
还有，是什么正在里面放

465
00:21:33,330 --> 00:21:36,120
X是什么指向，
或x的指针？

466
00:21:36,120 --> 00:21:37,690
>> JASON HIRSCHHORN：你能
重复的问题？

467
00:21:37,690 --> 00:21:39,340
我们可以借鉴它，而你说了吗？

468
00:21:39,340 --> 00:21:42,710
>> 学生：在测验，其实，
一个你给我们送来，就好像，烧焦

469
00:21:42,710 --> 00:21:46,520
星级真相等于CS50岩石，对不对？

470
00:21:46,520 --> 00:21:52,190
那么，这是否意味着该CS50岩石
是什么样的真相是指向？

471
00:21:52,190 --> 00:21:55,810
>> JASON HIRSCHHORN：所以你说
大约一个char明星在一个字符串中，如何

472
00:21:55,810 --> 00:21:56,460
的作品？

473
00:21:56,460 --> 00:21:56,890
是啊。

474
00:21:56,890 --> 00:21:57,700
确定。

475
00:21:57,700 --> 00:21:59,140
让我们得出这样的在这里。

476
00:21:59,140 --> 00:22:07,100
>> [SIDE会话]

477
00:22:07,100 --> 00:22:11,130
>> JASON HIRSCHHORN：所以这个变量
将是char类型的明星。

478
00:22:11,130 --> 00:22:14,580
多大是一个变量
的char类型的明星？

479
00:22:14,580 --> 00:22:15,510
有多少字节？

480
00:22:15,510 --> 00:22:16,450
>> 学生：四。

481
00:22:16,450 --> 00:22:18,210
>> JASON HIRSCHHORN：这是四个字节。

482
00:22:18,210 --> 00:22:21,420
有多少权利是一个变量
int类型的明星？

483
00:22:21,420 --> 00:22:22,210
>> 学生：四。

484
00:22:22,210 --> 00:22:24,910
>> JASON HIRSCHHORN：四个字节。

485
00:22:24,910 --> 00:22:28,280
如果它是一个指针，那么它始终是
4个字节，因为指针，其

486
00:22:28,280 --> 00:22:30,070
值是一个存储器地址。

487
00:22:30,070 --> 00:22:35,160
而在CS50内存地址
家电是四个字节长。

488
00:22:35,160 --> 00:22:42,900
因此，当我们需要调用getString，或当我们
也就是说，字符串名称等于，然后在

489
00:22:42,900 --> 00:22:46,140
双引号把一个字符串，
我们正在把 - 

490
00:22:46,140 --> 00:22:46,920
好了，这是一个有点不同。

491
00:22:46,920 --> 00:22:48,630
我们会做的GetString为例。

492
00:22:48,630 --> 00:22:52,150
或char星级东西
等于字符串。

493
00:22:52,150 --> 00:22:54,360
对不起，给我的例子
你读？

494
00:22:54,360 --> 00:22:57,590
>> 学生：字符星级等于真相
在双引号“CS50石头”。

495
00:22:57,590 --> 00:23:02,260
>> JASON HIRSCHHORN：那么这颗星，这
我们将调用这个变量x为

496
00:23:02,260 --> 00:23:04,060
通用的目的。

497
00:23:04,060 --> 00:23:05,970
我们已经创建了一个变量x。

498
00:23:05,970 --> 00:23:07,610
这是char类型的明星。

499
00:23:07,610 --> 00:23:10,950
它是一个指向一个系列
字符。

500
00:23:10,950 --> 00:23:12,200
这样下来在这里 - 

501
00:23:12,200 --> 00:23:23,710

502
00:23:23,710 --> 00:23:25,890
>> 因此，这是该会怎样
在内存中运行。

503
00:23:25,890 --> 00:23:27,410
这将存储的存储器地址。

504
00:23:27,410 --> 00:23:31,770
将存储的存储器地址
阵列中的第一个字符。

505
00:23:31,770 --> 00:23:33,830
然后你按照时
指针，你会

506
00:23:33,830 --> 00:23:35,200
得到第一个字符。

507
00:23:35,200 --> 00:23:38,780
>> 如果你正在读这篇东西一样
一个字符串，你的电脑是智能

508
00:23:38,780 --> 00:23:42,930
足以知道，阅读这件事
直到它到达一个反弹0。

509
00:23:42,930 --> 00:23:45,530
但是，如果你正在阅读这一个字符
一时间，所以你通过迭代

510
00:23:45,530 --> 00:23:49,910
这个字符串，那么你将只是一个读
字符一次，直到你到达

511
00:23:49,910 --> 00:23:50,850
反斜杠0。

512
00:23:50,850 --> 00:23:52,335
可能不会回答你的
的问题，虽然。

513
00:23:52,335 --> 00:23:55,610
>> 学生：是啊，但你有没有
malloced的空间

514
00:23:55,610 --> 00:23:58,400
但对于该指针。

515
00:23:58,400 --> 00:24:02,510
>> JASON HIRSCHHORN：所以我不太清楚
正是你要找什么，

516
00:24:02,510 --> 00:24:03,640
因为我没有作出这样的测验。

517
00:24:03,640 --> 00:24:06,370
这应该是一个有益的
从另一个TF资源。

518
00:24:06,370 --> 00:24:11,380
如果你是在创建一个字符串
堆栈或局部变量，它会

519
00:24:11,380 --> 00:24:16,920
只是数组的费用，而不是
一般一个char星级指向

520
00:24:16,920 --> 00:24:18,600
另一个字符串。

521
00:24:18,600 --> 00:24:20,550
但我不知道。

522
00:24:20,550 --> 00:24:25,065
这可能是一个指向另一个
在堆栈上字符串。

523
00:24:25,065 --> 00:24:27,240
是啊。

524
00:24:27,240 --> 00:24:31,116
>> 学生：我知道你需要
分配内存，如果指针

525
00:24:31,116 --> 00:24:33,360
越来越声明内
另一个函数。

526
00:24:33,360 --> 00:24:36,740
你需要做同样的事情，如果是
主内被宣布，

527
00:24:36,740 --> 00:24:39,570
你使用它的主内？

528
00:24:39,570 --> 00:24:43,590
>> JASON HIRSCHHORN：所以，是的。

529
00:24:43,590 --> 00:24:46,670
你可以声明一个指向任何
在内存中的内存地址。

530
00:24:46,670 --> 00:24:51,440
它可以是一个本地的存储器地址
变，但通常情况下，

531
00:24:51,440 --> 00:24:55,760
人不申报的内存地址
局部变量，因为他们去

532
00:24:55,760 --> 00:24:59,890
一旦离开该函数返回，这
所以我们一般用malloc的东西。

533
00:24:59,890 --> 00:25:04,630
但是，是的，你可以声明一个指针
另一个局部变量。

534
00:25:04,630 --> 00:25:06,360
这只是一般没有这样做。

535
00:25:06,360 --> 00:25:09,480
但是我可以看看那个
下课后具体的事情。

536
00:25:09,480 --> 00:25:10,650
是啊。

537
00:25:10,650 --> 00:25:12,350
>> 学生：我认为这是排序
什么的被问。

538
00:25:12,350 --> 00:25:16,930
它似乎奇怪进行初始化
一个指针而不是作为一个

539
00:25:16,930 --> 00:25:20,760
地址，但正如
似乎是一个值。

540
00:25:20,760 --> 00:25:25,970
这似乎是CS50是里面有什么
事情被指向和

541
00:25:25,970 --> 00:25:28,820
没有实际的地址，对吧？

542
00:25:28,820 --> 00:25:30,520
>> JASON HIRSCHHORN：所以这是
不是这种情况，虽然。

543
00:25:30,520 --> 00:25:32,470
这不是发生了什么。

544
00:25:32,470 --> 00:25:35,910
当你声明一个char星，
这是一个内存地址。

545
00:25:35,910 --> 00:25:38,860
指针是所有的内存地址
指着别的东西。

546
00:25:38,860 --> 00:25:41,480
别的东西可能是在
栈，但几乎总是是在

547
00:25:41,480 --> 00:25:43,440
堆在我们将看到它的使用方式。

548
00:25:43,440 --> 00:25:46,860

549
00:25:46,860 --> 00:25:53,500
但字符串名称等于双引号
“GetString的，”我们可以看到，和我们

550
00:25:53,500 --> 00:25:55,010
可以看看通过和代码。

551
00:25:55,010 --> 00:26:01,190
GetString的字符串没有被保存在
该变量，或任何字符串

552
00:26:01,190 --> 00:26:04,580
名字没有被保存在
变量，因为这不是如何

553
00:26:04,580 --> 00:26:06,070
指针工作。

554
00:26:06,070 --> 00:26:06,770
这是否有道理？

555
00:26:06,770 --> 00:26:07,170
>> 学生：是啊。

556
00:26:07,170 --> 00:26:08,570
>> JASON HIRSCHHORN：确定。

557
00:26:08,570 --> 00:26:11,690
但愿，这不是
混乱给任何人。

558
00:26:11,690 --> 00:26:15,732
但如果是，我们可以再看看它
在一个位，因为我们实际上会

559
00:26:15,732 --> 00:26:19,240
以代码的东西，希望能
处理字符串的工作和让你感觉

560
00:26:19,240 --> 00:26:22,170
更舒适的他们。

561
00:26:22,170 --> 00:26:24,869
>> 与这些其他问题
主题或其他主题，

562
00:26:24,869 --> 00:26:26,119
我要把备份？

563
00:26:26,119 --> 00:26:32,280

564
00:26:32,280 --> 00:26:34,840
和 - 

565
00:26:34,840 --> 00:26:36,310
现在。

566
00:26:36,310 --> 00:26:37,630
是的，奥尔登。

567
00:26:37,630 --> 00:26:39,860
>> 奥尔登：所以这是完全不相关的，
但我们只是去了

568
00:26:39,860 --> 00:26:42,760
真的很快我们所需要知道的
大约32和之间的差

569
00:26:42,760 --> 00:26:46,345
64位机？

570
00:26:46,345 --> 00:26:47,740
>> JASON HIRSCHHORN：是的。

571
00:26:47,740 --> 00:26:52,111
因此，32位是多少字节？

572
00:26:52,111 --> 00:26:53,060
>> 奥尔登：这是四个字节。

573
00:26:53,060 --> 00:26:54,360
>> JASON HIRSCHHORN：这是四个字节。

574
00:26:54,360 --> 00:26:58,420
和64位是多少字节？

575
00:26:58,420 --> 00:26:59,112
>> 学生：八。

576
00:26:59,112 --> 00:27:00,610
>> JASON HIRSCHHORN：8个字节。

577
00:27:00,610 --> 00:27:03,980
如此反复，八位为一字节。

578
00:27:03,980 --> 00:27:08,340
您的CS50设备是
一个32位的机器。

579
00:27:08,340 --> 00:27:13,650
因此，内存地址
四字节长。

580
00:27:13,650 --> 00:27:17,460
有2到32个
内存地址。

581
00:27:17,460 --> 00:27:21,310
0到2至32减去1。

582
00:27:21,310 --> 00:27:27,630
而我不是正面的，但是这
什么，你需要大概的范围

583
00:27:27,630 --> 00:27:35,230
知道一个32位的机器，该内存
地址是，再次，四字节长，

584
00:27:35,230 --> 00:27:39,620
这就是最高金额
内存地址。

585
00:27:39,620 --> 00:27:41,680
>> 此外，数据类型 - 

586
00:27:41,680 --> 00:27:45,020
这可能是由于东西
那么这是值得注意的。

587
00:27:45,020 --> 00:27:49,610
一个数据类型的大小取决于
您正在使用的机器。

588
00:27:49,610 --> 00:27:56,760
因此，一个字符，一个字符，是怎么
多少个字节我们CS50设备？

589
00:27:56,760 --> 00:27:57,980
一个字节。

590
00:27:57,980 --> 00:28:02,310
它实际上是一个字节作为
以及一个64位的机器上。

591
00:28:02,310 --> 00:28:05,920
>> 和大多数数据类型是相同的数
的字节在两台机器上。

592
00:28:05,920 --> 00:28:11,620
但某些数据类型会有所不同
在两台机器上。

593
00:28:11,620 --> 00:28:14,590
所以这将是可能的
只有你需要知道的事情。

594
00:28:14,590 --> 00:28:16,710
>> 但即使这样，我认为，
超出了界限 - 

595
00:28:16,710 --> 00:28:20,990
我几乎可以肯定，如果你回头看
在旧的测验，它说，承担

596
00:28:20,990 --> 00:28:24,090
编码你使用的问题
一个32位的机器。

597
00:28:24,090 --> 00:28:26,620

598
00:28:26,620 --> 00:28:30,620
但也有，一起去，在
如果你有兴趣，有

599
00:28:30,620 --> 00:28:35,920
是相同的数据类型
尺寸上的所有机器。

600
00:28:35,920 --> 00:28:42,670
>> 如果你看过类似的东西
uint32_t的，你可能会或可能

601
00:28:42,670 --> 00:28:43,260
没有看到这一点。

602
00:28:43,260 --> 00:28:44,290
这是一个数据类型。

603
00:28:44,290 --> 00:28:47,570
这是说，有32位不管
什么机器，这是上。

604
00:28:47,570 --> 00:28:50,350
所以，当人们编写可移植
代码，他们可能不会使用int类型。

605
00:28:50,350 --> 00:28:53,260
他们会转而使用其他这些数据
他们知道类型将是相同的

606
00:28:53,260 --> 00:28:54,780
大小每一个机器上。

607
00:28:54,780 --> 00:28:58,080

608
00:28:58,080 --> 00:28:58,250
马杜。

609
00:28:58,250 --> 00:29:00,150
>> MADHU：我有一个问题是关于
编译过程。

610
00:29:00,150 --> 00:29:04,110
所以，如果你正在编写一个使用程序
像CS50什么的图书馆

611
00:29:04,110 --> 00:29:06,840
这样，我知道该库
有，在某些时候，可

612
00:29:06,840 --> 00:29:08,590
编译和链接英寸

613
00:29:08,590 --> 00:29:13,380
但其中有多少过程中发生
你的程序的编译？

614
00:29:13,380 --> 00:29:15,880
该库程序的哪一部分
当你出现

615
00:29:15,880 --> 00:29:18,560
编译你自己的程序？

616
00:29:18,560 --> 00:29:24,020
>> JASON HIRSCHHORN：让我们去了
通常的步骤这一过程的。

617
00:29:24,020 --> 00:29:26,280
你写你的c文件。

618
00:29:26,280 --> 00:29:33,530
在你的c文件，你的＃include你
头的库，例如，cs50.h.

619
00:29:33,530 --> 00:29:39,480
什么是尖锐的，包括
行做你的计划吗？

620
00:29:39,480 --> 00:29:40,525
Akchar。

621
00:29:40,525 --> 00:29:43,350
>> AKCHAR：它增加的原型
从标题中的功能

622
00:29:43,350 --> 00:29:45,120
在库中的文件。

623
00:29:45,120 --> 00:29:45,600
>> JASON HIRSCHHORN：没错。

624
00:29:45,600 --> 00:29:49,870
它增加了这些函数原型
你的代码。

625
00:29:49,870 --> 00:29:55,230
所以，当你的代码被编译
在早期阶段，编译器知道

626
00:29:55,230 --> 00:29:59,250
这些功能真的存在，
在某个地方，他们已经确定。

627
00:29:59,250 --> 00:30:02,460
h文件不包含
定义这些函数或如何

628
00:30:02,460 --> 00:30:03,950
他们的实际工作。

629
00:30:03,950 --> 00:30:07,960
Cs50.h只是包括一些说
GetString的是一个真正的东西，

630
00:30:07,960 --> 00:30:09,270
可能发生。

631
00:30:09,270 --> 00:30:14,240
和standardio.h说printf的是
一个真实的东西，可以发生。

632
00:30:14,240 --> 00:30:23,190
>> 所以用这个你的c语言实现。头
文件被变成了一些

633
00:30:23,190 --> 00:30:27,750
机器可读的代码，最终
被转换为二进制

634
00:30:27,750 --> 00:30:30,030
代码0和1。

635
00:30:30,030 --> 00:30:33,590
这就是代码，最终
被执行。

636
00:30:33,590 --> 00:30:38,550
使用-l CS50线 - 例如，
当你写锵 - 

637
00:30:38,550 --> 00:30:41,830
然后就包括-L CS50，
你键入英寸

638
00:30:41,830 --> 00:30:42,180
你可以看到这一点。

639
00:30:42,180 --> 00:30:43,890
当你写做，你会
看到这条线在这里。

640
00:30:43,890 --> 00:30:47,740
我们将看到，在第二个时
我们的代码或当我们的代码以后。

641
00:30:47,740 --> 00:30:50,390
>> 但这-L CS50线做一些事情
比有点不同

642
00:30:50,390 --> 00:30:52,440
＃包括cs50.h.

643
00:30:52,440 --> 00:30:56,300
这是什么-L CS50行吗？

644
00:30:56,300 --> 00:30:56,820
阿维？

645
00:30:56,820 --> 00:31:00,310
>> AVI：我想说的是，它链接
图书馆的功能

646
00:31:00,310 --> 00:31:02,710
打电话，像。o文件。

647
00:31:02,710 --> 00:31:08,200
>> JASON HIRSCHHORN：所以很
接近，如果不是当场上。

648
00:31:08,200 --> 00:31:16,220
使用-l CS50采用的二进制文件，
与您的二进制文件将其合并。

649
00:31:16,220 --> 00:31:21,410
所以cs50.h，有车削没有点
从C语言cs50.h为二进制每

650
00:31:21,410 --> 00:31:23,130
单一次它被使用。

651
00:31:23,130 --> 00:31:26,650
那将是愚蠢的，因为这
会浪费很多时间。

652
00:31:26,650 --> 00:31:30,420
所以它已经被编译
，变成一个可执行文件。

653
00:31:30,420 --> 00:31:35,430
现在它要被合并
与您的文件结尾。

654
00:31:35,430 --> 00:31:38,370
因此，那些1和0的打算
与您的那些合并

655
00:31:38,370 --> 00:31:39,150
和0结尾。

656
00:31:39,150 --> 00:31:43,670
所以，现在你会真正有实际
1和0的定义如何GetString的，

657
00:31:43,670 --> 00:31:47,890
例如，工作，还是怎么的printf，
例如，工作。

658
00:31:47,890 --> 00:31:52,750
>> 而对于更多的信息，有一个
总之编译器内特给出了

659
00:31:52,750 --> 00:31:55,410
你应该检查出云
通过这些步骤。

660
00:31:55,410 --> 00:31:56,050
但是 - 

661
00:31:56,050 --> 00:31:56,560
是。

662
00:31:56,560 --> 00:32:01,700
>> 学生：他们总是在o文件。
当他们在图书馆的形式，

663
00:32:01,700 --> 00:32:06,764
准备合并，链接 - 像
他们在二进制代码吗？

664
00:32:06,764 --> 00:32:07,600
>> JASON HIRSCHHORN：确定。

665
00:32:07,600 --> 00:32:08,420
什么 - 

666
00:32:08,420 --> 00:32:11,780
>> 学生：那是经常的情况下，
该库时将它们链接？

667
00:32:11,780 --> 00:32:12,500
>> JASON HIRSCHHORN：是的。

668
00:32:12,500 --> 00:32:17,300
因此，有。s个文件，这将是
机代码，这也将是

669
00:32:17,300 --> 00:32:17,975
神秘的给你。

670
00:32:17,975 --> 00:32:19,410
你不必担心这些。

671
00:32:19,410 --> 00:32:24,930
但是总体来说，是的，他们会
是。o文件准备好了。

672
00:32:24,930 --> 00:32:27,170
>> 学生：所以，当你运送到
一个库，你只船

673
00:32:27,170 --> 00:32:28,880
的，H和。Ö？

674
00:32:28,880 --> 00:32:32,210
你不出货。c或。秒。

675
00:32:32,210 --> 00:32:33,070
>> JASON HIRSCHHORN：那么 - 

676
00:32:33,070 --> 00:32:36,260
这就是在这短短的为好，如果
这一信息似乎是一个未来

677
00:32:36,260 --> 00:32:36,700
快一点。

678
00:32:36,700 --> 00:32:39,870
但短期的编译器
关于这个谈判也是如此。

679
00:32:39,870 --> 00:32:43,290
当你船库，如果你出货
在H，头文件，这些

680
00:32:43,290 --> 00:32:46,290
函数原型，以及1和
0的，这就是你需要给。

681
00:32:46,290 --> 00:32:50,640
你并不需要给该如何
函数的工作原理，在c文件。

682
00:32:50,640 --> 00:32:56,360
因为该点的抽象，或
点的API，该点在这个SPL，

683
00:32:56,360 --> 00:32:59,650
斯坦福便携图书馆，它的
让你不用担心如何将新

684
00:32:59,650 --> 00:33:04,220
GRect工作，或如何移动工作，
或如何添加工作。

685
00:33:04,220 --> 00:33:06,520
所有你需要知道的是，加
是一个函数，你可以

686
00:33:06,520 --> 00:33:08,880
使用，并且它这样做。

687
00:33:08,880 --> 00:33:12,760
所以，你真的不需要知道如何
它是用C编写的，您只需要

688
00:33:12,760 --> 00:33:15,460
知道，这里是函数，他们
做的，这里是1和0

689
00:33:15,460 --> 00:33:18,870
当你真的想使用它们。

690
00:33:18,870 --> 00:33:19,530
>> 凉爽。

691
00:33:19,530 --> 00:33:26,980
在编译器的任何其他问题
或电路板上的其他议题是什么？

692
00:33:26,980 --> 00:33:30,300
>> 学生：我有一个问题
实现递归函数。

693
00:33:30,300 --> 00:33:31,170
关于递归的一个问题。

694
00:33:31,170 --> 00:33:33,030
我会想出一个感觉。

695
00:33:33,030 --> 00:33:38,310
因此，让我们快速浏览一下
递归与特定

696
00:33:38,310 --> 00:33:40,690
例如，阶乘函数。

697
00:33:40,690 --> 00:33:44,920
因为这是一个例子，
经常出现或使用

698
00:33:44,920 --> 00:33:46,170
来说明递归。

699
00:33:46,170 --> 00:33:52,390

700
00:33:52,390 --> 00:33:56,410
>> 因此，“4！”读作4的阶乘。

701
00:33:56,410 --> 00:33:59,120
又是什么4的阶乘是什么意思？

702
00:33:59,120 --> 00:34:00,696
那是什么呢？

703
00:34:00,696 --> 00:34:02,235
如何计算4的阶乘？

704
00:34:02,235 --> 00:34:05,250

705
00:34:05,250 --> 00:34:07,960
4倍3倍2倍1。

706
00:34:07,960 --> 00:34:11,889
>> 因此，另一种方式来写4的阶乘
就是写这个。

707
00:34:11,889 --> 00:34:16,780

708
00:34:16,780 --> 00:34:19,022
4次3的阶乘。

709
00:34:19,022 --> 00:34:22,080
因为3是阶乘
3倍2倍1。

710
00:34:22,080 --> 00:34:27,580
所以，4次3因子为4
倍3倍2倍1。

711
00:34:27,580 --> 00:34:32,679
这就是为什么阶乘是一个伟大的
候选人递归，因为它是

712
00:34:32,679 --> 00:34:36,630
显然，有一些东西，
发生一遍又一遍又一遍的

713
00:34:36,630 --> 00:34:39,820
更小的一些事情，直到
你到达终点。

714
00:34:39,820 --> 00:34:42,570
当你达到1,1的阶乘为1。

715
00:34:42,570 --> 00:34:43,719
你不能走得更远。

716
00:34:43,719 --> 00:34:47,219
0阶乘也被定义为1。

717
00:34:47,219 --> 00:34:50,679
所以，当你到达1或0，你
在最后，你可以

718
00:34:50,679 --> 00:34:53,219
就回去了。

719
00:34:53,219 --> 00:34:59,540
因此，如果我们想写一个递归
函数来计算阶乘，

720
00:34:59,540 --> 00:35:02,170
我们将编写一些
伪不动了。

721
00:35:02,170 --> 00:35:03,300
在我们写的伪代码 - 

722
00:35:03,300 --> 00:35:05,660
我给你们一，两分钟
写的伪代码或者只是想

723
00:35:05,660 --> 00:35:09,600
它 - 有两件事情每
递归函数需要。

724
00:35:09,600 --> 00:35:12,530
什么是这两件事情？

725
00:35:12,530 --> 00:35:13,220
>> 杰克：它调用自身。

726
00:35:13,220 --> 00:35:13,680
>> JASON HIRSCHHORN：诺亚？

727
00:35:13,680 --> 00:35:14,460
噢，杰克。

728
00:35:14,460 --> 00:35:15,100
来吧。

729
00:35:15,100 --> 00:35:16,640
>> 杰克：它调用自身。

730
00:35:16,640 --> 00:35:19,220
>> JASON HIRSCHHORN：所以递归
函数需要一个递归调用，

731
00:35:19,220 --> 00:35:20,220
打电话给自己。

732
00:35:20,220 --> 00:35:20,770
这是一。

733
00:35:20,770 --> 00:35:21,510
这有什么其他的事情？

734
00:35:21,510 --> 00:35:22,250
>> 杰克：一个基本情况。

735
00:35:22,250 --> 00:35:23,780
>> JASON HIRSCHHORN：一个基本情况。

736
00:35:23,780 --> 00:35:26,940
一个基本的情况是，当我们停在这里的。

737
00:35:26,940 --> 00:35:29,510
所以，你的函数被调用。

738
00:35:29,510 --> 00:35:31,410
基本情况是第一位的。

739
00:35:31,410 --> 00:35:33,710
你要知道，如果你在最后。

740
00:35:33,710 --> 00:35:37,110
如果你不是在结束时，你
让你的递归调用。

741
00:35:37,110 --> 00:35:39,880
和你又来了通过这个功能，
再次检查你的基本情况。

742
00:35:39,880 --> 00:35:42,575
如果你还没结束，你做
另一个递归调用，

743
00:35:42,575 --> 00:35:44,130
等等，等等。

744
00:35:44,130 --> 00:35:47,110
>> 这就是为什么递归函数总是
需要这些基础情况和那些

745
00:35:47,110 --> 00:35:48,210
递归调用。

746
00:35:48,210 --> 00:35:51,280
如果你没有一个递归调用，它
不会是一个递归函数。

747
00:35:51,280 --> 00:35:53,210
如果你没有一个基本情况，
如果你想走到永远

748
00:35:53,210 --> 00:35:54,780
不会有什么结局。

749
00:35:54,780 --> 00:35:57,870
和基本情况永远是第一位，
因为你永远要检查

750
00:35:57,870 --> 00:36:00,420
如果你在结束第一。

751
00:36:00,420 --> 00:36:04,770
所以在我们做一些伪代码，为什么
你不花一分钟思考

752
00:36:04,770 --> 00:36:09,360
如何递归阶乘函数
会写的？

753
00:36:09,360 --> 00:36:23,340

754
00:36:23,340 --> 00:36:26,010
>> 此外，多达你在做什么，写
它列于一张纸是

755
00:36:26,010 --> 00:36:27,960
你要什么有
做测验的明天。

756
00:36:27,960 --> 00:36:32,160
所以大概好的做法，使
确保你写的代码

757
00:36:32,160 --> 00:36:34,420
倒在纸上 - 

758
00:36:34,420 --> 00:36:35,160
或者你可以做到这一点。

759
00:36:35,160 --> 00:36:36,710
你知道哪里有分号。

760
00:36:36,710 --> 00:36:37,660
你还记得的语法。

761
00:36:37,660 --> 00:36:40,400
因为你不能够有一个
编译器告诉你犯了一个错误。

762
00:36:40,400 --> 00:37:02,356

763
00:37:02,356 --> 00:37:07,240
>> 此外，沿着这些线路，明天，当
您已编码的问题，如果你

764
00:37:07,240 --> 00:37:11,490
都冲了时间，或者如果你是非常
困惑，如何你应该

765
00:37:11,490 --> 00:37:16,030
写特别的事情在C，它
会理所当然你写的伪代码

766
00:37:16,030 --> 00:37:18,160
或写评论为好。

767
00:37:18,160 --> 00:37:21,940
因为有一部份信贷
很多对测验的问题。

768
00:37:21,940 --> 00:37:24,840
所以，你可能操之过急，否则你
可能只是混淆。

769
00:37:24,840 --> 00:37:28,030
写在注释或伪代码
通常的方式，你

770
00:37:28,030 --> 00:37:29,360
可以得到部分分数。

771
00:37:29,360 --> 00:37:31,440
>> 所以，不要留下遗憾
在测验的空白。

772
00:37:31,440 --> 00:37:33,490
有没有处罚
把东西英寸

773
00:37:33,490 --> 00:37:37,650
实际上，投入在伪码或
意见是要帮助的平地机

774
00:37:37,650 --> 00:37:40,410
搞清楚，如果你真的知道什么
你在说什么，或许大奖

775
00:37:40,410 --> 00:37:42,030
你为一些局部的信用。

776
00:37:42,030 --> 00:37:44,510
>> 还沿着这些线路，写清楚。

777
00:37:44,510 --> 00:37:47,650
如果我们真的不能你写的东西，
我们不会给你打电话

778
00:37:47,650 --> 00:37:49,900
在明天午​​夜图
出你写什么。

779
00:37:49,900 --> 00:37:51,520
我们只是要起飞点。

780
00:37:51,520 --> 00:37:56,570
写清楚，以便我们能听到，或者更确切地说，
我们可以读你写的。

781
00:37:56,570 --> 00:38:00,230
>> 如果它说两句话，
不写的一段话。

782
00:38:00,230 --> 00:38:02,280
按照说明进行操作。

783
00:38:02,280 --> 00:38:03,500
写清楚。

784
00:38:03,500 --> 00:38:07,720
写这些意见或
伪代码的问题，可能

785
00:38:07,720 --> 00:38:10,270
奖励部分信贷。

786
00:38:10,270 --> 00:38:12,520
>> 好了，让我们去阶乘。

787
00:38:12,520 --> 00:38:15,000
所以我们有一个函数阶乘。

788
00:38:15,000 --> 00:38:18,400

789
00:38:18,400 --> 00:38:21,550
如果我真正写在C，
我需要什么名字前放

790
00:38:21,550 --> 00:38:22,800
函数？

791
00:38:22,800 --> 00:38:24,880

792
00:38:24,880 --> 00:38:30,060
返回类型，其中，在该
情况下，我们会给它诠释。

793
00:38:30,060 --> 00:38:35,450
然后在大括号内，是
善有善报花括号内为

794
00:38:35,450 --> 00:38:36,850
一个函数？

795
00:38:36,850 --> 00:38:37,950
>> 学生：参数类型。

796
00:38:37,950 --> 00:38:39,150
>> JASON HIRSCHHORN：它的参数。

797
00:38:39,150 --> 00:38:42,680
所以阶乘大概会
带参数。

798
00:38:42,680 --> 00:38:44,500
它很可能只需要一个参数。

799
00:38:44,500 --> 00:38:49,450
我们会说这会带
一个整数名为x。

800
00:38:49,450 --> 00:38:52,770
再次，写的原型时，
一个功能或记录的功能

801
00:38:52,770 --> 00:38:57,110
在定义它，你在你的代码
写的数据类型和名称

802
00:38:57,110 --> 00:39:01,370
该变量的函数只。

803
00:39:01,370 --> 00:39:06,350
所以，你可以通过一些数字到这个
功能，它会被称为X

804
00:39:06,350 --> 00:39:07,340
在内部。

805
00:39:07,340 --> 00:39:08,755
>> 我们有我们的阶乘函数。

806
00:39:08,755 --> 00:39:12,030

807
00:39:12,030 --> 00:39:15,850
我们需要两个东西，一个基本情况
和递归调用。

808
00:39:15,850 --> 00:39:20,900
是什么样的基本情况进行阶乘？

809
00:39:20,900 --> 00:39:24,850
有人谁写出来谁没有
讲的是，什么是基础

810
00:39:24,850 --> 00:39:26,100
案例阶乘？

811
00:39:26,100 --> 00:39:28,400

812
00:39:28,400 --> 00:39:30,930
>> 学生：如果n小于
大于2，则返回1。

813
00:39:30,930 --> 00:39:33,520
>> JASON HIRSCHHORN：如果n
小于2，则返回1。

814
00:39:33,520 --> 00:39:37,216
我喜欢这样，因为这
取0和1的照顾。

815
00:39:37,216 --> 00:39:45,290
所以我们会先去做x <2，则返回1。

816
00:39:45,290 --> 00:39:47,870
如果获得通过0，如果我们得到
通过1，此功能将

817
00:39:47,870 --> 00:39:49,790
立即返回1。

818
00:39:49,790 --> 00:39:54,020
如果我们通过一些数量较大的
大于或等于2，我们要

819
00:39:54,020 --> 00:39:55,370
有我们的递归调用。

820
00:39:55,370 --> 00:39:57,855
>> 所以这是怎么去上班？

821
00:39:57,855 --> 00:40:01,070
可别人谁曾在此
谁一直没有发言，给我的

822
00:40:01,070 --> 00:40:07,380
递归调用此函数
在伪代码？

823
00:40:07,380 --> 00:40:10,770
如果我们传递一个数x
而且它大于2，什么

824
00:40:10,770 --> 00:40:13,370
我们想干什么？

825
00:40:13,370 --> 00:40:17,930
我们也有一个例子写在
一面，可能会给你一个提示。

826
00:40:17,930 --> 00:40:20,770
>> 学生：调用x次的
x的减1阶乘？

827
00:40:20,770 --> 00:40:22,020
>> JASON HIRSCHHORN：完全正确。

828
00:40:22,020 --> 00:40:24,610

829
00:40:24,610 --> 00:40:37,750
我们要返回x次
的X减去1的阶乘。

830
00:40:37,750 --> 00:40:41,810
而且，即使我写了，
基本上，你用英语说的话，

831
00:40:41,810 --> 00:40:44,580
这个阶乘函数
将得到再次调用。

832
00:40:44,580 --> 00:40:46,320
这将X减1上执行。

833
00:40:46,320 --> 00:40:49,320
它会返回一些整数，
然后它会乘这两个

834
00:40:49,320 --> 00:40:52,050
在一起，并且该值将是
回到什么叫这个

835
00:40:52,050 --> 00:40:55,010
阶乘函数，这可能
是的另一个实例

836
00:40:55,010 --> 00:40:58,420
这个阶乘函数。

837
00:40:58,420 --> 00:41:01,360
>> 所以这是一个递归的一个例子
功能，一个非常

838
00:41:01,360 --> 00:41:02,530
简单的递归函数。

839
00:41:02,530 --> 00:41:04,530
但他们大多会是这样。

840
00:41:04,530 --> 00:41:11,170
如果你想一个很好的递归
为竞猜挑战，尝试编码

841
00:41:11,170 --> 00:41:13,230
二进制搜索递归。

842
00:41:13,230 --> 00:41:18,950
因为如果你做二进制搜索
问题设定了三个，你可能做到了

843
00:41:18,950 --> 00:41:21,730
反复在一个while循环。

844
00:41:21,730 --> 00:41:23,700
>> 但它也可以写成
递归。

845
00:41:23,700 --> 00:41:26,310
你将需要写你自己的
单独的函数，需要一些

846
00:41:26,310 --> 00:41:29,020
不同的命令行参数 - 或
没有命令行参数，一些

847
00:41:29,020 --> 00:41:30,910
不同的只是普通的论点。

848
00:41:30,910 --> 00:41:33,870
但你可以写二进制搜索
递归地为好。

849
00:41:33,870 --> 00:41:36,190
>> 学生：所以你可能也写，
代替X减1，则

850
00:41:36,190 --> 00:41:39,502
本来也写X减
减号，或者你可以有

851
00:41:39,502 --> 00:41:40,830
书面减减x。

852
00:41:40,830 --> 00:41:44,740
你可以解释得真快，为什么
这些将是不同的东西，

853
00:41:44,740 --> 00:41:49,510
喜欢的区别是什么之间
X减减和减减x？

854
00:41:49,510 --> 00:41:51,320
>> JASON HIRSCHHORN：不，我不
要进入那个。

855
00:41:51,320 --> 00:41:55,500
不过，我以后会和你谈谈这件事
类。 X减，减，减减x

856
00:41:55,500 --> 00:41:57,780
由1减小量X。

857
00:41:57,780 --> 00:41:59,090
但他们这样做有点不同。

858
00:41:59,090 --> 00:42:00,340
但我不想去考虑这样做。

859
00:42:00,340 --> 00:42:04,330

860
00:42:04,330 --> 00:42:09,090
关于递归其他问题
或者这个功能呢？

861
00:42:09,090 --> 00:42:10,140
这不是真的连伪代码。

862
00:42:10,140 --> 00:42:15,060
这基本上是在代码
c您会写这个。

863
00:42:15,060 --> 00:42:19,393
>> 好了，其他问题
的话题在这里？

864
00:42:19,393 --> 00:42:19,864
是啊。

865
00:42:19,864 --> 00:42:23,130
>> 学生：我有一个快速的破败
浮点和精度。

866
00:42:23,130 --> 00:42:24,260
>> JASON HIRSCHHORN：浮动
点和精度。

867
00:42:24,260 --> 00:42:26,920
可有人真的很快
给我一个破败

868
00:42:26,920 --> 00:42:28,210
浮点和精度？

869
00:42:28,210 --> 00:42:30,420
你都必须做到这一点你
问题集，所以你的所有

870
00:42:30,420 --> 00:42:31,700
熟悉它。

871
00:42:31,700 --> 00:42:35,090
或者，也许不是所有的你。

872
00:42:35,090 --> 00:42:36,602
任何人吗？

873
00:42:36,602 --> 00:42:39,530
给我一个开始的地方。

874
00:42:39,530 --> 00:42:40,750
浮点和精度。

875
00:42:40,750 --> 00:42:42,380
这是什么问题？

876
00:42:42,380 --> 00:42:42,960
是。

877
00:42:42,960 --> 00:42:43,680
维多利亚？

878
00:42:43,680 --> 00:42:44,480
>> 云妮：凡妮莎。

879
00:42:44,480 --> 00:42:45,285
>> JASON HIRSCHHORN：凡妮莎。

880
00:42:45,285 --> 00:42:45,680
抱歉。

881
00:42:45,680 --> 00:42:51,550
>> 云妮：这里只有有限数量的
可以表示数字

882
00:42:51,550 --> 00:42:57,930
因为你是在，在我们的
情况下，32位的系统。

883
00:42:57,930 --> 00:43:03,080
那种让你不得不
弥补了一些数字。

884
00:43:03,080 --> 00:43:03,910
>> JASON HIRSCHHORN：所以这是
完全正确。

885
00:43:03,910 --> 00:43:08,110
有仅一定量的
可表示数字。

886
00:43:08,110 --> 00:43:11,770
如果你将两个非常大的数字，
它可能会溢​​出量

887
00:43:11,770 --> 00:43:13,950
的空间，你必须代表
的整数。

888
00:43:13,950 --> 00:43:17,930
这就是为什么有时候我们使用
长，而不是一个int长。

889
00:43:17,930 --> 00:43:19,210
有更多的空间。

890
00:43:19,210 --> 00:43:21,210
可容纳一个更大的数字。

891
00:43:21,210 --> 00:43:24,310
>> 浮点精度，是因为有
这一点，但也有做的

892
00:43:24,310 --> 00:43:29,300
事实是十进制数是
并不总是代表。

893
00:43:29,300 --> 00:43:29,540
抱歉。

894
00:43:29,540 --> 00:43:31,280
让我把这个备份。

895
00:43:31,280 --> 00:43:36,610
十进制数1.0并不总是
代表像你所期望的，

896
00:43:36,610 --> 00:43:40,770
1.000000000。

897
00:43:40,770 --> 00:43:50,360
它有时被表示为
1.000000001或0.999999999。

898
00:43:50,360 --> 00:43:52,780
它可能是89甚至抛出
在那里的某个地方。

899
00:43:52,780 --> 00:43:56,560
因此，这些十进制数字是不
代表酷似你会

900
00:43:56,560 --> 00:43:58,430
希望他们能来表示。

901
00:43:58,430 --> 00:44:00,010
>> 所以在问题设置 - 

902
00:44:00,010 --> 00:44:00,860
是两份？ - 

903
00:44:00,860 --> 00:44:05,290
问题设置两个，在这里我们处理
浮点数，当我们想

904
00:44:05,290 --> 00:44:08,690
他们表示正是我们想要的
他们表示，数

905
00:44:08,690 --> 00:44:12,860
便士，或仙的数量，
我们用100乘以它们。

906
00:44:12,860 --> 00:44:14,750
我们绕过他们。

907
00:44:14,750 --> 00:44:18,660
然后，我们切断了一切
后面的小数点。

908
00:44:18,660 --> 00:44:22,020
这是为了确保他们
实际上等于正是我们想要的

909
00:44:22,020 --> 00:44:22,410
他们相等。

910
00:44:22,410 --> 00:44:26,870
>> 因为当你把东西的
一个float和把它变成一个int，你

911
00:44:26,870 --> 00:44:29,860
切断一切的权利
的小数点。

912
00:44:29,860 --> 00:44:33,900
因为有一些浮点
不精确，100.000可能是

913
00:44:33,900 --> 00:44:37,440
表示为99.999999999。

914
00:44:37,440 --> 00:44:40,350
如果你只是切断了一切
右边向右走，你要

915
00:44:40,350 --> 00:44:41,600
得到错误的号码。

916
00:44:41,600 --> 00:44:44,050

917
00:44:44,050 --> 00:44:44,180
是啊。

918
00:44:44,180 --> 00:44:45,290
>> 学生：我有一个问题
有关转换。

919
00:44:45,290 --> 00:44:47,500
什么为了它发生在？

920
00:44:47,500 --> 00:44:54,480
如果你愿意做浮动，支架，1分
10，它做1除以10，

921
00:44:54,480 --> 00:44:58,910
然后得到0.1，然后打开
它变成一个浮动？

922
00:44:58,910 --> 00:45:01,470
>> JASON HIRSCHHORN：如果你这样做
浮动1除以10  - 

923
00:45:01,470 --> 00:45:02,550
>> 学生：是啊，然后等于 - 

924
00:45:02,550 --> 00:45:04,240
好了，它通常会
有它在平等的 - 

925
00:45:04,240 --> 00:45:04,690
是啊。

926
00:45:04,690 --> 00:45:06,760
你想成为一个浮动，对不对？

927
00:45:06,760 --> 00:45:12,790
>> JASON HIRSCHHORN：好了，我们要
用它来Segue公司进入搞清楚

928
00:45:12,790 --> 00:45:15,390
在这些问题的答案
通过编码。

929
00:45:15,390 --> 00:45:18,180
因为你可能有很多的
这些细微问题，一个很好的方法

930
00:45:18,180 --> 00:45:19,100
解决这些问题是通过编码。

931
00:45:19,100 --> 00:45:21,320
因此，我们现在要编写这一权利，
然后我们要回去

932
00:45:21,320 --> 00:45:24,020
你的代码有问题。

933
00:45:24,020 --> 00:45:24,950
>> 所以第一线 - 

934
00:45:24,950 --> 00:45:29,390
我不应该写它 - 什么是
我们要做的第一件事情，当我们

935
00:45:29,390 --> 00:45:32,250
打开gedit中一个新的文件？

936
00:45:32,250 --> 00:45:34,190
>> 学生：包括。

937
00:45:34,190 --> 00:45:35,920
>> JASON HIRSCHHORN：包括什么？

938
00:45:35,920 --> 00:45:37,952
>> 学生：CS50库。

939
00:45:37,952 --> 00:45:39,920
>> JASON HIRSCHHORN：确定。

940
00:45:39,920 --> 00:45:42,590
我们还应该包括哪些内容？

941
00:45:42,590 --> 00:45:46,820
我们只是要检查发生了什么
当你施放的东西为float。

942
00:45:46,820 --> 00:45:48,605
但是，我们需要包括，如果我们
打算写一个C程序？

943
00:45:48,605 --> 00:45:49,300
>> 学生：标准I / O。

944
00:45:49,300 --> 00:45:50,625
>> JASON HIRSCHHORN：stdio.h中。

945
00:45:50,625 --> 00:45:54,880
我们其实并不需要，这
程序，cs50.h，即使它的

946
00:45:54,880 --> 00:45:55,920
总是有帮助的，包括它。

947
00:45:55,920 --> 00:45:58,260
但我们总是需要stdio.h中。

948
00:45:58,260 --> 00:45:59,660
>> 学生：C语言编码什么时候？

949
00:45:59,660 --> 00:46:15,770
>> JASON HIRSCHHORN：在C编码时

950
00:46:15,770 --> 00:46:17,090
>> 所以我将它保存为这个c文件。

951
00:46:17,090 --> 00:46:18,590
我得到了一些不错的语法高亮。

952
00:46:18,590 --> 00:46:22,890
我里面主要写无效。

953
00:46:22,890 --> 00:46:24,792
什么是无效的呢？

954
00:46:24,792 --> 00:46:26,740
>> 学生：不采取任何
命令行参数。

955
00:46:26,740 --> 00:46:28,900
>> JASON HIRSCHHORN：虚空的手段，在这
情况下，主并没有采取任何

956
00:46:28,900 --> 00:46:29,700
命令行参数。

957
00:46:29,700 --> 00:46:32,720
在其他情况下，表示该功能
并不需要命令行参数。

958
00:46:32,720 --> 00:46:36,560
或者函数，如果我是写无效
主要（无效），这可以说主要的

959
00:46:36,560 --> 00:46:38,460
不返回任何东西。

960
00:46:38,460 --> 00:46:39,960
因此作废只是意味着什么。

961
00:46:39,960 --> 00:46:42,510
我会怎么写，如果我是
采取命令行参数？

962
00:46:42,510 --> 00:46:45,250

963
00:46:45,250 --> 00:46:47,150
>> 学生：诠释圆弧C字符串弧诉

964
00:46:47,150 --> 00:46:49,055
>> JASON HIRSCHHORN：INT
ARGC ARGV字符串。

965
00:46:49,055 --> 00:46:54,050

966
00:46:54,050 --> 00:46:55,572
是这样吗？

967
00:46:55,572 --> 00:46:58,720
>> 学生：这是字符星级argv的括号内。

968
00:46:58,720 --> 00:47:01,730
>> JASON HIRSCHHORN：所以你可以写
字符串argv的括号或char星级的argv

969
00:47:01,730 --> 00:47:03,710
括号，但你需要的括号内。

970
00:47:03,710 --> 00:47:06,290
因为argv是一个数组
字符串，切记。

971
00:47:06,290 --> 00:47:07,360
这不只是一个字符串。

972
00:47:07,360 --> 00:47:10,350
所以字符串argv是，这里的
一根弦称为argv的。

973
00:47:10,350 --> 00:47:13,630
字符串argv的括号是，这里的
一个字符串数组。

974
00:47:13,630 --> 00:47:17,865
所以整型的argc字符串argv的支架
会是什么，我

975
00:47:17,865 --> 00:47:18,810
可能会写。

976
00:47:18,810 --> 00:47:23,050
>> 所以，你想保存一个整数？

977
00:47:23,050 --> 00:47:24,285
>> 学生：是啊，整数。

978
00:47:24,285 --> 00:47:25,840
或者在浮动。

979
00:47:25,840 --> 00:47:26,710
>> JASON HIRSCHHORN：在一个浮动？

980
00:47:26,710 --> 00:47:30,790
像，浮x等于1除以10。

981
00:47:30,790 --> 00:47:32,040
>> JASON HIRSCHHORN：确定。

982
00:47:32,040 --> 00:47:40,160

983
00:47:40,160 --> 00:47:42,240
printf中如何打印出一个浮动？

984
00:47:42,240 --> 00:47:45,100

985
00:47:45,100 --> 00:47:46,714
什么？

986
00:47:46,714 --> 00:47:47,560
>> 学生：％F。

987
00:47:47,560 --> 00:47:48,300
>> JASON HIRSCHHORN：％F。

988
00:47:48,300 --> 00:47:50,810
什么是整数？

989
00:47:50,810 --> 00:47:52,110
d或我。

990
00:47:52,110 --> 00:47:53,000
什么是字符串？

991
00:47:53,000 --> 00:47:54,240
>> 学生：秒。

992
00:47:54,240 --> 00:47:56,140
>> JASON HIRSCHHORN：秒。

993
00:47:56,140 --> 00:47:57,550
我如何获得一个新行？

994
00:47:57,550 --> 00:47:58,800
>> 学生：反斜杠ñ。

995
00:47:58,800 --> 00:48:04,610

996
00:48:04,610 --> 00:48:07,100
>> JASON HIRSCHHORN：我该怎么回
如果主要的运行是否正确？

997
00:48:07,100 --> 00:48:08,360
>> 学生：0。

998
00:48:08,360 --> 00:48:09,430
我是否需要写该行有关系吗？

999
00:48:09,430 --> 00:48:10,170
>> 学生：

1000
00:48:10,170 --> 00:48:11,513
OK，我们不会写它，然后。

1001
00:48:11,513 --> 00:48:16,450

1002
00:48:16,450 --> 00:48:17,190
每个人都可以读吗？

1003
00:48:17,190 --> 00:48:18,485
它看起来有点小。

1004
00:48:18,485 --> 00:48:20,160
大家可以看到，还是应该
我使它更大？

1005
00:48:20,160 --> 00:48:23,480

1006
00:48:23,480 --> 00:48:25,100
我觉得对于摄像头，我们会做
它有点大，虽然。

1007
00:48:25,100 --> 00:48:35,750

1008
00:48:35,750 --> 00:48:38,410
>> JASON HIRSCHHORN：如果我想关闭这个
c文件为可执行文件，有什么

1009
00:48:38,410 --> 00:48:39,260
我写？

1010
00:48:39,260 --> 00:48:41,610
>> 学生：做测试。

1011
00:48:41,610 --> 00:48:42,080
>> JASON HIRSCHHORN：对不起？

1012
00:48:42,080 --> 00:48:42,790
>> 学生：做测试。

1013
00:48:42,790 --> 00:48:44,040
>> JASON HIRSCHHORN：请测试。

1014
00:48:44,040 --> 00:48:46,700

1015
00:48:46,700 --> 00:48:48,410
我们都在谈论
这条线前面。

1016
00:48:48,410 --> 00:48:49,140
铛。

1017
00:48:49,140 --> 00:48:51,270
什么是铛？

1018
00:48:51,270 --> 00:48:52,200
编译器的名称。

1019
00:48:52,200 --> 00:48:53,920
这是什么线？

1020
00:48:53,920 --> 00:48:55,580
>> 学生：设置它为使用gdb的。

1021
00:48:55,580 --> 00:48:59,230
>> JASON HIRSCHHORN：集
它使用的GDB。

1022
00:48:59,230 --> 00:49:02,338
这条线，那是什么？

1023
00:49:02,338 --> 00:49:03,290
>> 学生：源代码。

1024
00:49:03,290 --> 00:49:06,010
>> JASON HIRSCHHORN：这就是
源文件，c文件。

1025
00:49:06,010 --> 00:49:08,150
什么这两行吗？

1026
00:49:08,150 --> 00:49:10,245
或者这两个不是行。

1027
00:49:10,245 --> 00:49:12,300
>> 学生：它的名字来测试。

1028
00:49:12,300 --> 00:49:15,410
>> JASON HIRSCHHORN：所以破折号ø说，
不同命名的东西。

1029
00:49:15,410 --> 00:49:16,790
在这里，你调用它的测试。

1030
00:49:16,790 --> 00:49:18,900
如果我没有在，
那会是什么名字呢？

1031
00:49:18,900 --> 00:49:20,260
>> 学生：为a.out。

1032
00:49:20,260 --> 00:49:22,340
>> JASON HIRSCHHORN：为a.out。

1033
00:49:22,340 --> 00:49:25,366
这是什么呢？

1034
00:49:25,366 --> 00:49:27,670
>> 学生：友情链接数学库。

1035
00:49:27,670 --> 00:49:29,550
>> JASON HIRSCHHORN：它链接
在数学库。

1036
00:49:29,550 --> 00:49:32,880
我们没有包括数学库，但
因为这是如此普遍，他们已经

1037
00:49:32,880 --> 00:49:35,780
写make来总是包括
数学库。

1038
00:49:35,780 --> 00:49:39,050
同样地，这包括
在CS50库。

1039
00:49:39,050 --> 00:49:43,010
>> 好了，如果我们列出，我们现在有
可执行文件名为test。

1040
00:49:43,010 --> 00:49:45,150
为了执行它，我写的测试。

1041
00:49:45,150 --> 00:49:48,330
我看到我的浮点运算，
正如所料，等于0。

1042
00:49:48,330 --> 00:49:50,890

1043
00:49:50,890 --> 00:49:51,590
这是否 - 

1044
00:49:51,590 --> 00:49:52,060
所以 - 

1045
00:49:52,060 --> 00:49:55,210
>> 学生：那么，如果你把现在浮动，
就像你将其转换为浮动 - 

1046
00:49:55,210 --> 00:49:56,870
>> JASON HIRSCHHORN：铸铁
1为float？

1047
00:49:56,870 --> 00:49:59,180
>> 学生：不，投满的事情 - 

1048
00:49:59,180 --> 00:49:59,500
是的。

1049
00:49:59,500 --> 00:50:02,460
如果你只是这样做，会
这使它0.1？

1050
00:50:02,460 --> 00:50:07,170
>> JASON HIRSCHHORN：好了，真的很快，
1除以10，这些都是

1051
00:50:07,170 --> 00:50:08,690
整数被分割。

1052
00:50:08,690 --> 00:50:13,580
所以，当你划分整数，​​它们是
0，而你节省了0的

1053
00:50:13,580 --> 00:50:17,170
浮动，因为斜线
只是整数除法。

1054
00:50:17,170 --> 00:50:19,180
所以，现在我们正在转弯的东西
成浮动。

1055
00:50:19,180 --> 00:50:21,650
>> 让我们看看会发生什么。

1056
00:50:21,650 --> 00:50:22,900
我们会让测试。

1057
00:50:22,900 --> 00:50:25,870

1058
00:50:25,870 --> 00:50:31,090
所以，现在我们看到的斜线不
整数除法，它是浮动的

1059
00:50:31,090 --> 00:50:32,640
分点。

1060
00:50:32,640 --> 00:50:35,700
因为它的参数之一
已被转换为一个浮点数。

1061
00:50:35,700 --> 00:50:38,380
所以，现在有人说，对待这个
师像我们正在处理

1062
00:50:38,380 --> 00:50:40,140
浮动点，不带整数。

1063
00:50:40,140 --> 00:50:42,760
所以我们得到我们期望的答案。

1064
00:50:42,760 --> 00:50:44,620
>> 让我们看看会发生什么 - 

1065
00:50:44,620 --> 00:50:47,103
哎呀。

1066
00:50:47,103 --> 00:50:51,646
如果我想打印更十进制
点，我怎么能这样做呢？

1067
00:50:51,646 --> 00:50:55,550
>> 学生：点圆点f或尽可能多的
只要你想的小数位数。

1068
00:50:55,550 --> 00:51:02,280

1069
00:51:02,280 --> 00:51:04,440
>> JASON HIRSCHHORN：所以我打印
10进制的斑点。

1070
00:51:04,440 --> 00:51:06,610
而我们现在看到我们越来越
一些怪异的东西。

1071
00:51:06,610 --> 00:51:09,650
而这又回到你的问题
关于浮点不精确。

1072
00:51:09,650 --> 00:51:10,950
有奇怪的东西存放在这里。

1073
00:51:10,950 --> 00:51:13,650

1074
00:51:13,650 --> 00:51:15,275
>> 好了，这是否回答你的问题？

1075
00:51:15,275 --> 00:51:18,550

1076
00:51:18,550 --> 00:51:20,200
你想要什么
快速代码？

1077
00:51:20,200 --> 00:51:25,470
>> 学生：我只是想看看是否
不，如果你释放了一些指针，

1078
00:51:25,470 --> 00:51:30,410
该指针是否仍然存储在
它是什么它一直是地址

1079
00:51:30,410 --> 00:51:32,170
指着前面。

1080
00:51:32,170 --> 00:51:34,100
>> JASON HIRSCHHORN：OK，
所以让我们做到这一点。

1081
00:51:34,100 --> 00:51:38,030
字符明星PTR，这将创建一个变量
所谓PTR char类型的明星。

1082
00:51:38,030 --> 00:51:39,280
我怎样写的malloc？

1083
00:51:39,280 --> 00:51:40,550
奥尔登？

1084
00:51:40,550 --> 00:51:41,800
>> 奥尔登：只是malloc的。

1085
00:51:41,800 --> 00:51:44,820

1086
00:51:44,820 --> 00:51:51,040
但随后它必须的尺寸，并
在这种情况下，我想你会

1087
00:51:51,040 --> 00:51:52,465
是指向字符。

1088
00:51:52,465 --> 00:51:54,450
所以它会是char。

1089
00:51:54,450 --> 00:51:57,520
>> JASON HIRSCHHORN：OK，所以更
一般地，内幕 - 

1090
00:51:57,520 --> 00:51:58,770
让我们编辑。

1091
00:51:58,770 --> 00:52:05,100

1092
00:52:05,100 --> 00:52:09,260
里面的malloc，你要的号码
字节的堆。

1093
00:52:09,260 --> 00:52:12,320
一般情况下，我们所看到的，我们是
做的是我们要去用malloc

1094
00:52:12,320 --> 00:52:14,940
字符串，例如，或
整数的数组。

1095
00:52:14,940 --> 00:52:21,600
因此，如果我们想要10的整数，或10
字符，10会给我们10。

1096
00:52:21,600 --> 00:52:24,370
然后字符的大小会给
我们说，字符大小，这在

1097
00:52:24,370 --> 00:52:25,120
这种情况下，是1个字节。

1098
00:52:25,120 --> 00:52:26,250
我们得到了10个字节。

1099
00:52:26,250 --> 00:52:28,540
如果我们写为int的大小，
这会给我们40字节。

1100
00:52:28,540 --> 00:52:31,520
>> 所以更一般地，malloc的内部
是你想要的字节数。

1101
00:52:31,520 --> 00:52:34,620
在这种情况下，我们得到1个字节。

1102
00:52:34,620 --> 00:52:36,900
这似乎是一个奇怪的运用
malloc的，但对于我们的

1103
00:52:36,900 --> 00:52:38,470
目的是有道理的。

1104
00:52:38,470 --> 00:52:40,420
因此，有一点。

1105
00:52:40,420 --> 00:52:43,420
>> 我们要调用free。

1106
00:52:43,420 --> 00:52:47,040
我们摆脱它，我们再次使用PTR。

1107
00:52:47,040 --> 00:52:48,750
和你想要什么检查？

1108
00:52:48,750 --> 00:52:50,550
>> 学生：我只是想检查是否
或不存在是什么，

1109
00:52:50,550 --> 00:52:51,900
里面的它。

1110
00:52:51,900 --> 00:52:53,050
>> JASON HIRSCHHORN：所以，无论
它指出了什么？

1111
00:52:53,050 --> 00:52:57,740
>> 学生：是的，没错，无论是
它仍然有一个存储器地址。

1112
00:52:57,740 --> 00:53:02,220
>> JASON HIRSCHHORN：所以，你想要
检查ptr的值？

1113
00:53:02,220 --> 00:53:03,470
>> 学生：是的，没错。

1114
00:53:03,470 --> 00:53:07,940

1115
00:53:07,940 --> 00:53:10,160
>> JASON HIRSCHHORN：那我写在这里
如果我要检查的价值

1116
00:53:10,160 --> 00:53:11,880
点 - 什么是，乔丹
说，值？

1117
00:53:11,880 --> 00:53:13,720
或者什么是存储PTR里面？

1118
00:53:13,720 --> 00:53:14,620
>> 学生：一个内存地址。

1119
00:53:14,620 --> 00:53:16,330
>> JASON HIRSCHHORN：一个内存地址。

1120
00:53:16,330 --> 00:53:20,520
所以，如果我写的只是这一点，它会
给我ptr的值。

1121
00:53:20,520 --> 00:53:22,800
以及如何打印出
一个内存地址？

1122
00:53:22,800 --> 00:53:26,470
什么是格式字符串
用于存储器的地址？

1123
00:53:26,470 --> 00:53:27,430
>> 学生：％P。

1124
00:53:27,430 --> 00:53:28,050
>> JASON HIRSCHHORN：％P。

1125
00:53:28,050 --> 00:53:29,500
％s是一个字符串。

1126
00:53:29,500 --> 00:53:30,750
％P的指针。

1127
00:53:30,750 --> 00:53:40,820

1128
00:53:40,820 --> 00:53:43,540
是这样吗？

1129
00:53:43,540 --> 00:53:44,790
这是正确的。

1130
00:53:44,790 --> 00:53:49,450

1131
00:53:49,450 --> 00:53:51,040
所以PTR等于 - 

1132
00:53:51,040 --> 00:53:53,350
但仍然有一些东西在里面。

1133
00:53:53,350 --> 00:53:56,110

1134
00:53:56,110 --> 00:53:57,645
这可能是一个更
有趣的问题。

1135
00:53:57,645 --> 00:53:59,198
这是什么线路呢？

1136
00:53:59,198 --> 00:54:00,830
>> 学生：赛格故障。

1137
00:54:00,830 --> 00:54:01,310
>> JASON HIRSCHHORN：什么？

1138
00:54:01,310 --> 00:54:02,678
>> 学生：我觉得这赛格故障。

1139
00:54:02,678 --> 00:54:03,574
>> JASON HIRSCHHORN：嗯？

1140
00:54:03,574 --> 00:54:04,920
>> 学生：我认为它会赛格故障。

1141
00:54:04,920 --> 00:54:08,265
>> JASON HIRSCHHORN：所以这条线
的代码，明星PTR，是什么

1142
00:54:08,265 --> 00:54:10,152
没有星星是什么意思？

1143
00:54:10,152 --> 00:54:11,240
>> 学生：内容。

1144
00:54:11,240 --> 00:54:11,560
>> JASON HIRSCHHORN：是啊。

1145
00:54:11,560 --> 00:54:13,910
去得到的内容。

1146
00:54:13,910 --> 00:54:16,830
因此，这是要去记忆
有地址，并让我说。

1147
00:54:16,830 --> 00:54:21,030
我用％C就在这里，因为有
存储有字符。

1148
00:54:21,030 --> 00:54:23,390
因此，我们打算去那个地址我们
刚看到 - 或者它可能会成为一个

1149
00:54:23,390 --> 00:54:25,190
稍微有点不同，这
一次，我们运行该程序。

1150
00:54:25,190 --> 00:54:28,010
但我们会去那个地址
我们知道仍然存在

1151
00:54:28,010 --> 00:54:29,260
看看那里的东西。

1152
00:54:29,260 --> 00:54:35,640

1153
00:54:35,640 --> 00:54:37,110
>> 所以也没赛格故障。

1154
00:54:37,110 --> 00:54:38,970
它只是没有给我们任何东西。

1155
00:54:38,970 --> 00:54:43,350
它可能实际上已经给了我们
东西，我们不能看到它。

1156
00:54:43,350 --> 00:54:45,110
而这又回到这个想法 - 

1157
00:54:45,110 --> 00:54:47,270
并且我们不会得到太多到
这一点，因为这是超越

1158
00:54:47,270 --> 00:54:48,460
本课程的范围。

1159
00:54:48,460 --> 00:54:51,260
但我们谈到这里吧，如果我们
超出了数组界限由

1160
00:54:51,260 --> 00:54:54,890
1，我们可能不会惹上麻烦。

1161
00:54:54,890 --> 00:54:58,550
>> 有时候，当你只是1熄灭，
你正在做的事情错了，你

1162
00:54:58,550 --> 00:54:59,220
可能惹上麻烦。

1163
00:54:59,220 --> 00:55:00,820
但你并不总是惹上麻烦。

1164
00:55:00,820 --> 00:55:05,170
这要看怎么是一件坏事，你得多
这样做，你会惹上麻烦。

1165
00:55:05,170 --> 00:55:07,790
这是不是说，马虎
与您的代码。

1166
00:55:07,790 --> 00:55:12,080
但它说，该计划将不会
总是跳槽，即使你去的地方

1167
00:55:12,080 --> 00:55:14,130
你不应该去。

1168
00:55:14,130 --> 00:55:18,170
>> 这方面的一个很好的例子是，很多
人们在问题设置3，其中

1169
00:55:18,170 --> 00:55:22,350
15岁，没有检查
董事会的界限。

1170
00:55:22,350 --> 00:55:25,860
所以，你看左边，看向
右，看着顶端，看着

1171
00:55:25,860 --> 00:55:27,000
至底部。

1172
00:55:27,000 --> 00:55:31,540
但你没有检查，看看是否顶部
实际上将是在黑板上。

1173
00:55:31,540 --> 00:55:35,220
和很多人谁这样做了，
原来，在，他们的工作程序

1174
00:55:35,220 --> 00:55:38,960
完美，因为那个地方是板
存储在内存中，如果你走了一条

1175
00:55:38,960 --> 00:55:42,300
它上面或托运的记忆
地址，有没有什么

1176
00:55:42,300 --> 00:55:44,870
尤其可怕的这个，
所以你的程序是不是

1177
00:55:44,870 --> 00:55:45,970
要骂你。

1178
00:55:45,970 --> 00:55:48,870
>> 但是，我们仍然起飞点，如果
你没有检查，因为你

1179
00:55:48,870 --> 00:55:50,850
在做一些你不
应该做的，而你可以有

1180
00:55:50,850 --> 00:55:51,860
变得麻烦了。

1181
00:55:51,860 --> 00:55:54,040
奇怪的是，虽然你可能没有。

1182
00:55:54,040 --> 00:55:57,790
因此，这是证明，是的，
我们仍然可以去它。

1183
00:55:57,790 --> 00:55:59,010
而我们没有得到的
在这种情况下，麻烦。

1184
00:55:59,010 --> 00:56:04,000
如果我们试图做阅读
接下来的100个字，我们就

1185
00:56:04,000 --> 00:56:06,000
可能惹上麻烦。

1186
00:56:06,000 --> 00:56:09,400
而且你可以编写读取下一个100
字符，如果你想要做一些

1187
00:56:09,400 --> 00:56:10,110
排序的for循环。

1188
00:56:10,110 --> 00:56:10,850
是啊。

1189
00:56:10,850 --> 00:56:16,250
>> 学生：因为我们被分配了
空间的实际值，我们不会

1190
00:56:16,250 --> 00:56:17,050
居然能看到什么。

1191
00:56:17,050 --> 00:56:21,740
我们是否应该尝试用该设置
等于像C什么的？

1192
00:56:21,740 --> 00:56:22,640
>> JASON HIRSCHHORN：大问题。

1193
00:56:22,640 --> 00:56:25,340
我如何设置该值 - 

1194
00:56:25,340 --> 00:56:28,980
我写行哪一行代码
七，你说什么？

1195
00:56:28,980 --> 00:56:34,040
>> 学生：星PTR等于单
引用C + +期末单引号。

1196
00:56:34,040 --> 00:56:36,970
>> JASON HIRSCHHORN：所以这把
一个字符，C，在该位置，

1197
00:56:36,970 --> 00:56:40,200
因为再次，这颗恒星
意味着去那里。

1198
00:56:40,200 --> 00:56:43,320
和左手侧使用时
赋值运算符，等于

1199
00:56:43,320 --> 00:56:47,270
签名，我们不会得到那个
值这么多的设置值。

1200
00:56:47,270 --> 00:56:48,520
现在，让我们看看会发生什么。

1201
00:56:48,520 --> 00:56:54,700

1202
00:56:54,700 --> 00:56:56,770
>> 我们把那里的东西
并且它在那里。

1203
00:56:56,770 --> 00:56:58,000
我们所谓的自由。

1204
00:56:58,000 --> 00:57:00,100
有些东西可能发生
在堆上。

1205
00:57:00,100 --> 00:57:01,890
因此，它不存在了。

1206
00:57:01,890 --> 00:57:07,440
但同样，我们没有得到
在为去那里的麻烦。

1207
00:57:07,440 --> 00:57:10,260
>> 我这样做出来的代码来说明
有很多这些

1208
00:57:10,260 --> 00:57:12,410
您有任何问题，他们是
真的很有趣

1209
00:57:12,410 --> 00:57:13,650
回答了很多时间。

1210
00:57:13,650 --> 00:57:15,260
而且他们真的很好的问题。

1211
00:57:15,260 --> 00:57:19,010
并且你可以计算出来的
自己如果，例如，

1212
00:57:19,010 --> 00:57:19,990
我们不是在一节。

1213
00:57:19,990 --> 00:57:20,940
是啊。

1214
00:57:20,940 --> 00:57:24,430
>> 学生：因为你没有送
指针的任何地方，你需要

1215
00:57:24,430 --> 00:57:26,530
使用malloc？

1216
00:57:26,530 --> 00:57:28,400
>> JASON HIRSCHHORN：所以这可以追溯到
给你最初的问题。

1217
00:57:28,400 --> 00:57:28,620
[？ ？]

1218
00:57:28,620 --> 00:57:29,980
难道仅仅是一个局部变量？

1219
00:57:29,980 --> 00:57:32,280
这里的malloc是不是引人注目。

1220
00:57:32,280 --> 00:57:35,260
在使用malloc这里就不
那引人注目，因为它是

1221
00:57:35,260 --> 00:57:36,500
只是一个局部变量。

1222
00:57:36,500 --> 00:57:40,970
>> 学生：所以你能做到的char
明星PTR等于你好？

1223
00:57:40,970 --> 00:57:41,400
>> JASON HIRSCHHORN：哦。

1224
00:57:41,400 --> 00:57:43,300
所以，我们要拿回
给你最初的问题。

1225
00:57:43,300 --> 00:57:46,885
我觉得你不满意
我的回答。

1226
00:57:46,885 --> 00:57:48,220
好不好？

1227
00:57:48,220 --> 00:57:49,226
喜欢吗？

1228
00:57:49,226 --> 00:57:49,682
>> 学生：是啊。

1229
00:57:49,682 --> 00:57:50,932
等待。

1230
00:57:50,932 --> 00:57:54,090

1231
00:57:54,090 --> 00:57:57,850
>> JASON HIRSCHHORN：在哪里
你想打印出来？

1232
00:57:57,850 --> 00:58:00,026
因此，我们将打印出一个这样的字符串？

1233
00:58:00,026 --> 00:58:06,380

1234
00:58:06,380 --> 00:58:07,630
>> 学生：有趣。

1235
00:58:07,630 --> 00:58:09,900

1236
00:58:09,900 --> 00:58:14,285
>> JASON HIRSCHHORN：所以这个说，这
参数有一个字符的类型。

1237
00:58:14,285 --> 00:58:17,200

1238
00:58:17,200 --> 00:58:18,620
所以这应该是一个字符。

1239
00:58:18,620 --> 00:58:25,170

1240
00:58:25,170 --> 00:58:26,280
>> 学生：只需要第一个。

1241
00:58:26,280 --> 00:58:28,610
>> JASON HIRSCHHORN：所以这
就是我之前说的。

1242
00:58:28,610 --> 00:58:34,240
就像我说的，它不是存储
字符串变量的指针里面。

1243
00:58:34,240 --> 00:58:35,120
它的存储 - 

1244
00:58:35,120 --> 00:58:36,350
>> 学生：第一个值
的字符串。

1245
00:58:36,350 --> 00:58:40,810
>> JASON HIRSCHHORN：的地址
字符串的第一个值。

1246
00:58:40,810 --> 00:58:46,940
如果我们要打印出这一点，我们
进入内部指针的值。

1247
00:58:46,940 --> 00:58:51,005
我们会看到它确实是，
的存储器地址。

1248
00:58:51,005 --> 00:58:53,595

1249
00:58:53,595 --> 00:58:56,440
>> 这是否有道理？

1250
00:58:56,440 --> 00:58:56,940
抱歉。

1251
00:58:56,940 --> 00:58:58,996
等等，这是否回答你
问题有关系吗？

1252
00:58:58,996 --> 00:58:59,790
>> 学生：是啊。

1253
00:58:59,790 --> 00:59:05,830
>> JASON HIRSCHHORN：这行代码是
创建一个字符串，然后再

1254
00:59:05,830 --> 00:59:09,115
变量指针的指向
该字符串，数组。

1255
00:59:09,115 --> 00:59:14,320

1256
00:59:14,320 --> 00:59:14,980
是啊。

1257
00:59:14,980 --> 00:59:19,200
>> 学生：所以，如果我们去一个内存
进一步解决，我们将得到的H？

1258
00:59:19,200 --> 00:59:21,990

1259
00:59:21,990 --> 00:59:23,150
有没有被存储为一个字符串？

1260
00:59:23,150 --> 00:59:24,400
>> JASON HIRSCHHORN：像我们所做的 - 

1261
00:59:24,400 --> 00:59:28,540

1262
00:59:28,540 --> 00:59:30,790
所以这是有价值的事情。

1263
00:59:30,790 --> 00:59:33,780
这是第一点运算，这你们
以前见过，应该是

1264
00:59:33,780 --> 00:59:35,550
比较舒服。

1265
00:59:35,550 --> 00:59:36,905
这类似于写 - 

1266
00:59:36,905 --> 00:59:41,980

1267
00:59:41,980 --> 00:59:46,350
如果我们写这行代码，
我们以前见过数组符号。

1268
00:59:46,350 --> 00:59:55,900
这应该给我们的第二个
在这个数组，H值。

1269
00:59:55,900 --> 01:00:05,010
>> 如果我们这样做，这也应该给
我们在该数组的第二个值。

1270
01:00:05,010 --> 01:00:08,320
因为它是将不向存储器
的第一件事地址，但

1271
01:00:08,320 --> 01:00:10,530
的事情之一，在内存地址。

1272
01:00:10,530 --> 01:00:14,360
然后恒星取消引用运算符
该指针。

1273
01:00:14,360 --> 01:00:16,940
再次，让我们来看看。

1274
01:00:16,940 --> 01:00:18,664
我们再次拿到小时。

1275
01:00:18,664 --> 01:00:20,980
>> 学生：这到底是什么
解引用是什么意思？

1276
01:00:20,980 --> 01:00:23,650
>> JASON HIRSCHHORN：取消引用
是看中字去。

1277
01:00:23,650 --> 01:00:26,390
去那个并获得那里的东西
是取消引用指针。

1278
01:00:26,390 --> 01:00:28,240
这只是一个花哨的字的。

1279
01:00:28,240 --> 01:00:29,986
>> 学生：如果我们想打印
整个字符串，我们可以

1280
01:00:29,986 --> 01:00:31,930
做符号指针？

1281
01:00:31,930 --> 01:00:33,490
>> JASON HIRSCHHORN：OK，我们都
要在这里暂停。

1282
01:00:33,490 --> 01:00:35,480
我们将在这里结束。

1283
01:00:35,480 --> 01:00:41,760
符号给你一个地址
位置，所以你做的时候符号

1284
01:00:41,760 --> 01:00:44,080
一个变量，它给你的地址
其中的变量存储。

1285
01:00:44,080 --> 01:00:48,580
符号指针会给你
PTR其中ptr是在内存中的地址。

1286
01:00:48,580 --> 01:00:50,140
>> 我们不会去
用这个例子。

1287
01:00:50,140 --> 01:00:52,640
你能弄清楚这些
自己的东西。

1288
01:00:52,640 --> 01:00:55,740
但是，这甚至可能是一个濒临
超越你需要知道的一点

1289
01:00:55,740 --> 01:00:58,000
这次中期的范围 - 

1290
01:00:58,000 --> 01:00:59,070
或本测验，而。

1291
01:00:59,070 --> 01:01:00,270
抱歉。

1292
01:01:00,270 --> 01:01:03,770
>> 我们要继续前进，因为我会
喜欢做一个编码问题

1293
01:01:03,770 --> 01:01:05,100
之前的时间到了。

1294
01:01:05,100 --> 01:01:09,340
而我们将要编写什么，我认为
是目前最引人注目的这些

1295
01:01:09,340 --> 01:01:11,020
例子，atoi的。

1296
01:01:11,020 --> 01:01:14,520
所以这是一个问题
测验两年前。

1297
01:01:14,520 --> 01:01:17,810
我有它的董事会这里。

1298
01:01:17,810 --> 01:01:20,680
>> 人们被要求在测验 - 

1299
01:01:20,680 --> 01:01:23,640
他们得到多一点tesxt在
的问题，但我消灭了

1300
01:01:23,640 --> 01:01:26,640
文本，因为它是不必要的
我们的目的了。

1301
01:01:26,640 --> 01:01:29,180
这只是一些背景
什么是atoi一样。

1302
01:01:29,180 --> 01:01:31,425
但大家都知道，是非常
熟悉的atoi。

1303
01:01:31,425 --> 01:01:35,620
>> 我建议你​​这个代码
上一张纸。

1304
01:01:35,620 --> 01:01:39,310
我也建议你使用策略
我们已经讨论了

1305
01:01:39,310 --> 01:01:41,040
很多在我们的一节。

1306
01:01:41,040 --> 01:01:44,130
首先，确保你理解
什么是atoi的做。

1307
01:01:44,130 --> 01:01:47,580
画一幅画或想出一些
它在你的脑袋的精神形象。

1308
01:01:47,580 --> 01:01:51,120
接下来，写出伪代码这一点。

1309
01:01:51,120 --> 01:01:53,120
在测验，如果你得到的是
伪代码，至少你

1310
01:01:53,120 --> 01:01:54,550
装上去了下来。

1311
01:01:54,550 --> 01:02:00,070
然后是伪代码映射到
C.如果你有一个检查在你的

1312
01:02:00,070 --> 01:02:03,760
伪代码，就像检查什么
是1，即映射到如果一个

1313
01:02:03,760 --> 01:02:05,750
条件等等。

1314
01:02:05,750 --> 01:02:07,850
最后，代码在C程序

1315
01:02:07,850 --> 01:02:15,000
>> 所以回去的atoi和需要五分钟
编写本上的纸

1316
01:02:15,000 --> 01:02:19,480
纸，这可能是关于
的时候，你会采取一个量

1317
01:02:19,480 --> 01:02:21,260
测验代码atoi的。

1318
01:02:21,260 --> 01:02:27,060
5至15分钟，5至12个，5到
10分钟后，大约的量

1319
01:02:27,060 --> 01:02:30,150
时间你会在这上面花
问题的问答。

1320
01:02:30,150 --> 01:02:31,670
因此，需要五分钟的话，请。

1321
01:02:31,670 --> 01:02:35,957
如果您有任何问题，提高
你的手，我会回到你身边。

1322
01:02:35,957 --> 01:06:39,570

1323
01:06:39,570 --> 01:06:41,066
>> [私下交谈]

1324
01:06:41,066 --> 01:08:35,279

1325
01:08:35,279 --> 01:08:37,580
>> JASON HIRSCHHORN：好了，
那是五分钟。

1326
01:08:37,580 --> 01:08:39,880
这是大概的金额
你最好花了一个测验，

1327
01:08:39,880 --> 01:08:42,120
那个时候，也许低端。

1328
01:08:42,120 --> 01:08:44,010
我们将回顾一下在一个位。

1329
01:08:44,010 --> 01:08:45,740
让我们开始编码了。

1330
01:08:45,740 --> 01:08:49,479
如果我们没有得到，一路过关斩将，
的答案，这个和这个

1331
01:08:49,479 --> 01:08:54,189
测验问题的情况下，再一次，
2011年秋季是当这个问题

1332
01:08:54,189 --> 01:08:54,913
出现在测验。

1333
01:08:54,913 --> 01:08:57,830
>> 而这是值得八个点
在测验即可。

1334
01:08:57,830 --> 01:09:01,140
八个点是对的高端
点的东西量是值得的。

1335
01:09:01,140 --> 01:09:04,790
大多数问题都在范围内
一到六个点。

1336
01:09:04,790 --> 01:09:08,500
所以这是一个更具挑战性
问题是肯定的。

1337
01:09:08,500 --> 01:09:09,750
谁能让我开始？

1338
01:09:09,750 --> 01:09:13,260

1339
01:09:13,260 --> 01:09:15,380
>> 一般情况下，究竟是为了什么
要想做这个

1340
01:09:15,380 --> 01:09:17,550
函数atoi，逻辑？

1341
01:09:17,550 --> 01:09:19,569
我们究竟想干什么？

1342
01:09:19,569 --> 01:09:22,279
所以我们要编写
一些伪代码。

1343
01:09:22,279 --> 01:09:24,090
>> 学生：转换字符
成整数。

1344
01:09:24,090 --> 01:09:26,700
>> JASON HIRSCHHORN：转换字符
成整数。

1345
01:09:26,700 --> 01:09:27,479
确定。

1346
01:09:27,479 --> 01:09:30,870
那么多少个字，我们都
将需要办理什么手续？

1347
01:09:30,870 --> 01:09:32,295
>> 学生：他们全部。

1348
01:09:32,295 --> 01:09:34,100
>> 学生：所有人物
在字符串中。

1349
01:09:34,100 --> 01:09:35,540
>> JASON HIRSCHHORN：所有
字符的字符串。

1350
01:09:35,540 --> 01:09:42,180
因此，如果我们想要去通过每一个
字符的字符串，是什么东西

1351
01:09:42,180 --> 01:09:44,560
C语言，我们已经看到，已经允许
我们走过的每

1352
01:09:44,560 --> 01:09:45,939
字符在一个字符串？

1353
01:09:45,939 --> 01:09:46,819
>> 学生：一个for循环。

1354
01:09:46,819 --> 01:09:48,069
>> JASON HIRSCHHORN：一个for循环。

1355
01:09:48,069 --> 01:09:52,020

1356
01:09:52,020 --> 01:09:55,330
因此，我们通过将循环
每个字符s中。

1357
01:09:55,330 --> 01:10:00,940
>> 那么什么是我们要想做
当我们得到一个特定的字符？

1358
01:10:00,940 --> 01:10:02,480
说我们就要过去了90。

1359
01:10:02,480 --> 01:10:03,460
我们得到了9。

1360
01:10:03,460 --> 01:10:04,240
这是一个字符。

1361
01:10:04,240 --> 01:10:07,440
什么是我们想要做的
该字符9？

1362
01:10:07,440 --> 01:10:10,082
>> 学生：从字符0中减去了吗？

1363
01:10:10,082 --> 01:10:11,860
>> 学生：加0？

1364
01:10:11,860 --> 01:10:13,350
>> JASON HIRSCHHORN：减去
它从字符0？

1365
01:10:13,350 --> 01:10:13,800
>> 学生：是啊。

1366
01:10:13,800 --> 01:10:15,573
>> JASON HIRSCHHORN：为什么
你想这样做？

1367
01:10:15,573 --> 01:10:16,560
>> 学生：[听不清]

1368
01:10:16,560 --> 01:10:17,010
值。

1369
01:10:17,010 --> 01:10:18,380
它的int值。

1370
01:10:18,380 --> 01:10:21,580
>> JASON HIRSCHHORN：好了，我们走
字符9，从它减去

1371
01:10:21,580 --> 01:10:25,820
字符0得到一个
实际整数9。

1372
01:10:25,820 --> 01:10:27,070
甜蜜。

1373
01:10:27,070 --> 01:10:31,255

1374
01:10:31,255 --> 01:10:37,000
你怎么知道字符
9负0字符是9？

1375
01:10:37,000 --> 01:10:39,222
你看什么图？

1376
01:10:39,222 --> 01:10:43,130
>> 学生：有逻辑上9
在9和0的地方。

1377
01:10:43,130 --> 01:10:44,620
或者你可以看一下ASCII表。

1378
01:10:44,620 --> 01:10:45,120
>> JASON HIRSCHHORN：ASCII表。

1379
01:10:45,120 --> 01:10:46,490
但是，是的，你是正确的为好。

1380
01:10:46,490 --> 01:10:47,780
所以我们减去0。

1381
01:10:47,780 --> 01:10:49,010
所以，现在我们有整数9。

1382
01:10:49,010 --> 01:10:49,970
什么我们想要做的是什么？

1383
01:10:49,970 --> 01:10:54,970
如果我们有90，它是一个整数
我们，就是我们想干什么？

1384
01:10:54,970 --> 01:10:58,180
>> 学生：我把一个临时整数
数组，然后做数学吧

1385
01:10:58,180 --> 01:11:02,088
后来将它做成了尽头。

1386
01:11:02,088 --> 01:11:03,020
>> JASON HIRSCHHORN：确定。

1387
01:11:03,020 --> 01:11:06,990
>> 学生：您可以开始在年底
该数组，然后向前移动，以便

1388
01:11:06,990 --> 01:11:10,350
你往前走每一次，
你乘以10。

1389
01:11:10,350 --> 01:11:10,830
>> JASON HIRSCHHORN：确定。

1390
01:11:10,830 --> 01:11:12,250
这听起来像一个漂亮的
引人注目的想法。

1391
01:11:12,250 --> 01:11:16,040
我们可以在我们的数组的末尾开始，
而且我们可以使用strleng。

1392
01:11:16,040 --> 01:11:17,030
我们可以在这里使用strleng。

1393
01:11:17,030 --> 01:11:18,870
我们会得到我们的字符串的长度。

1394
01:11:18,870 --> 01:11:20,100
首先，我们在最后。

1395
01:11:20,100 --> 01:11:29,170
和+第一位的，我们只取了
整数，也许我们创建一个像

1396
01:11:29,170 --> 01:11:32,270
新的整型变量往上顶，其中
我们要存储的一切。

1397
01:11:32,270 --> 01:11:37,340
因此，我们通过以s每个字符从环
回到前面，我们减去0，

1398
01:11:37,340 --> 01:11:42,790
然后我们把它，并根据
它在哪里，我们乘它

1399
01:11:42,790 --> 01:11:45,860
以10的幂。

1400
01:11:45,860 --> 01:11:50,644
因为第一个，我们怎么办
乘以最右边的字符？

1401
01:11:50,644 --> 01:11:51,440
>> 学生：10到0。

1402
01:11:51,440 --> 01:11:53,170
>> JASON HIRSCHHORN：10到0。

1403
01:11:53,170 --> 01:11:56,010
什么是我们乘第二
最右边的字符通过？

1404
01:11:56,010 --> 01:11:57,450
>> 学生：[听不清]。

1405
01:11:57,450 --> 01:11:57,960
>> JASON HIRSCHHORN：什么？

1406
01:11:57,960 --> 01:11:59,150
>> 学生：10到1。

1407
01:11:59,150 --> 01:12:00,420
>> JASON HIRSCHHORN：10到1。

1408
01:12:00,420 --> 01:12:03,754
第三，最右边的字符？

1409
01:12:03,754 --> 01:12:04,580
>> 学生：10到2。

1410
01:12:04,580 --> 01:12:05,350
>> 杰森HIRSCHHORN：10至2。

1411
01:12:05,350 --> 01:12:07,200
>> 学生：对不起，我不明白
我们在这里做的。

1412
01:12:07,200 --> 01:12:08,640
>> JASON HIRSCHHORN：OK，
让我们回去，然后。

1413
01:12:08,640 --> 01:12:12,500
所以，我们要得到
传递的字符串。

1414
01:12:12,500 --> 01:12:14,470
因为我们正在写的atoi。

1415
01:12:14,470 --> 01:12:15,260
所以我们得到传递的字符串。

1416
01:12:15,260 --> 01:12:17,640
说，我们正在获得通过
在串90。

1417
01:12:17,640 --> 01:12:19,930
>> 我们要做的第一件事就是设置
一个新的整型变量，我们是

1418
01:12:19,930 --> 01:12:22,150
只是要创建
作为我们新的整数。

1419
01:12:22,150 --> 01:12:24,630
这就是我们要去
返回在最后。

1420
01:12:24,630 --> 01:12:30,110
我们需要经过每一个字符
的字符串，因为我们已经确定

1421
01:12:30,110 --> 01:12:34,430
我们需要触摸每一个和
然后将其添加到我们的新的整数。

1422
01:12:34,430 --> 01:12:36,330
>> 但是，我们不能仅仅将其作为一个数字。

1423
01:12:36,330 --> 01:12:38,270
我们不能只取9和
新增9对我们的整数。

1424
01:12:38,270 --> 01:12:40,560
这要看是什么地方
它是字符串中。

1425
01:12:40,560 --> 01:12:42,960
我们将需要乘
它由10的幂。

1426
01:12:42,960 --> 01:12:45,580
因为那是基地10件作品。

1427
01:12:45,580 --> 01:12:49,050
>> 所以，我们要获得实际的
字符，或实际整数

1428
01:12:49,050 --> 01:12:53,860
数，减去字符0
从9字就像我们一样

1429
01:12:53,860 --> 01:12:57,560
从减去字符大写A
任何性质我们在一

1430
01:12:57,560 --> 01:12:58,120
这些问题。

1431
01:12:58,120 --> 01:13:04,190
因此，我们将真正得到一个从0到
9保存为一个实数，我们将

1432
01:13:04,190 --> 01:13:07,590
由10根据功率乘以
在我们所处的字符串中。

1433
01:13:07,590 --> 01:13:19,430

1434
01:13:19,430 --> 01:13:22,575
然后我们将其添加​​回
成我们新的整型变量。

1435
01:13:22,575 --> 01:13:32,840

1436
01:13:32,840 --> 01:13:37,890
>> 那么，这看起来就像会
可以 - 我们将绘制在这里。

1437
01:13:37,890 --> 01:13:40,086
如果我们传递的字符串90  - 

1438
01:13:40,086 --> 01:13:41,336
>> 学生：[听不清]。

1439
01:13:41,336 --> 01:13:43,190

1440
01:13:43,190 --> 01:13:45,540
>> JASON HIRSCHHORN：但
atoi的接受一个字符串。

1441
01:13:45,540 --> 01:13:46,350
因此，我们要经过
的控股。

1442
01:13:46,350 --> 01:13:49,900
我们会获得通过的90。

1443
01:13:49,900 --> 01:13:51,540
我们去从后面到前面。

1444
01:13:51,540 --> 01:13:53,920
我们以0。

1445
01:13:53,920 --> 01:13:55,080
>> 学生：我很抱歉。

1446
01:13:55,080 --> 01:13:55,880
也许这是愚蠢的。

1447
01:13:55,880 --> 01:13:59,440
如果我们得到传入一个字符串，
为什么是90我们在做什么

1448
01:13:59,440 --> 01:14:00,260
获得通过的？

1449
01:14:00,260 --> 01:14:03,160
因为90是一个整数。

1450
01:14:03,160 --> 01:14:06,820
>> JASON HIRSCHHORN：因为atoi的需要
字符串，并把它变成整数

1451
01:14:06,820 --> 01:14:08,320
该字符串表示形式。

1452
01:14:08,320 --> 01:14:13,650
但是字符串90不是整数
90或90位。

1453
01:14:13,650 --> 01:14:17,920
串90是两个阵列，或
三个大字，相反，9

1454
01:14:17,920 --> 01:14:22,740
字符，字符0，和
反斜杠字符0。

1455
01:14:22,740 --> 01:14:26,260
>> 我们正在写的atoi，因为，
例如，当你把命令

1456
01:14:26,260 --> 01:14:30,230
行参数，并且它保存在
argv的，它保存为一个字符串。

1457
01:14:30,230 --> 01:14:32,940
但是如果你想将其视为一个数字，
您需要将其转换为

1458
01:14:32,940 --> 01:14:34,700
实际的整数。

1459
01:14:34,700 --> 01:14:37,210
我们做了我们的问题集之一。

1460
01:14:37,210 --> 01:14:38,800
我们在一些做
我们的习题集。

1461
01:14:38,800 --> 01:14:41,690
大家，把一个整数
作为命令行参数。

1462
01:14:41,690 --> 01:14:46,490
所以这就是为什么我们的atoi函数
接受一个字符串。

1463
01:14:46,490 --> 01:14:51,910
>> 所以，再一次，在这里我们的例子中，我们
要采取最后一个。

1464
01:14:51,910 --> 01:14:55,050
我们要减去字符
0从它，因为字符0

1465
01:14:55,050 --> 01:14:58,810
减去字符0给你
的实际数目为0，根据

1466
01:14:58,810 --> 01:15:00,950
ASCII码的数学，我们做的。

1467
01:15:00,950 --> 01:15:04,870
>> 因为字符被表示为
不同于他们的实际 - 的

1468
01:15:04,870 --> 01:15:08,830
一个字符，例如
小写字母a为97。

1469
01:15:08,830 --> 01:15:10,260
这不是 - 糟糕！

1470
01:15:10,260 --> 01:15:13,290
这不是任何你所期望的
它是，例如0。

1471
01:15:13,290 --> 01:15:16,200
所以，你必须减去
字符得到0。

1472
01:15:16,200 --> 01:15:18,950
>> 所以，我们要做的是，这里
得到的实际数量。

1473
01:15:18,950 --> 01:15:22,560
然后我们将通过乘以它
10的幂取决于它

1474
01:15:22,560 --> 01:15:27,030
是在字符串中，然后采取
并把它添加到我们的占位符

1475
01:15:27,030 --> 01:15:32,520
变量，所以我们可以拿出
我们最终的新的整数。

1476
01:15:32,520 --> 01:15:35,080
这是否有道理给大家？

1477
01:15:35,080 --> 01:15:37,730
>> 因此，我们不打算这个代码
现在，因为我们

1478
01:15:37,730 --> 01:15:38,830
越来越短的时间。

1479
01:15:38,830 --> 01:15:40,860
我的，何时道歉。

1480
01:15:40,860 --> 01:15:44,620
但是，这是什么，希望你会
能够做的测验 - 在

1481
01:15:44,620 --> 01:15:47,710
最起码，得到这个伪代码
写出来。

1482
01:15:47,710 --> 01:15:50,840
>> 然后，如果我们写的
伪代码，实际上，我们可以这样做

1483
01:15:50,840 --> 01:15:51,490
很快。

1484
01:15:51,490 --> 01:15:55,230
注释每一行我们我们写
在这里转化为约

1485
01:15:55,230 --> 01:15:56,970
一行C代码。

1486
01:15:56,970 --> 01:16:01,780
声明一个新的变量，写作
一个循环中，一些减法，一些

1487
01:16:01,780 --> 01:16:07,070
乘法和一些分配。

1488
01:16:07,070 --> 01:16:09,020
我们可能还需要
写一个返回行。

1489
01:16:09,020 --> 01:16:12,040
我们可能还需要放
一些检查在这里。

1490
01:16:12,040 --> 01:16:12,655
是啊。

1491
01:16:12,655 --> 01:16:15,720
>> 学生：所以我们可以把
S作为实际的字符串？

1492
01:16:15,720 --> 01:16:18,730
因为我知道这只是一个地址。

1493
01:16:18,730 --> 01:16:22,090
就像，你会怎么得到的长度
该字符串被通过？

1494
01:16:22,090 --> 01:16:25,310
>> JASON HIRSCHHORN：那么，如何做
字符串的长度是多少？

1495
01:16:25,310 --> 01:16:25,830
strlen的。

1496
01:16:25,830 --> 01:16:26,660
>> 学生：strlen的，是的。

1497
01:16:26,660 --> 01:16:30,550
不过你能不能把S作为
论点是什么？

1498
01:16:30,550 --> 01:16:34,620
>> JASON HIRSCHHORN：所以strlen的
需要一个char明星。

1499
01:16:34,620 --> 01:16:38,090
接下去就是字符明星，它
保持计数，直到它到达一个

1500
01:16:38,090 --> 01:16:41,865
反斜杠0。 strlen的竟是
其他项目之一，我们

1501
01:16:41,865 --> 01:16:42,850
将要的代码。

1502
01:16:42,850 --> 01:16:44,560
这是另一个很好的一个代码。

1503
01:16:44,560 --> 01:16:47,270
一个人的更容易一点，因为如果
你要想想，

1504
01:16:47,270 --> 01:16:47,830
概念 - 

1505
01:16:47,830 --> 01:16:51,620
我只是说出来大声 -  strlen的如下
一个指针，并保持持续和

1506
01:16:51,620 --> 01:16:54,210
计数和跟踪，直到
你达到一个反斜杠0。

1507
01:16:54,210 --> 01:16:56,530
>> 学生：好的，知道了。

1508
01:16:56,530 --> 01:17:00,200
>> JASON HIRSCHHORN：所以最好的
运气测验0的明天。

1509
01:17:00,200 --> 01:17:03,170
如果您有任何问题，我会
在此之后在外面。

1510
01:17:03,170 --> 01:17:05,610
请随时给我发电子邮件。

1511
01:17:05,610 --> 01:17:08,480
伸出自己的TF，如果你
不是在我的部分，或者让我

1512
01:17:08,480 --> 01:17:10,005
如果你想通过电子邮件发送。

1513
01:17:10,005 --> 01:17:13,140
>> 如果你想发飙了，只是发送
我一个电子邮件，一个FREAKOUT电子邮件，我会

1514
01:17:13,140 --> 01:17:16,710
送你回去，像一个笑脸，
还是一样，开个玩笑什么的。

1515
01:17:16,710 --> 01:17:18,190
可以随意做，也是如此。

1516
01:17:18,190 --> 01:17:20,750
祝你好运再次，我会
见到大家下周。

1517
01:17:20,750 --> 01:17:23,435