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

2
00:00:05,115 --> 00:00:07,230
>> JASON HIRSCHHORN：欢迎
四个星期，每次一片。

3
00:00:07,230 --> 00:00:09,910
我们有我们的忙提前一周。

4
00:00:09,910 --> 00:00:14,030
本周一和周三
上周，你已经被引入到

5
00:00:14,030 --> 00:00:17,920
指针，所以希望有
吹你的头脑，但是希望不是

6
00:00:17,920 --> 00:00:18,870
让你太糊涂了。

7
00:00:18,870 --> 00:00:23,140
如果有，我们将在在
节今天以及我们要去

8
00:00:23,140 --> 00:00:24,510
做指针。

9
00:00:24,510 --> 00:00:28,090
我们要投奔的堆栈，该堆栈
我们在讲课讲到

10
00:00:28,090 --> 00:00:32,150
了，我们要去暗示
东西来在周三及以后

11
00:00:32,150 --> 00:00:33,780
在内存管理方面。

12
00:00:33,780 --> 00:00:38,430
最后，我们要商量了一下
关于斯坦福便携式语言，

13
00:00:38,430 --> 00:00:41,920
这是你们的图书馆
利用这个星期来实现

14
00:00:41,920 --> 00:00:43,900
问题集。

15
00:00:43,900 --> 00:00:46,020
>> 正如我向你们上周 - 

16
00:00:46,020 --> 00:00:48,750
我想再次把这个向上滑动，
因为这是一个列表

17
00:00:48,750 --> 00:00:51,680
可用资源
你CS50。

18
00:00:51,680 --> 00:00:54,670
这些都是我们给你出的
框，这些是令人难以置信的

19
00:00:54,670 --> 00:00:57,160
重要的是什么
下一张幻灯片将显示。

20
00:00:57,160 --> 00:01:00,110
但在此之前我们得到的下一张幻灯片，
我想去过这些了。

21
00:01:00,110 --> 00:01:03,410
>> 对于每一个讲座，也有
注释所采取。

22
00:01:03,410 --> 00:01:06,850
这是演讲的摘要，但它
也有代码段和帮助

23
00:01:06,850 --> 00:01:07,510
技巧和窍门。

24
00:01:07,510 --> 00:01:11,140
所以，如果您要查看的演讲 - 
希望你没有错过的讲座，但

25
00:01:11,140 --> 00:01:13,760
如果你没有，你应该rewatch  - 但
当您要查看的讲座，

26
00:01:13,760 --> 00:01:15,530
一定要看看这些
讲义。

27
00:01:15,530 --> 00:01:18,770
还有源代码在线
从每一个讲座。

28
00:01:18,770 --> 00:01:23,680
>> cs50.net/shorts很短，
6至12分钟的短片。

29
00:01:23,680 --> 00:01:25,470
你们已经看到了很多人。

30
00:01:25,470 --> 00:01:28,820
也有视频，我们不分配
给你，但封面主题是

31
00:01:28,820 --> 00:01:30,310
本课程涵盖的讲座。

32
00:01:30,310 --> 00:01:33,550
所以，如果你想更新这些
主题，你看看这些短裤。

33
00:01:33,550 --> 00:01:37,830
>> study.cs50.net有引
上一吨话题。

34
00:01:37,830 --> 00:01:38,880
它具有视频。

35
00:01:38,880 --> 00:01:39,930
它具有实践问题。

36
00:01:39,930 --> 00:01:41,880
这是一个奇妙的资源。

37
00:01:41,880 --> 00:01:46,380
快来任何问题，但
也考考时间。

38
00:01:46,380 --> 00:01:47,390
>> 一对夫妇更多的资源。

39
00:01:47,390 --> 00:01:50,160
有一个在man命令
终端给你一些

40
00:01:50,160 --> 00:01:52,590
在一个特定的信息
函数或命令。

41
00:01:52,590 --> 00:01:55,320
有谷歌，我最喜欢的资源 - 
我最喜欢的资源。

42
00:01:55,320 --> 00:01:58,610
我最喜欢的资源是最后一个，
我们会得到一个第二。

43
00:01:58,610 --> 00:02:00,520
有cs50.net/discuss。

44
00:02:00,520 --> 00:02:01,930
这是我们的班级论坛。

45
00:02:01,930 --> 00:02:05,080
有办公时间周一至
星期四，上午8:00至11:00。

46
00:02:05,080 --> 00:02:08,669
也有网上办公时间
延期的学生。

47
00:02:08,669 --> 00:02:12,010
>> 最后，如​​果你需要什么，
有任何疑问，意见或

48
00:02:12,010 --> 00:02:14,240
关注，你有我
联系方式。

49
00:02:14,240 --> 00:02:16,900
与我取得联系，谢谢。

50
00:02:16,900 --> 00:02:20,970
>> 所以当我暗示，下周三，一
从明天起一周，是你的第一

51
00:02:20,970 --> 00:02:25,180
测验，测验为零，因为在计算机
科学，我们从零开始计数。

52
00:02:25,180 --> 00:02:28,620
更多信息将在提供
明天的演讲，和一个手将

53
00:02:28,620 --> 00:02:33,510
最终被发布到网上与更多
具体的细节，特别是

54
00:02:33,510 --> 00:02:34,860
测验零的位置。

55
00:02:34,860 --> 00:02:37,390
但它会将于下周三
而不是讲座。

56
00:02:37,390 --> 00:02:40,670
有没有讲座下周一
因为它是一个节日。

57
00:02:40,670 --> 00:02:45,010
>> 此测验将涵盖所有的材料
从零一周到五周，

58
00:02:45,010 --> 00:02:47,420
所以通过这个星期，通过
讲课的明天。

59
00:02:47,420 --> 00:02:49,710
材料包括讲座。

60
00:02:49,710 --> 00:02:51,580
材料包括部分。

61
00:02:51,580 --> 00:02:55,970
材料包括习题集，和
尤其是开始部分，

62
00:02:55,970 --> 00:02:58,590
在哪里你走了习题集
通过一些背景资料

63
00:02:58,590 --> 00:02:59,780
你即将覆盖。

64
00:02:59,780 --> 00:03:02,570
不要期待通过这些习题集。

65
00:03:02,570 --> 00:03:07,340
>> 为了帮助您所有的测验，下一
周一，即使它是一个节日，

66
00:03:07,340 --> 00:03:10,570
该课程将举办
当然性检讨会议。

67
00:03:10,570 --> 00:03:13,465
视频课程范围的审查会议
将在网上公布，如果你

68
00:03:13,465 --> 00:03:14,570
不能够做到这一点。

69
00:03:14,570 --> 00:03:18,510
此外，在第下星期二
我们会做一吨测验

70
00:03:18,510 --> 00:03:22,810
审查并希望玩一些
危险为好，但我们要

71
00:03:22,810 --> 00:03:25,220
是想在回答你所有的
的问题，但我会拿出

72
00:03:25,220 --> 00:03:27,710
很多有帮助的问题
并根据信息

73
00:03:27,710 --> 00:03:29,540
在10年测验。

74
00:03:29,540 --> 00:03:31,780
我有一个什么样的一个不错的主意
要显示出来，以及如何的问题是

75
00:03:31,780 --> 00:03:36,640
将要问，所以我们就去了
那些在节下周二。

76
00:03:36,640 --> 00:03:39,260
>> 此外，我并没有把这个向上滑动
上周，不过这是后话，我们

77
00:03:39,260 --> 00:03:40,030
上周做了。

78
00:03:40,030 --> 00:03:42,960
这是我们如何走近了很多
的编码问题，我们做到了。

79
00:03:42,960 --> 00:03:46,710
我想提炼出我们的方法
成一些简单的步骤，可以帮助

80
00:03:46,710 --> 00:03:49,580
你解决一个编码问题。

81
00:03:49,580 --> 00:03:53,710
>> 记得在上周，我们的二进制编码
搜索和我们做的第一件事

82
00:03:53,710 --> 00:03:55,820
当我们需要编写二进制搜索
是我们在考虑我们

83
00:03:55,820 --> 00:03:57,090
领导它是如何工作的。

84
00:03:57,090 --> 00:04:00,400
我们没有画一幅画在课堂上，但
我问大家看短

85
00:04:00,400 --> 00:04:03,250
视频，这也有一个图片
如何表示

86
00:04:03,250 --> 00:04:04,900
二进制搜索工作。

87
00:04:04,900 --> 00:04:07,800
第一，我们真正想做的事
明白了什么是画

88
00:04:07,800 --> 00:04:09,900
图片来了解它的逻辑，
为了确保我们知道

89
00:04:09,900 --> 00:04:11,530
这个东西怎么工作的。

90
00:04:11,530 --> 00:04:14,670
>> 接下来的事情，我们在一节没有你
上周我们把我们的精神

91
00:04:14,670 --> 00:04:17,100
模型，我们把它
到一些伪代码。

92
00:04:17,100 --> 00:04:21,570
伪代码，同样，编程类
语法在口头上，而不是C代码。

93
00:04:21,570 --> 00:04:26,210
甚至具体到C。我们只是把我们的
思路，并采取了英语，我们使用

94
00:04:26,210 --> 00:04:31,510
把它表达出来，并写出来的
某种方案的前瞻性的方式。

95
00:04:31,510 --> 00:04:32,550
所以，这只是逻辑的一部分。

96
00:04:32,550 --> 00:04:34,010
我们把我们的逻辑照顾第一。

97
00:04:34,010 --> 00:04:36,930
我们分手了这个硬编程
问题分为两部分，并且我们把

98
00:04:36,930 --> 00:04:38,670
关心逻辑部分的第一。

99
00:04:38,670 --> 00:04:40,520
>> 然后我们走近
语法部分。

100
00:04:40,520 --> 00:04:43,830
记得在我们制定了
伪代码中，我们挑选出的部分

101
00:04:43,830 --> 00:04:47,840
伪代码，我们知道映射到
在C中的特定元素，例如，

102
00:04:47,840 --> 00:04:53,050
for循环，if条件，或更大
大于或等于运算符。

103
00:04:53,050 --> 00:04:56,100
最后，我们做的最后一件事，
我们做的最后一件事，是

104
00:04:56,100 --> 00:04:58,640
在C代码其实这个节目

105
00:04:58,640 --> 00:05:02,100
>> 我们要经过这个过程
今天再次在一个比较大的

106
00:05:02,100 --> 00:05:05,620
编码问题，将占用
散节的下半年，

107
00:05:05,620 --> 00:05:07,730
但我想打好这个框架
在这里为你们。

108
00:05:07,730 --> 00:05:11,435
这就是我们一直在逼近
在课堂上的问题，以及如何可能

109
00:05:11,435 --> 00:05:14,610
你一直在处理这些问题
你自己以外的部分。

110
00:05:14,610 --> 00:05:16,990
所以，我要离开这里了这件事，
我们会重提这个当

111
00:05:16,990 --> 00:05:21,930
我们今天的编码后，去
系统通过这些步骤。

112
00:05:21,930 --> 00:05:23,320
>> 最后，反馈。

113
00:05:23,320 --> 00:05:27,670
如果您有任何意见对我来说，
网站是在这张幻灯片的顶部，

114
00:05:27,670 --> 00:05:29,670
sayat.me/cs50。

115
00:05:29,670 --> 00:05:30,460
给我一些反馈。

116
00:05:30,460 --> 00:05:33,320
我得到了一些意想不到的反馈
从你们的最后一周。

117
00:05:33,320 --> 00:05:36,470
你说你真的很喜欢
pseudocoding和编码，我们做到了。

118
00:05:36,470 --> 00:05:41,250
也有人给了我一个链接到一个研究
这表明，等待

119
00:05:41,250 --> 00:05:46,200
询问是否经过三至7秒
任何人有问题是最优

120
00:05:46,200 --> 00:05:47,240
时间等待。

121
00:05:47,240 --> 00:05:50,850
所以，如果你有你的秒表出来，
今天我要去尝试，等待7

122
00:05:50,850 --> 00:05:56,240
秒后我问，如果任何人有
在移动之前的任何问题。

123
00:05:56,240 --> 00:05:59,340
>> 所以，在我们继续之前，是否有人
有任何疑问，这么远吗？

124
00:05:59,340 --> 00:06:06,470

125
00:06:06,470 --> 00:06:07,810
>> 控制室给了我七秒。

126
00:06:07,810 --> 00:06:11,480
OK，没人有任何问题，但
随时问他们，如果你这样做。

127
00:06:11,480 --> 00:06:15,110
>> 首先，本周我们将要覆盖
指针，因为我们暗示了在

128
00:06:15,110 --> 00:06:16,910
议程在类的开始。

129
00:06:16,910 --> 00:06:18,060
你见过在课堂上的指针。

130
00:06:18,060 --> 00:06:21,040
他们可能已经融化你的心。

131
00:06:21,040 --> 00:06:25,050
这是确定的，这就是他们对我做了
数百名CS50的学生在你面前。

132
00:06:25,050 --> 00:06:29,900
因此，在未来10到30分钟，我们
要通过这些指针

133
00:06:29,900 --> 00:06:31,450
慢慢地，系统地。

134
00:06:31,450 --> 00:06:34,490
如果在任何时候你有什么
问题，请提问。

135
00:06:34,490 --> 00:06:38,430
我保证，在此您同行
部分和在家里看有

136
00:06:38,430 --> 00:06:41,050
完全相同的问题。

137
00:06:41,050 --> 00:06:45,660
>> 让我们来谈谈一般首先，我们才
潜入指针，有关变量

138
00:06:45,660 --> 00:06:47,900
和数据，这我们已经
使用前被。

139
00:06:47,900 --> 00:06:50,800
除了具有这些事
上一个幻灯片，我要去

140
00:06:50,800 --> 00:06:52,050
画这些了。

141
00:06:52,050 --> 00:06:54,400

142
00:06:54,400 --> 00:07:00,140
>> 正如这张幻灯片说，内存中的数据有
两者的值和地址，所以我们

143
00:07:00,140 --> 00:07:03,260
要表示的东西
在存储器中。

144
00:07:03,260 --> 00:07:06,460
记得上周，当你看到
正在绘制数组，我们一般画

145
00:07:06,460 --> 00:07:10,850
他们为一系列框，因此我们将
只是画一个变量为一个框

146
00:07:10,850 --> 00:07:13,100
某处在存储器中。

147
00:07:13,100 --> 00:07:18,480
这个盒子在这个例子中，我们将
称之为X，并且它有一个值。

148
00:07:18,480 --> 00:07:23,700
在这种情况下，我们正在初始化
该变量的值50。

149
00:07:23,700 --> 00:07:30,260
>> 您还会注意到，除了
刚刚的价值，这个变量x的

150
00:07:30,260 --> 00:07:31,570
位置在存储器中。

151
00:07:31,570 --> 00:07:34,870
事实上，你可能是有点
知道，内存有

152
00:07:34,870 --> 00:07:36,180
有限数量的空格。

153
00:07:36,180 --> 00:07:39,490
还有在你的只有这么多箱子
计算机可以存储的东西。

154
00:07:39,490 --> 00:07:42,580
更好的是，让你知道的事情
被存储，每个方块有

155
00:07:42,580 --> 00:07:46,340
特定地址，特定数量的
在这里你可以找到它。

156
00:07:46,340 --> 00:07:52,540
就像新生都有自己的
在科学中心邮寄地址，

157
00:07:52,540 --> 00:07:55,070
在内存中的每个方块有
一个特定的地址。

158
00:07:55,070 --> 00:07:57,750
当你去到那个地址，你
能得到什么设在那里。

159
00:07:57,750 --> 00:08:02,300

160
00:08:02,300 --> 00:08:05,000
>> 我要完全任意的与
这个变量的地址，但我

161
00:08:05,000 --> 00:08:07,450
接下来要说的地址是123。

162
00:08:07,450 --> 00:08:08,700
现在，我不只是写1-2-3。

163
00:08:08,700 --> 00:08:10,990
我写了为0x123。

164
00:08:10,990 --> 00:08:15,280
该0X部分表示这是
一个十六进制数。

165
00:08:15,280 --> 00:08:19,800
我们不打算谈论
十六进制很多今天，但要注意，

166
00:08:19,800 --> 00:08:23,750
当我们参照的存储器地址，
我们称它们为十六进制。

167
00:08:23,750 --> 00:08:27,000
所以每当我在谈论一个
地址，我会把那0x开头，这就是

168
00:08:27,000 --> 00:08:29,400
只是说123是
十六进制数。

169
00:08:29,400 --> 00:08:30,430
它的基数为16。

170
00:08:30,430 --> 00:08:32,760
它不是以10为基数。

171
00:08:32,760 --> 00:08:34,270
>> 没有任何人有任何
问题这么远吗？

172
00:08:34,270 --> 00:08:42,090

173
00:08:42,090 --> 00:08:42,950
>> 完美的。

174
00:08:42,950 --> 00:08:44,430
所以这是一个变量。

175
00:08:44,430 --> 00:08:47,020
我们已经看到过，但现在我们
出发去引擎盖下，看看

176
00:08:47,020 --> 00:08:48,350
什么是实际发生的事情。

177
00:08:48,350 --> 00:08:49,910
>> 所以，指针。

178
00:08:49,910 --> 00:08:54,090
关于指针很酷的事情是，
不像有一个正常的变量

179
00:08:54,090 --> 00:08:57,500
一些数值，某些整数，一些
性格，也许是一系列的

180
00:08:57,500 --> 00:09:01,930
字符，如果我们谈论的
数组，指针具有值是

181
00:09:01,930 --> 00:09:04,290
一个地址。

182
00:09:04,290 --> 00:09:07,470
在屏幕上，我们与int x
等于50，我们之前创建的。

183
00:09:07,470 --> 00:09:09,060
我已经画了框。

184
00:09:09,060 --> 00:09:12,090
>> 让我们也画一个框。

185
00:09:12,090 --> 00:09:14,490
这将是 - 哦，我的天啊。

186
00:09:14,490 --> 00:09:15,810
我们需要一个新的标志。

187
00:09:15,810 --> 00:09:19,270

188
00:09:19,270 --> 00:09:19,845
也不遑多让。

189
00:09:19,845 --> 00:09:23,230
>> 但我们要调用此框 - 这
在变量称为指针。

190
00:09:23,230 --> 00:09:24,650
指针还具有一个地址。

191
00:09:24,650 --> 00:09:26,180
这是在一个不同的地址。

192
00:09:26,180 --> 00:09:27,270
这是一个不同的变量。

193
00:09:27,270 --> 00:09:28,820
这不是要上
第一个的上面。

194
00:09:28,820 --> 00:09:32,330
你可以不拿把两件事情
内部邮箱。

195
00:09:32,330 --> 00:09:34,160
你不能覆盖初始
之一，所以我们要在

196
00:09:34,160 --> 00:09:35,200
这里不同的地址。

197
00:09:35,200 --> 00:09:37,880
我们给它的地址456。

198
00:09:37,880 --> 00:09:42,190
但指针的值将是一个
地址，并且在这种情况下，它会

199
00:09:42,190 --> 00:09:45,750
要解决的x变量的。

200
00:09:45,750 --> 00:09:50,000
所以里面的指针，我们要存储
地址123。

201
00:09:50,000 --> 00:09:52,700
>> 我用的语法来写它 - 我们
要去了语法在

202
00:09:52,700 --> 00:09:56,420
第二个，但要知道，在这个语法
幻灯片是你可以使用的语法

203
00:09:56,420 --> 00:09:58,700
设置此情况向上 - 

204
00:09:58,700 --> 00:10:02,735
之前我们得到的语法，不过，我
要明确到每一个人，

205
00:10:02,735 --> 00:10:05,900
确保每个人都明白，
从指针变量作为不同的

206
00:10:05,900 --> 00:10:11,560
有一个地址作为自己的价值，
不为整数或字符。

207
00:10:11,560 --> 00:10:13,470
>> 到目前为止好？

208
00:10:13,470 --> 00:10:16,360
>> 一般也，当我们这些图纸
的东西，我不只是要

209
00:10:16,360 --> 00:10:18,320
绘制地址在这里。

210
00:10:18,320 --> 00:10:24,100
我要去参加一个箭头从这个
框到其他变量，它的

211
00:10:24,100 --> 00:10:29,590
指着给予这个意义上说，如果我
分别来看看地址123，如果

212
00:10:29,590 --> 00:10:34,130
我是用这个指针来查找
它的指向，我会得到

213
00:10:34,130 --> 00:10:35,150
此框在这里。

214
00:10:35,150 --> 00:10:36,400
我会得到数50。

215
00:10:36,400 --> 00:10:40,010

216
00:10:40,010 --> 00:10:41,810
>> 是的，质疑？

217
00:10:41,810 --> 00:10:46,200
>> 学生：如果指针存储的地址，
那么我们该如何选择阵列，和int

218
00:10:46,200 --> 00:10:48,650
明星，或像一个char
明星，或什么？

219
00:10:48,650 --> 00:10:50,190
>> JASON HIRSCHHORN：你能
重复的中间部分？

220
00:10:50,190 --> 00:10:51,310
我失去了你。

221
00:10:51,310 --> 00:10:55,070
>> 学生：你如何选择阵列，
就像一个int星级或char明星，或

222
00:10:55,070 --> 00:10:57,200
什么，如果它总是
存储的地址？

223
00:10:57,200 --> 00:10:59,340
>> JASON HIRSCHHORN：好问题。

224
00:10:59,340 --> 00:11:01,730
我们如何选择什么，它实际上
指着若

225
00:11:01,730 --> 00:11:03,010
总是存储一个地址？

226
00:11:03,010 --> 00:11:07,840
如果不要写成整数星级权利
在这里，我写的char明星，这将是

227
00:11:07,840 --> 00:11:09,090
指着 - 

228
00:11:09,090 --> 00:11:11,770

229
00:11:11,770 --> 00:11:14,750
这是我们会写，如果我们想
它指向一个字符。

230
00:11:14,750 --> 00:11:19,720
深，深跌的一和零
世界，那整数，即字符，不

231
00:11:19,720 --> 00:11:20,600
真正的问题。

232
00:11:20,600 --> 00:11:24,280
但在C而言，它要你
是相当具体的条款

233
00:11:24,280 --> 00:11:27,660
类型你指向的东西。

234
00:11:27,660 --> 00:11:30,240
的水平，我们正在编程，
我们将写

235
00:11:30,240 --> 00:11:32,670
事情类型我们点
尽管它总是一个

236
00:11:32,670 --> 00:11:34,940
解决这里面框。

237
00:11:34,940 --> 00:11:38,980

238
00:11:38,980 --> 00:11:40,420
你有问题吗？

239
00:11:40,420 --> 00:11:41,670
确定。

240
00:11:41,670 --> 00:11:43,240

241
00:11:43,240 --> 00:11:47,610
>> 现在我们要看看
一些语法指针。

242
00:11:47,610 --> 00:11:50,070
在这张幻灯片中的第一行 - 

243
00:11:50,070 --> 00:11:52,520
整型明星，空间，指针 - 

244
00:11:52,520 --> 00:11:54,770
初始化并创建 - 

245
00:11:54,770 --> 00:11:56,040
没有初始化，而。

246
00:11:56,040 --> 00:11:58,680
不设置它等于什么，
但它创造这个指针。

247
00:11:58,680 --> 00:12:01,090
所以在我的图的形式 - 

248
00:12:01,090 --> 00:12:03,790
让我们去这一边 - 

249
00:12:03,790 --> 00:12:08,510
首行，诠释明星
指针，创建一个框。

250
00:12:08,510 --> 00:12:12,800
这个箱子是指针变量，
它是在一个地址。

251
00:12:12,800 --> 00:12:16,250
我们给它一个不同的
地址999。

252
00:12:16,250 --> 00:12:17,010
>> 这是所有行的作用。

253
00:12:17,010 --> 00:12:17,970
我们之前已经看到这一点。

254
00:12:17,970 --> 00:12:21,750
这就像任何时间，如果我只是
写诠释x那里，它会做

255
00:12:21,750 --> 00:12:24,210
同样的事情，创造
一盒名为x。

256
00:12:24,210 --> 00:12:29,350
在这种情况下，我们给
它不同的类型。

257
00:12:29,350 --> 00:12:30,240
所以它不会是一个int。

258
00:12:30,240 --> 00:12:35,460
这将是一个int明星，
所以此框将是一点点

259
00:12:35,460 --> 00:12:38,650
比如果它是不同的只是
是一个字符，例如。

260
00:12:38,650 --> 00:12:41,550
>> 因为字符，召回，是
在内存中只有一个字节。

261
00:12:41,550 --> 00:12:43,050
指针是四个字节。

262
00:12:43,050 --> 00:12:45,640
所以这个盒子看起来有点
不同的，如果我们写整型明星作为

263
00:12:45,640 --> 00:12:46,490
反对为char。

264
00:12:46,490 --> 00:12:49,110
但除此之外，我们创建了一个
框，它是在一个特定的地址。

265
00:12:49,110 --> 00:12:51,830
这是所有第一线一样。

266
00:12:51,830 --> 00:12:57,630
>> 代码的第二行，诠释x等于
50，再创建另一个盒子x在

267
00:12:57,630 --> 00:12:58,410
不同的位置。

268
00:12:58,410 --> 00:13:00,340
我们会给错位111。

269
00:13:00,340 --> 00:13:02,560
这实际上是初始化
除了指针

270
00:13:02,560 --> 00:13:03,490
创建框。

271
00:13:03,490 --> 00:13:07,380
我们把50这里面框。

272
00:13:07,380 --> 00:13:10,650
>> 的代码，指针的第三行
等于地址X。

273
00:13:10,650 --> 00:13:14,600
该地址操作装置
一个非常具体的事情。

274
00:13:14,600 --> 00:13:19,650
每当我们把符号在前面
一个变量名的，我们在说给

275
00:13:19,650 --> 00:13:22,810
该变量的我的地址。

276
00:13:22,810 --> 00:13:27,830
所以，当我写符号X，这是
说给我x的地址，

277
00:13:27,830 --> 00:13:30,190
这种情况下，111。

278
00:13:30,190 --> 00:13:30,610
>> 是吗？

279
00:13:30,610 --> 00:13:33,750
>> 学生：这是可以接受的，如果我们
碰巧知道这个地址

280
00:13:33,750 --> 00:13:37,860
特定的变量只
说指针等于0x111？

281
00:13:37,860 --> 00:13:41,130
>> JASON HIRSCHHORN：所以，如果你知道，
这是在111，你可以写

282
00:13:41,130 --> 00:13:46,825
指针x等于这个十六进制
号，但我看不到一个办法，你

283
00:13:46,825 --> 00:13:50,880
会知道它是什么，所以这
为什么我们使用这个语法。

284
00:13:50,880 --> 00:13:54,950
但同样，这符号X，符号
是说给我的这个地址

285
00:13:54,950 --> 00:13:59,960
变量，就像任何相等
它的标志，这是该存储

286
00:13:59,960 --> 00:14:01,210
值里面的指针。

287
00:14:01,210 --> 00:14:04,370

288
00:14:04,370 --> 00:14:07,760
>> 所以每当你看到的符号，
认为这是给我的地址

289
00:14:07,760 --> 00:14:08,810
这件事情。

290
00:14:08,810 --> 00:14:12,240
符号x为给我
这种X框的地址。

291
00:14:12,240 --> 00:14:16,990
同样，如果我们这样做符号指针，
那么我得到什么？

292
00:14:16,990 --> 00:14:18,480
>> 学生：指针的地址。

293
00:14:18,480 --> 00:14:19,780
>> JASON HIRSCHHORN：地址
的指针。

294
00:14:19,780 --> 00:14:20,410
具体是什么？

295
00:14:20,410 --> 00:14:21,790
>> 学生：0x999。

296
00:14:21,790 --> 00:14:23,870
>> JASON HIRSCHHORN：999。

297
00:14:23,870 --> 00:14:26,920
符号指针将给予
我在这种情况下999。

298
00:14:26,920 --> 00:14:28,730
＆符号在任何前
变量给你

299
00:14:28,730 --> 00:14:30,630
该变量的地址。

300
00:14:30,630 --> 00:14:33,270
当然，我并不真的在乎
该指针的地址。

301
00:14:33,270 --> 00:14:37,900
我关心更多关于
这个变量的地址。

302
00:14:37,900 --> 00:14:41,980
>> 最后，我们将在最后一个符号
看到实际上是相同的符号，

303
00:14:41,980 --> 00:14:43,170
该星号。

304
00:14:43,170 --> 00:14:45,910
但在这最后一行，这是
用有点不同。

305
00:14:45,910 --> 00:14:49,070
请注意，在这最后一行
它旁边的变量。

306
00:14:49,070 --> 00:14:52,600
正如前面是旁边的类型，它
在这种类型的一部分​​，我们正在创建

307
00:14:52,600 --> 00:14:56,840
这种类型的整型指针，现在
明星意味着什么

308
00:14:56,840 --> 00:14:57,510
有一点点不同。

309
00:14:57,510 --> 00:15:00,700
这意味着去治疗价值 - 

310
00:15:00,700 --> 00:15:01,610
整型指针 - 

311
00:15:01,610 --> 00:15:06,740
对待值这个变量一样
一个地址，去那个地址，

312
00:15:06,740 --> 00:15:08,820
给我的价值。

313
00:15:08,820 --> 00:15:15,430
>> 因此，星号表示，再次治疗
值和指针作为地址，去

314
00:15:15,430 --> 00:15:18,640
该地址，并返回该值。

315
00:15:18,640 --> 00:15:22,060
在这种情况下，该值为50，
所以这行会的printf 50。

316
00:15:22,060 --> 00:15:22,430
是吗？

317
00:15:22,430 --> 00:15:25,770
>> 学生：所以，如果我们想这样做的
这在过去是没有声明为

318
00:15:25,770 --> 00:15:29,190
指针，如x上，并且该值是50，
它会尝试去解决50，

319
00:15:29,190 --> 00:15:30,535
或将它只是给我们一个错误？

320
00:15:30,535 --> 00:15:36,200
>> JASON HIRSCHHORN：如果我们做明星的x，
并试图对printf的是，什么样的

321
00:15:36,200 --> 00:15:39,780
编译器会做，或什么程序
它运行的时候会做，这是

322
00:15:39,780 --> 00:15:46,340
将治疗50就像一个地址，然后转到
解决你的程序号50。

323
00:15:46,340 --> 00:15:51,980
一般来说，当你要这些
随机地址，你不会

324
00:15:51,980 --> 00:15:54,310
去到一个地址的东西
是不错那里。

325
00:15:54,310 --> 00:15:57,160
你会去一个非常糟糕
解决你不应该去

326
00:15:57,160 --> 00:16:00,510
对，和你的程序
将要崩溃。

327
00:16:00,510 --> 00:16:01,560
>> 所以，是的，你说得对。

328
00:16:01,560 --> 00:16:04,430
它会做同样的事情，但
当我们试图去地址，我们

329
00:16:04,430 --> 00:16:07,290
没有要求，否则我们不会有
宣派，或者只是随机的

330
00:16:07,290 --> 00:16:10,360
地址，我们几乎总是在
麻烦，我们的程序崩溃。

331
00:16:10,360 --> 00:16:14,020

332
00:16:14,020 --> 00:16:15,040
>> 这是否回答你的问题？

333
00:16:15,040 --> 00:16:16,864
>> 学生：是啊，我猜
我有一个又一个。

334
00:16:16,864 --> 00:16:20,460
所以，如果你冷只是做到这一点，它会
去那个地址，有什么

335
00:16:20,460 --> 00:16:23,390
点声明一个指针作为的
指针，如果我们可以只说一个指针

336
00:16:23,390 --> 00:16:24,610
等于符号的东西？

337
00:16:24,610 --> 00:16:27,533
然后它会像一个有意义的
地址，我们可以去那里，对不对？

338
00:16:27,533 --> 00:16:29,130
>> JASON HIRSCHHORN：你能
重复的问题？

339
00:16:29,130 --> 00:16:32,210
>> 学生：我们为什么要申报
指针作为一个int明星是否会

340
00:16:32,210 --> 00:16:35,600
工作只是把它声明为一个像
定期诠释，因为它仍然会

341
00:16:35,600 --> 00:16:39,336
有一件事，可能是
然后间接引用，对不对？

342
00:16:39,336 --> 00:16:42,490
>> JASON HIRSCHHORN：那么，为什么我们
它声明为一个int，而明星

343
00:16:42,490 --> 00:16:46,700
而不仅仅是一个整数，
保存这个数字的呢？

344
00:16:46,700 --> 00:16:47,936
>> 学生：是啊。

345
00:16:47,936 --> 00:16:50,100
>> JASON HIRSCHHORN：因为
当我们使用的东西 - 

346
00:16:50,100 --> 00:16:50,960
伟大的问题 - 

347
00:16:50,960 --> 00:16:53,720
当我们使用的东西，每当我们使用
一个指针，我们要

348
00:16:53,720 --> 00:16:56,680
对待像指针，其他
事情是怎么回事，我不是要去

349
00:16:56,680 --> 00:17:00,080
现在，它有助于进入
如果程序知道

350
00:17:00,080 --> 00:17:01,270
这个东西是一个指针。

351
00:17:01,270 --> 00:17:04,630
它将不同的方式对待它以某种
其他的方式，是无关紧要的对我们来说，

352
00:17:04,630 --> 00:17:08,050
但我们要使用它就像一个
指针，我们应该说，我们要

353
00:17:08,050 --> 00:17:09,300
使用这个作为一个指针。

354
00:17:09,300 --> 00:17:12,450

355
00:17:12,450 --> 00:17:17,584
>> 以便基本上
指针是如何工作的。

356
00:17:17,584 --> 00:17:20,849
它并不比更复杂
这一点，但遗憾的是，就变成了

357
00:17:20,849 --> 00:17:23,710
很多更复杂时，
我们把它付诸实践。

358
00:17:23,710 --> 00:17:28,190
>> 接下来，我们要做的事情
东西蛮大的。

359
00:17:28,190 --> 00:17:31,703
而不是仅仅是用几行
网上的代码，我忍了4，5，

360
00:17:31,703 --> 00:17:34,290
6，7，8 9，10行代码。

361
00:17:34,290 --> 00:17:38,430
和而不是编码这些了你
计算机或运行此程序

362
00:17:38,430 --> 00:17:41,410
您的电脑上，我要你拿出
纸和一支铅笔或一个表

363
00:17:41,410 --> 00:17:45,800
笔，并找出各是什么
这些代码的行做。

364
00:17:45,800 --> 00:17:49,460
先从左边的列，从工作
从上到下，它初始化

365
00:17:49,460 --> 00:17:55,040
有很多这些变量，并
然后再通过每一行代码中

366
00:17:55,040 --> 00:17:57,880
右列和图
出会发生什么。

367
00:17:57,880 --> 00:18:01,890
我给大家3分钟
启动这个你自己，然后我们将

368
00:18:01,890 --> 00:18:03,230
过这作为一个群体。

369
00:18:03,230 --> 00:20:10,620

370
00:20:10,620 --> 00:20:12,100
>> 让我们开始去
在此作为一个群体。

371
00:20:12,100 --> 00:20:13,700
这是确定的，如果你还没有完成。

372
00:20:13,700 --> 00:20:18,570
我要开始用左手
柱的侧面，然后我要去

373
00:20:18,570 --> 00:20:24,520
请你们在这里，勇敢
你在这里你们当中了，执行

374
00:20:24,520 --> 00:20:26,730
一行上的右手侧代码
列，然后我们将继续努力

375
00:20:26,730 --> 00:20:27,770
我们的方式通过。

376
00:20:27,770 --> 00:20:32,900
>> 因此，首先，代码，int值，第一行
x等于2逗号y等于8逗号Ž

377
00:20:32,900 --> 00:20:36,500
等于12，创建三个变量。

378
00:20:36,500 --> 00:20:38,120
我做这一切在同一行。

379
00:20:38,120 --> 00:20:41,040
这是一个方便的语法来创建
的多的东西

380
00:20:41,040 --> 00:20:44,030
同类型在同一行。

381
00:20:44,030 --> 00:20:46,000
>> 因此，我们有三个箱子。

382
00:20:46,000 --> 00:20:48,834

383
00:20:48,834 --> 00:20:52,218
大家可以看到这三个，
或者是太低了？

384
00:20:52,218 --> 00:20:53,152
确定。

385
00:20:53,152 --> 00:20:57,180
>> 我们有X，Y，Z。

386
00:20:57,180 --> 00:21:00,550
及x，我们得到2。

387
00:21:00,550 --> 00:21:03,035
在Y，我们得到8。

388
00:21:03,035 --> 00:21:07,390
而在Z，我们得到12。

389
00:21:07,390 --> 00:21:09,270
漂亮的标准为止。

390
00:21:09,270 --> 00:21:12,430
>> 下一步，我们要创建另一个
箱，另一个变量。

391
00:21:12,430 --> 00:21:13,760
这是一个int指针。

392
00:21:13,760 --> 00:21:15,560
这就是所谓的指针按x。

393
00:21:15,560 --> 00:21:16,920
我们将绘制在这里。

394
00:21:16,920 --> 00:21:22,640

395
00:21:22,640 --> 00:21:26,998
>> 而什么是我们存储
里面的指针X'

396
00:21:26,998 --> 00:21:29,290
>> 学生：x的地址。

397
00:21:29,290 --> 00:21:31,100
>> JASON HIRSCHHORN：x的地址。

398
00:21:31,100 --> 00:21:33,750
在这种情况下，不知道
x的地址。

399
00:21:33,750 --> 00:21:35,970
它可以是任何东西，但我要去
做的东西了，现在做它

400
00:21:35,970 --> 00:21:37,310
我们更容易。

401
00:21:37,310 --> 00:21:40,360
我们将放置X在111。

402
00:21:40,360 --> 00:21:46,660
所以，这得到0x111，我们会给
它一个很好的箭头来表示

403
00:21:46,660 --> 00:21:48,520
它的指向为x。

404
00:21:48,520 --> 00:21:57,510
>> 同样，我有指针
y和指针的z。

405
00:21:57,510 --> 00:21:58,580
他们得到的值。

406
00:21:58,580 --> 00:22:18,672
我们会给这个0x222，0x333。

407
00:22:18,672 --> 00:22:21,940
>> 这是我们在初始设置
列的左侧。

408
00:22:21,940 --> 00:22:25,510
我们创建了三个整数，
我们创建了三个三分球。

409
00:22:25,510 --> 00:22:28,290
里面的每个指针，我们保存地址
三个初始之一

410
00:22:28,290 --> 00:22:30,460
我们创建的变量。

411
00:22:30,460 --> 00:22:35,710
>> 现在，上的右手侧
专栏中，我们使用的是星号

412
00:22:35,710 --> 00:22:41,390
符号中的一些不同的方式
所有这一切都没有用它来

413
00:22:41,390 --> 00:22:43,480
提领东西或去
到一个特定的地址，并

414
00:22:43,480 --> 00:22:45,720
返回值存在。

415
00:22:45,720 --> 00:22:48,680
>> 有人能告诉我是什么
代码的第一行呢？

416
00:22:48,680 --> 00:22:51,360

417
00:22:51,360 --> 00:22:54,360
有人举手。
谁一直没有发言。

418
00:22:54,360 --> 00:22:54,840
你呢？

419
00:22:54,840 --> 00:22:56,792
>> 学生：设置Z到16。

420
00:22:56,792 --> 00:23:00,340
>> JASON HIRSCHHORN：它的设置Z到16。

421
00:23:00,340 --> 00:23:02,120
所以z等于x次年。

422
00:23:02,120 --> 00:23:04,630
在这种情况下，它只是乘法
我们正在做的。

423
00:23:04,630 --> 00:23:08,640
所以z等于x次Y，
2次8是16。

424
00:23:08,640 --> 00:23:09,080
完美的。

425
00:23:09,080 --> 00:23:11,330
因此，我们将更新此。

426
00:23:11,330 --> 00:23:14,010
Ž等于16。

427
00:23:14,010 --> 00:23:18,270
>> 代码X空间是第二行
星级等于空间年。

428
00:23:18,270 --> 00:23:21,900
这是什么行代码呢？

429
00:23:21,900 --> 00:23:22,830
杰夫。

430
00:23:22,830 --> 00:23:24,470
>> 学生：x等于x次Ÿ？

431
00:23:24,470 --> 00:23:25,630
>> JASON HIRSCHHORN：完全正确。

432
00:23:25,630 --> 00:23:28,870
这是速记符号
为x等于x次年。

433
00:23:28,870 --> 00:23:32,030
你可能已经看到的东西
如x加等于y？

434
00:23:32,030 --> 00:23:34,380
这是x等于X加Y。

435
00:23:34,380 --> 00:23:39,190
在这种情况下，我们正在做的东西
有点不同，x等于x次年。

436
00:23:39,190 --> 00:23:40,400
>> 那么什么是我需要在这里更新？

437
00:23:40,400 --> 00:23:41,915
>> 学生：x是16。

438
00:23:41,915 --> 00:23:43,165
>> JASON HIRSCHHORN：x是16。

439
00:23:43,165 --> 00:23:50,080

440
00:23:50,080 --> 00:23:52,840
>> 变化的绿色是什么
我们迄今完成的。

441
00:23:52,840 --> 00:23:56,900
接下来，我们得：y等于星级指针按x。

442
00:23:56,900 --> 00:24:00,300
有人可以走我通过什么
这行代码呢？

443
00:24:00,300 --> 00:24:01,400
什么是这行代码呢？

444
00:24:01,400 --> 00:24:02,880
从一开始走我走过。

445
00:24:02,880 --> 00:24:07,060
>> 学生：它需要什么指针x是
指向，那就是作为价值

446
00:24:07,060 --> 00:24:11,064
由尖，和
它存储在年。

447
00:24:11,064 --> 00:24:11,950
>> JASON HIRSCHHORN：优秀。

448
00:24:11,950 --> 00:24:13,310
我要重复一遍。

449
00:24:13,310 --> 00:24:18,180
你做了出色的工作，但这样我们就可以
强调它，星号表示治疗

450
00:24:18,180 --> 00:24:20,550
事情在变像
一个地址，然后转到它。

451
00:24:20,550 --> 00:24:25,590
所以，对待事情的指针x像
地址，去它，把该值

452
00:24:25,590 --> 00:24:28,750
16，然后我们只是节省
它在变量y。

453
00:24:28,750 --> 00:24:34,393
所以，现在Y获取覆盖，
并且它现在是16。

454
00:24:34,393 --> 00:24:37,260

455
00:24:37,260 --> 00:24:42,810
>> 码，星形指针的下一行
强调x等于x次年。

456
00:24:42,810 --> 00:24:44,400
这是什么行代码呢？

457
00:24:44,400 --> 00:24:47,120

458
00:24:47,120 --> 00:24:50,900
同样，如果你是一个有点失去了这里，
从右到左进行评估。

459
00:24:50,900 --> 00:24:53,480
那么盟，什么是正确的
那做右手边？

460
00:24:53,480 --> 00:24:55,820
>> 学生：右手边刚
乘无论是在

461
00:24:55,820 --> 00:24:56,990
框是x和y。

462
00:24:56,990 --> 00:24:58,880
>> JASON HIRSCHHORN：这就是16
16，有什么是平等？

463
00:24:58,880 --> 00:24:59,350
>> 学生：256。

464
00:24:59,350 --> 00:25:00,470
>> JASON HIRSCHHORN：256。

465
00:25:00,470 --> 00:25:01,865
哪里是我们节省了256？

466
00:25:01,865 --> 00:25:05,410
>> 学生：你将其保存在什么
指针x被指向，

467
00:25:05,410 --> 00:25:06,820
这是X框。

468
00:25:06,820 --> 00:25:08,802
所以，现在，x变成256。

469
00:25:08,802 --> 00:25:11,480
>> JASON HIRSCHHORN：所以的明星，
再次，是指去。

470
00:25:11,480 --> 00:25:13,320
我们去什么指针
x被指向。

471
00:25:13,320 --> 00:25:27,440
它指向X，并有
我们节省了价值256。

472
00:25:27,440 --> 00:25:29,750
>> 关于具体的一个什么问题吗？

473
00:25:29,750 --> 00:25:33,860
我们还没有看到使用上的明星
左手侧，然而，

474
00:25:33,860 --> 00:25:35,110
赋值运算符。

475
00:25:35,110 --> 00:25:42,690

476
00:25:42,690 --> 00:25:44,410
>> 所以这是代码的第四行。

477
00:25:44,410 --> 00:25:47,970
代码第五行，有人可以
谁一直没有发言，给我的

478
00:25:47,970 --> 00:25:49,710
第五行的代码，或步行
通过它和我在一起？

479
00:25:49,710 --> 00:25:55,120

480
00:25:55,120 --> 00:25:55,950
安妮，它是什么呢？

481
00:25:55,950 --> 00:25:59,535
>> 学生：改变指针的值
X要指针y的值。

482
00:25:59,535 --> 00:26:01,980
>> JASON HIRSCHHORN：这是
完全正确。

483
00:26:01,980 --> 00:26:06,010
指针y的值是这个地址
在这里，我们要存储在

484
00:26:06,010 --> 00:26:07,670
变量指针按x。

485
00:26:07,670 --> 00:26:12,740
因此，这成为222。

486
00:26:12,740 --> 00:26:16,010
我要去移动的箭头，
同样，以表示它现在

487
00:26:16,010 --> 00:26:17,260
具有不同的地址。

488
00:26:17,260 --> 00:26:24,560

489
00:26:24,560 --> 00:26:27,970
>> 所以，现在指针下划线x
和指针下划线ÿ

490
00:26:27,970 --> 00:26:29,250
具有相同的值。

491
00:26:29,250 --> 00:26:30,390
这就是这一行呢。

492
00:26:30,390 --> 00:26:34,170
所以基本上，他们是
都指向为y。

493
00:26:34,170 --> 00:26:37,180
如果我们只是有我们的三分球，而我们
真的不知道该变量，我们

494
00:26:37,180 --> 00:26:38,210
将失去按x。

495
00:26:38,210 --> 00:26:42,230
但幸运的是，有x保存
在这个函数中，所以我们还是

496
00:26:42,230 --> 00:26:43,350
知道其中x是。

497
00:26:43,350 --> 00:26:48,660
但我们会看到，问题来了
以后，如果我们失去了一个指针

498
00:26:48,660 --> 00:26:51,790
什么东西，我们可能实际上并不知道
它在哪里，或者能够恢复它。

499
00:26:51,790 --> 00:26:53,540
但是，这是未来。

500
00:26:53,540 --> 00:26:55,310
所以，现在，这是
完全正确，安妮。

501
00:26:55,310 --> 00:26:57,350
>> 最后，代码的最后一行。

502
00:26:57,350 --> 00:27:00,876
有人可以给我什么样的
代码的最后一行呢？

503
00:27:00,876 --> 00:27:01,742
是吗？

504
00:27:01,742 --> 00:27:09,245
>> 学生：它乘以什么是
指针Y，那么16倍16  - 

505
00:27:09,245 --> 00:27:10,810
>> JASON HIRSCHHORN：16
没有指针年。

506
00:27:10,810 --> 00:27:14,530
>> 学生：嗯，它关系到该地址，
发现它，然后乘以

507
00:27:14,530 --> 00:27:17,370
通过同样的事情 - 它的
同样的事情与指标Z，乘

508
00:27:17,370 --> 00:27:19,280
值，并将其存储在X。

509
00:27:19,280 --> 00:27:19,960
>> JASON HIRSCHHORN：完全正确。

510
00:27:19,960 --> 00:27:22,540
那么我需要更新？

511
00:27:22,540 --> 00:27:23,463
我应该x为？

512
00:27:23,463 --> 00:27:25,520
>> 学生：左上，256。

513
00:27:25,520 --> 00:27:28,620
>> JASON HIRSCHHORN：什么
我将其更改为？

514
00:27:28,620 --> 00:27:31,160
很抱歉，我们就回去了。

515
00:27:31,160 --> 00:27:33,605
>> 学生：它应该仍然是相同的。

516
00:27:33,605 --> 00:27:36,020
>> JASON HIRSCHHORN：是的，它实际上
还是等于256。

517
00:27:36,020 --> 00:27:37,630
但是，这是完全正确的。

518
00:27:37,630 --> 00:27:38,850
让我们打破这种下降。

519
00:27:38,850 --> 00:27:43,470
我们将看到在这里，这个东西在
括号，明星指针Y，即

520
00:27:43,470 --> 00:27:46,850
把什么在指针y为
一个地址，去那

521
00:27:46,850 --> 00:27:48,670
地址，取16。

522
00:27:48,670 --> 00:27:51,570
所以，现在我们有一个16，我们很
相乘，通过对

523
00:27:51,570 --> 00:27:52,710
在Z同样的事情。

524
00:27:52,710 --> 00:27:54,895
去那个地址，服用16。

525
00:27:54,895 --> 00:27:59,820
16倍，16是256，我们正在存储
这里面的x。 X里面已经发生了

526
00:27:59,820 --> 00:28:02,000
等于256，所以我们不
要作出改变。

527
00:28:02,000 --> 00:28:04,590

528
00:28:04,590 --> 00:28:08,550
>> 你没有这个文件，现在，
但在此源代码

529
00:28:08,550 --> 00:28:12,880
部分，这将在网上进行公布
cs50.net/sections，我写的所有

530
00:28:12,880 --> 00:28:14,780
的这件事，正是我们所做的。

531
00:28:14,780 --> 00:28:17,780
我其实包含了一些其他的
信息在这里，我们是

532
00:28:17,780 --> 00:28:19,610
要经过在一秒钟。

533
00:28:19,610 --> 00:28:24,040
>> 我们做这些操作，你可以看到
在这里，然后打印出

534
00:28:24,040 --> 00:28:27,860
得到的值的特定变量的
已被改变​​。

535
00:28:27,860 --> 00:28:28,880
此代码是已经被写入。

536
00:28:28,880 --> 00:28:30,130
我要运行此代码。

537
00:28:30,130 --> 00:28:36,110

538
00:28:36,110 --> 00:28:39,170
>> 现在让我们遍历输出。

539
00:28:39,170 --> 00:28:40,860
让我们从头开始。

540
00:28:40,860 --> 00:28:43,200
x值等于为2。

541
00:28:43,200 --> 00:28:44,120
这应该是有意义的。

542
00:28:44,120 --> 00:28:46,600
这正是我们最初
初始化它。

543
00:28:46,600 --> 00:28:51,650
>> 的x地址是这个疯狂的事情。

544
00:28:51,650 --> 00:28:55,510
再次，我们却看到，即使它
看起来有点疯狂的在第一次

545
00:28:55,510 --> 00:28:57,980
检查中，我们看到，
0X就在那里。

546
00:28:57,980 --> 00:29:00,040
这是一个十六进制数。

547
00:29:00,040 --> 00:29:03,600
>> 然后我们看到所有的
这个疯狂的东西。

548
00:29:03,600 --> 00:29:05,860
有一个B和一个f，和
还有一个C在那里。

549
00:29:05,860 --> 00:29:09,460
这些都不是正常的零通过
九位数字，但因为十六进制

550
00:29:09,460 --> 00:29:14,310
是基地16，你的实际需要
一对夫妇的其他符号

551
00:29:14,310 --> 00:29:16,940
代表每个数字。

552
00:29:16,940 --> 00:29:19,860
所以，再一次，我们不打算谈
十六进制太多，但知道

553
00:29:19,860 --> 00:29:23,990
当你写的十六进制
数字，你会从零看到什么

554
00:29:23,990 --> 00:29:28,830
到9加东西
从a到f。

555
00:29:28,830 --> 00:29:33,140
因此，即使他们不是所有零
通过9号，这是一个

556
00:29:33,140 --> 00:29:34,760
号，这是一个地址。

557
00:29:34,760 --> 00:29:38,540
并且它可以被表示为
基地10，如果我们想要。

558
00:29:38,540 --> 00:29:46,500
>> 指针的x这里的值是
还一个十六进制数，并且什么是

559
00:29:46,500 --> 00:29:47,520
它同样的？

560
00:29:47,520 --> 00:29:49,510
什么是这个数目一样？

561
00:29:49,510 --> 00:29:53,910

562
00:29:53,910 --> 00:29:55,290
>> 地址X的，对不对？

563
00:29:55,290 --> 00:29:59,440
该生产线正上方，这两个
地址是相同的，这就是

564
00:29:59,440 --> 00:30:00,610
我们所期望的。

565
00:30:00,610 --> 00:30:06,830
x的地址是
指针的x值。

566
00:30:06,830 --> 00:30:10,020
>> 接下来，我们的地址
指针的x，便是

567
00:30:10,020 --> 00:30:11,680
再次，一些随机数。

568
00:30:11,680 --> 00:30:15,390
如果我们要检查它，我们注意到
它分享了很多

569
00:30:15,390 --> 00:30:16,410
相同的数字作为其他的。

570
00:30:16,410 --> 00:30:20,200
这是不同的，但它的股票
很多相同的数字。

571
00:30:20,200 --> 00:30:22,700
记得谈论缓冲
溢出错误？

572
00:30:22,700 --> 00:30:24,900
当你可以在写的东西都是
靠近你的内存，如果你去

573
00:30:24,900 --> 00:30:26,340
超出阵列的界限。

574
00:30:26,340 --> 00:30:28,920
同样，我们不打算谈
那现在，但对于那些你

575
00:30:28,920 --> 00:30:31,510
好奇，这些东西实际上是
非常接近彼此。

576
00:30:31,510 --> 00:30:34,400
这些箱子是相当接近
彼此在存储器中。

577
00:30:34,400 --> 00:30:38,660
>> 最后，指针x指向的
值，当然，它是2。

578
00:30:38,660 --> 00:30:39,920
我这样做明星。

579
00:30:39,920 --> 00:30:43,310
我们遵循的指针地址
x起初，它

580
00:30:43,310 --> 00:30:45,340
返回x的值。

581
00:30:45,340 --> 00:30:47,870
>> 最后，我们清楚地看到
我们只是做了。

582
00:30:47,870 --> 00:30:52,120
首先z为16，则x
是16，则y为16。

583
00:30:52,120 --> 00:30:55,000
x最终成为256就在这里。

584
00:30:55,000 --> 00:30:58,090
又一次，x没有改变
通过代码最后一行。

585
00:30:58,090 --> 00:31:00,950
它仍然是256。

586
00:31:00,950 --> 00:31:03,380
>> 如果你想在自己重复这
再次，或者通过它，或

587
00:31:03,380 --> 00:31:05,690
改变一些值了，我已经
已经写了这个代码。

588
00:31:05,690 --> 00:31:11,490
您可以进行更改代码
而实际上看到这些变化如何

589
00:31:11,490 --> 00:31:14,540
在现实生活中发挥出来。

590
00:31:14,540 --> 00:31:16,855
>> 在我们继续之前的指针，不
任何人有任何问题吗？

591
00:31:16,855 --> 00:31:20,924

592
00:31:20,924 --> 00:31:21,390
>> 确定。

593
00:31:21,390 --> 00:31:26,620
每个人都可以拿一只手，和
把它在空气中，和 - 

594
00:31:26,620 --> 00:31:28,090
闭上你的眼睛 - 

595
00:31:28,090 --> 00:31:32,700
把你的右手在空中为
拳头，并给我一个竖起大拇指，大拇指

596
00:31:32,700 --> 00:31:36,590
向下，大拇指中间，怎么舒服
你是指针为止。

597
00:31:36,590 --> 00:31:37,840
闭上你的眼睛。

598
00:31:37,840 --> 00:31:40,770

599
00:31:40,770 --> 00:31:41,050
>> 确定。

600
00:31:41,050 --> 00:31:43,360
你可以把你的手了
然后打开你的眼睛。

601
00:31:43,360 --> 00:31:44,610
谢谢。

602
00:31:44,610 --> 00:31:47,110

603
00:31:47,110 --> 00:31:47,750
>> 我们要继续前进。

604
00:31:47,750 --> 00:31:49,395
我们将继续谈论
三分球，但我们要谈

605
00:31:49,395 --> 00:31:51,590
关于他们在一点点
的不同的上下文。

606
00:31:51,590 --> 00:31:54,160
我们要谈
数组和指针。

607
00:31:54,160 --> 00:31:56,660
上周，记住
我吹你的头脑？

608
00:31:56,660 --> 00:31:58,480
人的大脑，他们离开
他们在这里的地板上。

609
00:31:58,480 --> 00:32:01,335
我敢肯定吹
那个人的心灵。

610
00:32:01,335 --> 00:32:02,925
这是一个糟糕的玩笑。

611
00:32:02,925 --> 00:32:03,220
>> [笑]

612
00:32:03,220 --> 00:32:03,990
>> JASON HIRSCHHORN：我要去
工作这一点。

613
00:32:03,990 --> 00:32:06,535
但无论如何，我们发现字符串
出为数组。

614
00:32:06,535 --> 00:32:08,750
数组实际上是指针。

615
00:32:08,750 --> 00:32:09,920
>> 这是什么意思了吗？

616
00:32:09,920 --> 00:32:14,710
那么，如果我们创建一个6组
字符，这行代码

617
00:32:14,710 --> 00:32:16,890
确实就在这里 - 

618
00:32:16,890 --> 00:32:21,380
字符，数组，打开支架，六，密切
支架，分号 - 再次，创建一个

619
00:32:21,380 --> 00:32:23,490
数组的六个字符。

620
00:32:23,490 --> 00:32:24,070
填充它。

621
00:32:24,070 --> 00:32:25,570
>> 我有一张它的照片就在这里。

622
00:32:25,570 --> 00:32:28,900
这些盒子，我们看到，它填补
有一些字符和空

623
00:32:28,900 --> 00:32:29,900
终止底。

624
00:32:29,900 --> 00:32:32,630
和向下跌破，这就是我想要
你指挥你的注意力。

625
00:32:32,630 --> 00:32:34,230
的第一盒 - 

626
00:32:34,230 --> 00:32:35,200
我们已经这样做过。

627
00:32:35,200 --> 00:32:37,230
我们实际上已经做到了这一点
在每一个问题设定。

628
00:32:37,230 --> 00:32:42,610
可以参考我在第一个框
这个数组作为数组支架为零。

629
00:32:42,610 --> 00:32:44,970
我们已经做了一百万次。

630
00:32:44,970 --> 00:32:47,860
>> 我其实可以参考
同一个盒子的另一种方式。

631
00:32:47,860 --> 00:32:50,630
我可以把它称为星阵。

632
00:32:50,630 --> 00:32:55,620
因为数组，如果我们实际上是
打印出什么等于数组，数组是

633
00:32:55,620 --> 00:33:01,340
一个地址，它是一个地址
在此数组中的第一个框。

634
00:33:01,340 --> 00:33:06,590
让星算把什么
存储在数组作为地址，去

635
00:33:06,590 --> 00:33:09,180
该地址，并返回
该值在那里。

636
00:33:09,180 --> 00:33:15,870
星阵将返回f就​​像
阵列支架零返回f。

637
00:33:15,870 --> 00:33:19,850
>> 再次，到处都是我们一直在写
阵列支架零，星阵会

638
00:33:19,850 --> 00:33:21,440
也做了同样的事情。

639
00:33:21,440 --> 00:33:25,570
事实上，阵列支架是零
只是我们的糖衣

640
00:33:25,570 --> 00:33:26,270
究竟是什么发生的事情。

641
00:33:26,270 --> 00:33:29,420
这真是星阵是更
正确的做法，如果有一个正确的

642
00:33:29,420 --> 00:33:32,840
这样，想到什么
实际发生的事情。

643
00:33:32,840 --> 00:33:37,280
>> 所以，这一切都很好，但
这里的那里得到神奇。

644
00:33:37,280 --> 00:33:40,560
我们去的第二个字符
在这里，这个零。

645
00:33:40,560 --> 00:33:42,870
应该是一个O，但我们会
给它一个零。

646
00:33:42,870 --> 00:33:45,570
我们提到了前，
在一个数组第二个框中，为数组

647
00:33:45,570 --> 00:33:49,000
支架一每当我们已经反复
通过阵列。

648
00:33:49,000 --> 00:33:51,860
>> 还有另一种方法来指
它，这就是下面的人。

649
00:33:51,860 --> 00:33:57,750
那颗星，开括号，数组
加1，关闭括号。

650
00:33:57,750 --> 00:34:01,400
所以，因为数组的布局 - 这些
箱子都紧挨着对方

651
00:34:01,400 --> 00:34:03,350
在内存中 - 

652
00:34:03,350 --> 00:34:06,110
星阵去的第一个。

653
00:34:06,110 --> 00:34:10,940
所以，如果我们要采取阵列
地址，把它加1，然后去

654
00:34:10,940 --> 00:34:13,070
新地址时，这是怎么回事
要对旁边的事

655
00:34:13,070 --> 00:34:14,150
原来的地址。

656
00:34:14,150 --> 00:34:14,896
>> 是吗？

657
00:34:14,896 --> 00:34:18,810
>> 学生：所以，如果是数组，而不是，
为字符，这将是整数，那么

658
00:34:18,810 --> 00:34:21,659
你必须增加
4每次？

659
00:34:21,659 --> 00:34:22,980
>> JASON HIRSCHHORN：这是
一个很大的问题。

660
00:34:22,980 --> 00:34:24,850
我想画的东西，然后再我
要回答你的问题。

661
00:34:24,850 --> 00:34:47,030

662
00:34:47,030 --> 00:34:49,300
>> 为了绘制这个在屏幕上真的
越来越快速的前

663
00:34:49,300 --> 00:34:51,219
的问题，我们有我们的阵列 - 

664
00:34:51,219 --> 00:34:57,690

665
00:34:57,690 --> 00:35:00,530
而如此下去，但我只打算
专注于第一对夫妇的。

666
00:35:00,530 --> 00:35:04,800

667
00:35:04,800 --> 00:35:08,020
在内存方面，还有一个盒子
我们创建的时候，我们

668
00:35:08,020 --> 00:35:10,130
初始化此数组。

669
00:35:10,130 --> 00:35:12,795
这是数组变量，
并且它是一个地址。

670
00:35:12,795 --> 00:35:17,420
它是，实际上的地址
第一件事情，第一个框。

671
00:35:17,420 --> 00:35:18,740
所以这个箱子是什么地方。

672
00:35:18,740 --> 00:35:21,760
这六个箱子在别的地方。

673
00:35:21,760 --> 00:35:24,810
>> 当我们这样做阵列支架为零，我们
要到达这里的第一件事。

674
00:35:24,810 --> 00:35:28,370
当我们做星阵，我们将
得到确切的同样的事情，该值

675
00:35:28,370 --> 00:35:30,320
该数组是指向。

676
00:35:30,320 --> 00:35:35,360
>> 当我们这样做阵列支架1，我们要
获得第二个盒子，而且还

677
00:35:35,360 --> 00:35:39,630
因为指针以外的
括号，首先我们要添加

678
00:35:39,630 --> 00:35:43,520
1到这个地址，然后我们要去
遵循这一点，给我们

679
00:35:43,520 --> 00:35:45,220
第二个盒子。

680
00:35:45,220 --> 00:35:47,800
等等，等等。

681
00:35:47,800 --> 00:35:51,860
>> 阵列加2是要增加2到这个
在这里讨论，因为再次，地址

682
00:35:51,860 --> 00:35:54,640
只是数字表示
为十六进制，经常。

683
00:35:54,640 --> 00:36:00,070
所以加2到它，并按照该
第三个框，这恰好是，当你

684
00:36:00,070 --> 00:36:04,710
可以看到，两个空间离
从第一个框。

685
00:36:04,710 --> 00:36:07,470
>> 但愿，这使得它减少混乱
而不是更加混乱。

686
00:36:07,470 --> 00:36:08,540
但并使它更加混乱？

687
00:36:08,540 --> 00:36:10,030
再次，我会去你的
问题在一秒钟。

688
00:36:10,030 --> 00:36:12,250
并使它更困惑
任何人，或没有任何人有任何

689
00:36:12,250 --> 00:36:14,820
关于这个问题的想法
数组作为指针？

690
00:36:14,820 --> 00:36:20,080

691
00:36:20,080 --> 00:36:21,560
>> 太棒了。

692
00:36:21,560 --> 00:36:23,450
此外，它会很神奇
如果你有问题。

693
00:36:23,450 --> 00:36:27,780
但在继续讨论你的​​问题。

694
00:36:27,780 --> 00:36:30,910

695
00:36:30,910 --> 00:36:37,340
>> 现在的问题是在内存中的整数
占用四个字节，所以四盒。

696
00:36:37,340 --> 00:36:42,050
如果我们认为一个盒子为一个字节，
整数占用了四盒。

697
00:36:42,050 --> 00:36:44,560
>> 所以说这些都是整数了。

698
00:36:44,560 --> 00:36:50,680
这是一个int数组就在这里。

699
00:36:50,680 --> 00:36:52,570
我会弥补一些
随机地址。

700
00:36:52,570 --> 00:36:58,410
因此，如果这是一个int数组中，
第一种可能是10。

701
00:36:58,410 --> 00:37:03,210
下一个的四盒了，因为
整数是四盒大。

702
00:37:03,210 --> 00:37:07,690
还有的是10，11，12，13，所以
这个人会是一个14。

703
00:37:07,690 --> 00:37:08,870
这个人会是一个18。

704
00:37:08,870 --> 00:37:13,830
这一个将是22，依此类推。

705
00:37:13,830 --> 00:37:15,590
>> 如此反复，字符是一个字节。

706
00:37:15,590 --> 00:37:17,380
他们是紧挨着对方，
所以这个图上我们在谈论

707
00:37:17,380 --> 00:37:19,190
之前完美的作品。

708
00:37:19,190 --> 00:37:20,710
>> 但你刚才提出
整数的情况。

709
00:37:20,710 --> 00:37:23,440
好吧，如果我说1到这一点，
它会去到11。

710
00:37:23,440 --> 00:37:25,710
这将会是在这中间
INT，如果我跟着它真的

711
00:37:25,710 --> 00:37:26,710
特别是这样的。

712
00:37:26,710 --> 00:37:30,070
实际上，我是要去盒
由框在存储器中。

713
00:37:30,070 --> 00:37:36,750
>> 关于这种类型的很酷的事情
指针运算的程序

714
00:37:36,750 --> 00:37:38,840
足够聪明，知道你的意思。

715
00:37:38,840 --> 00:37:46,000
当你添加1到存储
这是指向一个地址

716
00:37:46,000 --> 00:37:49,470
整数，它实际上并不打算
添加一个块以上。

717
00:37:49,470 --> 00:37:51,150
这将超过新增四个街区。

718
00:37:51,150 --> 00:37:54,530
这将是规模数量
为你买的大小。

719
00:37:54,530 --> 00:37:57,780
>> 这可以追溯到柯蒂斯的问题，
为什么我们做的诠释，而明星

720
00:37:57,780 --> 00:37:58,595
不是char明星？

721
00:37:58,595 --> 00:38:01,050
是你的问题？

722
00:38:01,050 --> 00:38:02,220
有人问早些时候，对不对？

723
00:38:02,220 --> 00:38:06,200
为什么我们做整型明星而不是char
明星如果它要解决不

724
00:38:06,200 --> 00:38:06,960
不管是什么？

725
00:38:06,960 --> 00:38:09,790
这就是来帮助我们与此
类型的指针算术。

726
00:38:09,790 --> 00:38:12,660
如果我们的东西声明为一个char明星
但它确实经历

727
00:38:12,660 --> 00:38:16,890
整数，当我们增加了1，那只
移动一个方块的，而不是

728
00:38:16,890 --> 00:38:21,540
4，我们在逻辑上希望
它搬过来。

729
00:38:21,540 --> 00:38:26,180
>> 如此反复，在指针的算术运算，当
我们正在处理这些事情，比如

730
00:38:26,180 --> 00:38:29,890
地址，然后加上或减去
他们，然后按照他们

731
00:38:29,890 --> 00:38:35,410
弄清楚什么是内存怎么回事，
我们添加到他们的数量被缩小

732
00:38:35,410 --> 00:38:39,491
按事物的类型的大小
他们指着。

733
00:38:39,491 --> 00:38:41,100
>> 所以，如果他们指向一个整数 - 

734
00:38:41,100 --> 00:38:42,380
我知道我重复自己 - 

735
00:38:42,380 --> 00:38:45,030
但如果他们是一个整数，你
究竟要动议4

736
00:38:45,030 --> 00:38:46,760
箱子在每个时间。

737
00:38:46,760 --> 00:38:49,230
如果他们是一个字符，你
要移动一个框。

738
00:38:49,230 --> 00:38:52,720
如果他们是一个很长很长，这是八
字节，你要动

739
00:38:52,720 --> 00:38:53,880
8盒以上。

740
00:38:53,880 --> 00:38:55,940
的无论大小
数据类型，谁知道？

741
00:38:55,940 --> 00:38:57,690
其实并不重要
我们的目的。

742
00:38:57,690 --> 00:39:01,450
所有我们需要知道的是实际，
这道数学就在这里，只是增加1

743
00:39:01,450 --> 00:39:04,280
将得到我们的第二个对话框，不论
是在什么类型的东西

744
00:39:04,280 --> 00:39:05,530
那第二个盒子。

745
00:39:05,530 --> 00:39:09,860

746
00:39:09,860 --> 00:39:13,870
>> 我希望有一些类型的问题
在这里，因为这是一个很大的，我

747
00:39:13,870 --> 00:39:15,780
不能做一个完美的
工作在解释这一点。

748
00:39:15,780 --> 00:39:18,280

749
00:39:18,280 --> 00:39:19,260
真的吗？

750
00:39:19,260 --> 00:39:20,980
没有问题？

751
00:39:20,980 --> 00:39:23,660
对于观众在家里 - 
我们走吧。

752
00:39:23,660 --> 00:39:27,490
>> 学生：如果你是做一个数组
在一个函数，你想让它

753
00:39:27,490 --> 00:39:31,095
返回一个数组到别的东西，
你会怎么回呢？

754
00:39:31,095 --> 00:39:32,830
>> JASON HIRSCHHORN：非常好的问题。

755
00:39:32,830 --> 00:39:37,260
所以，如果你想使一个数组中的一个
函数，然后返回数组 - 

756
00:39:37,260 --> 00:39:41,300
所以我们说，我们会做一个数组
在一个称为主函数。

757
00:39:41,300 --> 00:39:45,750
主要调用这个函数，这
函数创建数组，然后

758
00:39:45,750 --> 00:39:47,100
它返回到主。

759
00:39:47,100 --> 00:39:49,370
>> 现在我们已经看到的东西
之前与此类似。

760
00:39:49,370 --> 00:39:52,810
在那里，我们看到类似的东西
其中主要创建数组，然后

761
00:39:52,810 --> 00:39:55,880
该函数处理呢？

762
00:39:55,880 --> 00:39:58,380
之前我们有什么写的
这样做了吗？

763
00:39:58,380 --> 00:39:59,626
>> 学生：排序？

764
00:39:59,626 --> 00:40:01,890
>> JASON HIRSCHHORN：排序
已经做到这一点。

765
00:40:01,890 --> 00:40:03,980
15场比赛也做了。

766
00:40:03,980 --> 00:40:09,680
在排序中，我们通过在阵列中，在
干草堆，然后我们整理了由

767
00:40:09,680 --> 00:40:13,100
破坏性更新不同
部分在该数组。

768
00:40:13,100 --> 00:40:16,380
因此，我们把我们的原始数组 - 
记住，这些参数的一个

769
00:40:16,380 --> 00:40:18,010
排序功能是数组 - 

770
00:40:18,010 --> 00:40:19,858
>> 学生：这不就是一个全局数组？

771
00:40:19,858 --> 00:40:20,420
>> JASON HIRSCHHORN：对。

772
00:40:20,420 --> 00:40:21,610
是啊，我们要回到那里。

773
00:40:21,610 --> 00:40:23,970
但就在它被创建 - 

774
00:40:23,970 --> 00:40:26,510
它是一个全球性的，或者是它
在函数产生的？

775
00:40:26,510 --> 00:40:28,115
让我们来看看。

776
00:40:28,115 --> 00:40:29,638
我们可以回答这个问题。

777
00:40:29,638 --> 00:40:49,700

778
00:40:49,700 --> 00:40:51,750
>> 它看起来像它不是一个全局数组。

779
00:40:51,750 --> 00:40:56,620
它创造就在这个行
一个整数数组，然后它

780
00:40:56,620 --> 00:40:59,820
传递给我们的排序功能。

781
00:40:59,820 --> 00:41:00,660
因此，这不是一个全局数组。

782
00:41:00,660 --> 00:41:02,810
它的主要创建，通过
我们的排序功能。

783
00:41:02,810 --> 00:41:05,690
我们的排序功能破坏性
更新它，并返回它。

784
00:41:05,690 --> 00:41:09,310
正如我们所看到了顶部，排序 - 

785
00:41:09,310 --> 00:41:10,410
哦，我的天啊，对不起。

786
00:41:10,410 --> 00:41:12,790
>> 学生：排序只是返回是否
或者不是找到了吗？

787
00:41:12,790 --> 00:41:13,350
>> JASON HIRSCHHORN：对。

788
00:41:13,350 --> 00:41:14,120
抱歉。

789
00:41:14,120 --> 00:41:16,320
实际上排序 - 让我们打开了。

790
00:41:16,320 --> 00:41:20,320

791
00:41:20,320 --> 00:41:21,310
排序是无效的。

792
00:41:21,310 --> 00:41:24,350
排序不返回任何东西，因为
排序破坏性更新数组，

793
00:41:24,350 --> 00:41:26,340
原始数组。

794
00:41:26,340 --> 00:41:30,520
>> 所以，这就是我们以前见过，但
你的问题是什么，如果排序

795
00:41:30,520 --> 00:41:32,155
实际上创建数组？

796
00:41:32,155 --> 00:41:36,870
>> 学生：请参阅返回更新
数组，或者类似的东西。

797
00:41:36,870 --> 00:41:39,030
>> JASON HIRSCHHORN：另一件事，
本来可以做的是所谓的主

798
00:41:39,030 --> 00:41:39,840
的功能。

799
00:41:39,840 --> 00:41:44,570
该函数的任务是创建一个
的东西，数组阵列

800
00:41:44,570 --> 00:41:49,390
整数，然后返回
数组它的创建主。

801
00:41:49,390 --> 00:41:55,080
>> 所以，当我们交谈时以前见过
有关栈，我们要

802
00:41:55,080 --> 00:42:00,390
今天晚些时候谈了一下，一旦
函数返回时，一切是

803
00:42:00,390 --> 00:42:03,490
在该函数中所有的，创造
它的局部变量，走开。

804
00:42:03,490 --> 00:42:04,910
我们以前见过的范围这一想法。

805
00:42:04,910 --> 00:42:07,750
这就是为什么我们已经创建了全球
变量有时，为了躲避这个

806
00:42:07,750 --> 00:42:11,790
事情要离开时的问题
其函数返回。

807
00:42:11,790 --> 00:42:15,970
>> 你会怎么做在这种情况下是
函数将创建数组不一样

808
00:42:15,970 --> 00:42:17,870
在堆栈中的局部变量。

809
00:42:17,870 --> 00:42:21,670
它会在不同的部分创建它
内存，可以让事情要

810
00:42:21,670 --> 00:42:26,050
即使功能已恢复保存
和功能框，则

811
00:42:26,050 --> 00:42:28,330
堆栈帧，已经离开了堆栈。

812
00:42:28,330 --> 00:42:29,770
>> 我将使用一些
术语在这里。

813
00:42:29,770 --> 00:42:31,620
你不会听到这个
直到明天，但该地区

814
00:42:31,620 --> 00:42:34,320
内存被称为堆，并
我不想去考虑这样做。

815
00:42:34,320 --> 00:42:39,140
但是，该函数可以做，再次
过于简单化潜在的，是创造

816
00:42:39,140 --> 00:42:43,390
在以不同的空间排列
内存，实际上在那里停留

817
00:42:43,390 --> 00:42:47,920
只要你想让它呆在那里，
它会传回主指针

818
00:42:47,920 --> 00:42:51,400
要保存在数组
内存的其他部分。

819
00:42:51,400 --> 00:42:54,960
因此，它使一些箱子别处
不被摧毁时，

820
00:42:54,960 --> 00:43:00,770
函数返回并传递回主
一个地址给该组的盒子。

821
00:43:00,770 --> 00:43:03,760
>> 这可能不是一个足以
回答你的问题，但

822
00:43:03,760 --> 00:43:05,520
将要探讨的明天更
当你们聊

823
00:43:05,520 --> 00:43:06,770
有关讲座堆。

824
00:43:06,770 --> 00:43:09,330

825
00:43:09,330 --> 00:43:11,590
>> 让我们继续前进 - 哦，我的天啊！

826
00:43:11,590 --> 00:43:12,850
这是一个海豚！

827
00:43:12,850 --> 00:43:14,650
多么可爱的是什么？

828
00:43:14,650 --> 00:43:15,660
上帝！

829
00:43:15,660 --> 00:43:18,170
他们是我最喜欢的动物，所以
他们确实是可爱的。

830
00:43:18,170 --> 00:43:19,720
我有三个海豚毛绒动物。

831
00:43:19,720 --> 00:43:21,930
但足够的了解我。

832
00:43:21,930 --> 00:43:23,910
>> 你都有你的电脑
在你面前打开。

833
00:43:23,910 --> 00:43:25,530
这里是你的编码任务。

834
00:43:25,530 --> 00:43:28,650
我们将开始与伪代码，
虽然，所以不要太激动。

835
00:43:28,650 --> 00:43:32,780
>> 你需要编写一个程序，需要
一个且只有一个命令行

836
00:43:32,780 --> 00:43:35,990
的说法，这就是数
海豚被训练。

837
00:43:35,990 --> 00:43:38,470
这个数字应大于0。

838
00:43:38,470 --> 00:43:41,160
>> 接下来你要允许
教练进入了年龄

839
00:43:41,160 --> 00:43:42,540
这些海豚。

840
00:43:42,540 --> 00:43:45,540
每个年龄段，再次，应
大于0。

841
00:43:45,540 --> 00:43:49,930
而所有这些年龄应该
被存储在数组中。

842
00:43:49,930 --> 00:43:53,740
>> 为了获得一个时代，但是，你需要
调用以下函数

843
00:43:53,740 --> 00:43:55,580
原型 - 

844
00:43:55,580 --> 00:44:01,750
整型明星，空间，getAge，括号，
无效，关闭括号，分号。

845
00:44:01,750 --> 00:44:06,380
>> 最后，我要你打印出来
最古老的海豚的年龄。

846
00:44:06,380 --> 00:44:10,490
如此反复，你开始写之前，
代码，有一张纸或有

847
00:44:10,490 --> 00:44:14,020
gedit中打开，如果你想，写
一些伪代码这一点。

848
00:44:14,020 --> 00:44:16,560
在三分钟内，我们将
走过去的伪代码。

849
00:44:16,560 --> 00:44:19,260
你们还有三分钟
代码，然后我们就去了编码

850
00:44:19,260 --> 00:44:21,180
它在一起。

851
00:44:21,180 --> 00:44:25,370
>> 如果您有任何问题，因为
这是不明确的，提高你的手，

852
00:44:25,370 --> 00:44:27,720
我会回来的，我很高兴
回答你的问题。

853
00:44:27,720 --> 00:44:31,080
但开始，走三分钟
写伪代码，以确保您

854
00:44:31,080 --> 00:44:32,675
理解这个问题的逻辑。

855
00:44:32,675 --> 00:46:40,160

856
00:46:40,160 --> 00:46:44,030
>> 让我们来刺在
伪代码为一组。

857
00:46:44,030 --> 00:46:46,780
我要在黑板上写这
你给我的伪代码。

858
00:46:46,780 --> 00:46:49,350
谁愿意给
我的第一行？

859
00:46:49,350 --> 00:46:51,170
第一行的也许是最简单的，
所以如果你有不

860
00:46:51,170 --> 00:46:54,010
还参加了，从这里开始。

861
00:46:54,010 --> 00:46:56,020
什么是伪代码的第一行。

862
00:46:56,020 --> 00:47:02,322
>> 学生：第一行是来检查
那你得到的参数数目。

863
00:47:02,322 --> 00:47:03,768
>> JASON HIRSCHHORN：完全正确。

864
00:47:03,768 --> 00:47:10,516

865
00:47:10,516 --> 00:47:14,150
检查数量的参数，第一个
的事情，我们需要做的。

866
00:47:14,150 --> 00:47:15,400
接下来呢？

867
00:47:15,400 --> 00:47:22,010

868
00:47:22,010 --> 00:47:27,776
>> 学生：检查该命令时，
第一个参数是大于0？

869
00:47:27,776 --> 00:47:31,050
>> JASON HIRSCHHORN：检查第一
参数大于0，是的。

870
00:47:31,050 --> 00:47:38,930

871
00:47:38,930 --> 00:47:40,400
下一行，继续前进。

872
00:47:40,400 --> 00:47:47,020
>> 学生：那么你很可能要
该命令行参数存储到

873
00:47:47,020 --> 00:47:51,380
一个变量，或者你可以只
转到下一个步骤。

874
00:47:51,380 --> 00:47:55,340
>> JASON HIRSCHHORN：是的，同样，我们将
有一个字符串在这里，但我们希望有一个

875
00:47:55,340 --> 00:47:57,600
整数，因为它是一个数字，
所以我们需要做的

876
00:47:57,600 --> 00:47:58,650
字符串转换为整数。

877
00:47:58,650 --> 00:47:59,210
>> 学生：X，Y。

878
00:47:59,210 --> 00:48:00,090
>> JASON HIRSCHHORN：这是正确的。

879
00:48:00,090 --> 00:48:01,970
因此，我们将编写一个。

880
00:48:01,970 --> 00:48:04,542
字符串 - 哇，看那个标记。

881
00:48:04,542 --> 00:48:06,760
这就是我们所需要的第二件事
这样做，拿绳子，

882
00:48:06,760 --> 00:48:07,490
把它变成一个int。

883
00:48:07,490 --> 00:48:08,740
下一步是什么？

884
00:48:08,740 --> 00:48:13,220

885
00:48:13,220 --> 00:48:18,770
>> 学生：与创建整型数组
第一个命令行的大小

886
00:48:18,770 --> 00:48:20,190
论点是不是编程？

887
00:48:20,190 --> 00:48:20,950
>> JASON HIRSCHHORN：对不起？

888
00:48:20,950 --> 00:48:26,957
>> 学生：只需创建一个int数组，
并使其成为命令的大小

889
00:48:26,957 --> 00:48:28,260
那你有行参数。

890
00:48:28,260 --> 00:48:30,920
>> JASON HIRSCHHORN：创建
大小的数组 - 

891
00:48:30,920 --> 00:48:33,930
我们会做精氨酸，无论
这样的说法了。

892
00:48:33,930 --> 00:48:34,850
好不好？

893
00:48:34,850 --> 00:48:36,100
下一步是什么？

894
00:48:36,100 --> 00:48:44,310

895
00:48:44,310 --> 00:48:48,230
>> 因此，我们有数组，允许
教练员进入一个

896
00:48:48,230 --> 00:48:50,096
年龄每海豚。

897
00:48:50,096 --> 00:48:52,790
为了得到一个时代，调用一个函数
用下面的原型。

898
00:48:52,790 --> 00:48:53,480
因此，我们有我们的数组。

899
00:48:53,480 --> 00:48:54,350
什么是我们需要做什么？

900
00:48:54,350 --> 00:48:56,805
>> 学生：对于n海豚？

901
00:48:56,805 --> 00:48:58,110
>> JASON HIRSCHHORN：确定。

902
00:48:58,110 --> 00:48:59,640
我打算写为每个。

903
00:48:59,640 --> 00:49:01,580
对于每一个海豚，是什么
我们需要做什么？

904
00:49:01,580 --> 00:49:04,340

905
00:49:04,340 --> 00:49:05,785
来吧？

906
00:49:05,785 --> 00:49:08,400
>> 学生：调用该函数。

907
00:49:08,400 --> 00:49:11,678
>> JASON HIRSCHHORN：通话
的功能，确定。

908
00:49:11,678 --> 00:49:15,640
>> 学生：在pseudocoding，你应该
这样定义在一个单独的函数

909
00:49:15,640 --> 00:49:16,660
伪代码块？

910
00:49:16,660 --> 00:49:17,650
>> JASON HIRSCHHORN：所以，是的。

911
00:49:17,650 --> 00:49:20,540
让我们做伪代码的一个单独的盒子
在这里，伪代码getAge。

912
00:49:20,540 --> 00:49:23,600
所以这个函数，对于每个海豚
我们称之为getAge，并

913
00:49:23,600 --> 00:49:25,370
getAge返回的东西。

914
00:49:25,370 --> 00:49:27,840
那么，我们应该把
我们回国的事情吗？

915
00:49:27,840 --> 00:49:30,730

916
00:49:30,730 --> 00:49:32,690
它返回一个int指针，对不对？

917
00:49:32,690 --> 00:49:35,810
这是返回类型，根据
该函数的原型。

918
00:49:35,810 --> 00:49:37,620
那么，我们是否把
该整型指针。

919
00:49:37,620 --> 00:49:41,828

920
00:49:41,828 --> 00:49:43,040
>> 学生：入阵。

921
00:49:43,040 --> 00:49:43,570
>> JASON HIRSCHHORN：入阵。

922
00:49:43,570 --> 00:49:44,460
这听起来不错。

923
00:49:44,460 --> 00:49:53,270
调用getAge，把回报
在数组中的值。

924
00:49:53,270 --> 00:49:57,490

925
00:49:57,490 --> 00:49:58,850
>> 让我们暂停getAge一秒钟。

926
00:49:58,850 --> 00:49:59,855
我们会回来的。

927
00:49:59,855 --> 00:50:01,310
我会让你开始
我这句话，马库斯。

928
00:50:01,310 --> 00:50:02,790
但是，我们已经得到了每个年龄。

929
00:50:02,790 --> 00:50:03,390
我们已经把他们所有的数组中。

930
00:50:03,390 --> 00:50:04,640
我们做的到底是什么？

931
00:50:04,640 --> 00:50:07,170

932
00:50:07,170 --> 00:50:10,640
我们如何完成主？

933
00:50:10,640 --> 00:50:13,630
什么是我们需要做的最后一件事？

934
00:50:13,630 --> 00:50:14,210
奥尔登？

935
00:50:14,210 --> 00:50:17,490
>> 学生：我们可以对它们进行排序，并
然后打印的最大发现。

936
00:50:17,490 --> 00:50:20,700
>> JASON HIRSCHHORN：我们可以
对它们进行排序，是的。

937
00:50:20,700 --> 00:50:21,950
那么我们该如何排序？

938
00:50:21,950 --> 00:50:25,670

939
00:50:25,670 --> 00:50:28,070
>> 学生：我们可以只喜欢 - 

940
00:50:28,070 --> 00:50:30,600
>> JASON HIRSCHHORN：我们是否需要
在此排序，但？

941
00:50:30,600 --> 00:50:32,810
>> 学生：我想不会。

942
00:50:32,810 --> 00:50:33,760
>> JASON HIRSCHHORN：确定。

943
00:50:33,760 --> 00:50:34,920
之前你这样做。

944
00:50:34,920 --> 00:50:37,300
什么是第一方式
你写的搜索？

945
00:50:37,300 --> 00:50:39,930
>> 学生：我们可以只检查每个
人反对对方之一。

946
00:50:39,930 --> 00:50:40,640
>> JASON HIRSCHHORN：让我们做到这一点。

947
00:50:40,640 --> 00:50:44,090
让我们通过搜索每一个和公正
跟踪最老的年龄。

948
00:50:44,090 --> 00:50:47,850

949
00:50:47,850 --> 00:50:54,110
搜索历史最悠久的，然后做什么
我们需要做的最古老的？

950
00:50:54,110 --> 00:50:55,330
>> 学生：返回它。

951
00:50:55,330 --> 00:50:56,280
打印出来，对不起。

952
00:50:56,280 --> 00:50:56,950
>> JASON HIRSCHHORN：我们走吧。

953
00:50:56,950 --> 00:50:58,630
完全正确。

954
00:50:58,630 --> 00:51:02,400
打印出最古老的。

955
00:51:02,400 --> 00:51:02,870
>> 确定。

956
00:51:02,870 --> 00:51:03,220
马库斯？

957
00:51:03,220 --> 00:51:05,800
>> 学生：跟踪的
作为历史最悠久的您加入他们吗？

958
00:51:05,800 --> 00:51:07,900
>> JASON HIRSCHHORN：OK，
搜索历史最悠久的。

959
00:51:07,900 --> 00:51:11,910
所以我们可以保持最古老的轨道
当我们把它们加起来有。

960
00:51:11,910 --> 00:51:16,360
调用getAge，把返回值在
数组，然后看看这是

961
00:51:16,360 --> 00:51:18,950
目前最古老的一个，也许救
它在一个不同的变量？

962
00:51:18,950 --> 00:51:20,400
这将正常工作。

963
00:51:20,400 --> 00:51:24,150
这实际上可能会节省我们
行，但是这是梦幻般的。

964
00:51:24,150 --> 00:51:26,120
我要离开这个
在这里现在。

965
00:51:26,120 --> 00:51:28,420
但是，如果你想在你的
实施把它那一步

966
00:51:28,420 --> 00:51:29,980
进一步，那将是巨大的。

967
00:51:29,980 --> 00:51:30,520
>> 马库斯？

968
00:51:30,520 --> 00:51:31,950
让我们做getAge在这里。

969
00:51:31,950 --> 00:51:33,930
>> MARCUS：确定。

970
00:51:33,930 --> 00:51:36,000
问一个年​​龄的用户。

971
00:51:36,000 --> 00:51:38,400
>> JASON HIRSCHHORN：问
用户一个年龄。

972
00:51:38,400 --> 00:51:39,650
确定。

973
00:51:39,650 --> 00:51:44,285

974
00:51:44,285 --> 00:51:46,252
可大家都看到了吗？

975
00:51:46,252 --> 00:51:47,900
在这里？

976
00:51:47,900 --> 00:51:51,530
好吧，询问用户一个年龄。

977
00:51:51,530 --> 00:51:52,780
坚持下去，你得到这个。

978
00:51:52,780 --> 00:51:55,250

979
00:51:55,250 --> 00:51:58,900
>> MARCUS：我想我真的不知道为什么
最好是返回一个int比星

980
00:51:58,900 --> 00:52:02,020
只是一个int，然后像只
返回年龄来存储它。

981
00:52:02,020 --> 00:52:04,200
>> JASON HIRSCHHORN：这不一定
不如归去。

982
00:52:04,200 --> 00:52:07,335
它会很好的工作回国，
但我希望你为返回int明星。

983
00:52:07,335 --> 00:52:08,585
>> MARCUS：确定。

984
00:52:08,585 --> 00:52:11,120

985
00:52:11,120 --> 00:52:12,620
我真的不知道是什么 - 

986
00:52:12,620 --> 00:52:13,050
>> JASON HIRSCHHORN：确定。

987
00:52:13,050 --> 00:52:14,430
没有任何人有任何想法？

988
00:52:14,430 --> 00:52:15,580
我们要求用户一个年龄。

989
00:52:15,580 --> 00:52:16,830
我们得到一个整数。

990
00:52:16,830 --> 00:52:23,970

991
00:52:23,970 --> 00:52:24,580
>> 确定。

992
00:52:24,580 --> 00:52:28,140
那么，为什么不我们在这里暂停一下。

993
00:52:28,140 --> 00:52:31,350
我们打​​算去我们的下一个步骤
逻辑，映射这些东西，看看，

994
00:52:31,350 --> 00:52:35,480
然后你们将代码首先
部分，以及代码了这一切

995
00:52:35,480 --> 00:52:37,380
在一起，但一个特定的getAge。

996
00:52:37,380 --> 00:52:39,395
我们会弄清楚这是怎么回事
在与该整数明星。

997
00:52:39,395 --> 00:52:41,970

998
00:52:41,970 --> 00:52:45,440
>> 但在此之前，我们这样做，我们才跳
成C代码，可以有人指出

999
00:52:45,440 --> 00:52:49,682
有些事情，他们在我们的伪代码见
这将映射到正规的代码？

1000
00:52:49,682 --> 00:52:53,130

1001
00:52:53,130 --> 00:52:53,850
在C？

1002
00:52:53,850 --> 00:52:57,580
所以有些事情在伪代码，有些话
你看，有的缩进你

1003
00:52:57,580 --> 00:53:00,435
看，一些事情，给你一些
有关如何在C代码这个提示？

1004
00:53:00,435 --> 00:53:01,360
>> 学生：For循环。

1005
00:53:01,360 --> 00:53:01,930
>> JASON HIRSCHHORN：在哪里？

1006
00:53:01,930 --> 00:53:04,356
>> 学生：对于“每一个”海豚“

1007
00:53:04,356 --> 00:53:06,310
>> JASON HIRSCHHORN：确定。

1008
00:53:06,310 --> 00:53:06,910
我们走吧。

1009
00:53:06,910 --> 00:53:07,920
我们已经有了一个循环那里。

1010
00:53:07,920 --> 00:53:09,420
还有什么？

1011
00:53:09,420 --> 00:53:09,920
盟？

1012
00:53:09,920 --> 00:53:12,410
>> 学生：为int的字符串
事情将是一个为i

1013
00:53:12,410 --> 00:53:14,270
>> JASON HIRSCHHORN：确定。

1014
00:53:14,270 --> 00:53:15,850
因此，我们在前面提到过的功能。

1015
00:53:15,850 --> 00:53:19,180

1016
00:53:19,180 --> 00:53:20,430
我们看到其他的东西？

1017
00:53:20,430 --> 00:53:26,456

1018
00:53:26,456 --> 00:53:27,992
>> 学生：printf的。

1019
00:53:27,992 --> 00:53:29,920
>> JASON HIRSCHHORN：没错。

1020
00:53:29,920 --> 00:53:35,470
不是很明显，但我希望我们有
现在有些熟悉的printf。

1021
00:53:35,470 --> 00:53:38,340
还有什么？

1022
00:53:38,340 --> 00:53:38,660
是吗？

1023
00:53:38,660 --> 00:53:41,230
>> 学生：读一个数组是
只是声明了一个数组？

1024
00:53:41,230 --> 00:53:42,350
>> JASON HIRSCHHORN：确定。

1025
00:53:42,350 --> 00:53:45,410
大小arg的话，。

1026
00:53:45,410 --> 00:53:46,190
这是正确的。

1027
00:53:46,190 --> 00:53:49,140
我不知道写的是​​什么
为，但肯定的，宣告之一。

1028
00:53:49,140 --> 00:53:50,490
另一个词来创建它。

1029
00:53:50,490 --> 00:53:53,070
我们看到了这里的任何其他的东西？

1030
00:53:53,070 --> 00:53:53,830
结构我们知道吗？

1031
00:53:53,830 --> 00:53:56,340
什么是线“的搜索
为最古老的？“什么样的

1032
00:53:56,340 --> 00:53:57,290
结构可能使用？

1033
00:53:57,290 --> 00:54:00,370
奥尔登，你建议。

1034
00:54:00,370 --> 00:54:01,620
>> 学生：只要搜索。

1035
00:54:01,620 --> 00:54:04,812

1036
00:54:04,812 --> 00:54:06,850
所以像只是一个循环。

1037
00:54:06,850 --> 00:54:07,920
>> JASON HIRSCHHORN：一个循环。

1038
00:54:07,920 --> 00:54:10,420
所以，他们的搜索。

1039
00:54:10,420 --> 00:54:12,510
你可能谈论线性
搜索就在这里，所以它可能

1040
00:54:12,510 --> 00:54:14,550
只需使用一个标准的循环经历
一切，这就是为什么

1041
00:54:14,550 --> 00:54:17,630
柯蒂斯认为，我们可以把
它在先前的循环。

1042
00:54:17,630 --> 00:54:19,810
>> 我们看不到任何其他的东西？

1043
00:54:19,810 --> 00:54:22,260
检查参数的个数数。

1044
00:54:22,260 --> 00:54:23,300
我们如何检查什么吗？

1045
00:54:23,300 --> 00:54:24,782
>> 学生：如果报表。

1046
00:54:24,782 --> 00:54:31,710

1047
00:54:31,710 --> 00:54:32,130
和

1048
00:54:32,130 --> 00:54:33,640
>> JASON HIRSCHHORN：这是
一个if条件。

1049
00:54:33,640 --> 00:54:37,040

1050
00:54:37,040 --> 00:54:39,460
>> 那么，你为什么不上手
该编码方案。

1051
00:54:39,460 --> 00:54:40,570
你有伪代码在这里。

1052
00:54:40,570 --> 00:54:42,310
开始写在C代码。

1053
00:54:42,310 --> 00:54:47,050
再次，我们要弄清楚什么是
与整型明星和事

1054
00:54:47,050 --> 00:54:50,910
我们如何能真正编写这个程序
所以，它符合

1055
00:54:50,910 --> 00:54:52,870
规格我给你。

1056
00:54:52,870 --> 00:54:57,330
如果你想，但是，启动
只有整型得到无效。

1057
00:54:57,330 --> 00:54:58,620
它只是返回一个整数。

1058
00:54:58,620 --> 00:55:00,070
>> 这有助于你走了。

1059
00:55:00,070 --> 00:55:01,380
只是代码的。

1060
00:55:01,380 --> 00:55:04,760
代码它只是返回类型
作为一个int，而不是作为一个int明星。

1061
00:55:04,760 --> 00:55:07,340
但是，我们打算把它变成
整型明星再次使我们能够顺应

1062
00:55:07,340 --> 00:55:08,040
该规范。

1063
00:55:08,040 --> 00:55:12,220
也探讨如何访问一个实际
得到什么杰夫

1064
00:55:12,220 --> 00:55:13,550
说起早期。

1065
00:55:13,550 --> 00:55:16,800
因此，需要三到五分钟
编写这一点。

1066
00:55:16,800 --> 01:01:16,860

1067
01:01:16,860 --> 01:01:19,590
>> 我们将通过
这个代码放在一起。

1068
01:01:19,590 --> 01:01:23,360
如果有缺少我道歉
澄清这种某些部分。

1069
01:01:23,360 --> 01:01:26,240
但我们要看看什么权利
现在的问题是我已经打完了所有的

1070
01:01:26,240 --> 01:01:29,690
它是什么样子的代码
如果我们只是返回一个

1071
01:01:29,690 --> 01:01:30,690
整数与getAge。

1072
01:01:30,690 --> 01:01:33,390
我们将通过该代码，并
然后我们会找出我们如何能

1073
01:01:33,390 --> 01:01:38,900
真正得到它，以配合什么
要求我们要返回一个int明星。

1074
01:01:38,900 --> 01:01:39,560
>> 下面的代码。

1075
01:01:39,560 --> 01:01:42,870
再次，我向你道歉，我们不能
编写了这一点作为一个群体，但我想

1076
01:01:42,870 --> 01:01:44,410
以确保我们通过它。

1077
01:01:44,410 --> 01:01:47,050
>> 对于顶级的，我们有我们的函数
原型，getAge。

1078
01:01:47,050 --> 01:01:48,920
之前我们已经看到了。

1079
01:01:48,920 --> 01:01:54,490
返回类型，然后再
名称，然后参数。

1080
01:01:54,490 --> 01:01:57,930
>> 在这里，我们包括
三个库。

1081
01:01:57,930 --> 01:02:00,560
有人可以告诉我是什么
这一行12呢？

1082
01:02:00,560 --> 01:02:02,020
夏普包括标准live.h？

1083
01:02:02,020 --> 01:02:05,410

1084
01:02:05,410 --> 01:02:06,410
这是什么线路呢？

1085
01:02:06,410 --> 01:02:10,120
如果我要问你这个上了白卷，并
我问你给我的答案

1086
01:02:10,120 --> 01:02:14,060
两句话，你会说什么？

1087
01:02:14,060 --> 01:02:15,310
>> 学生：[听不清]

1088
01:02:15,310 --> 01:02:19,290

1089
01:02:19,290 --> 01:02:22,160
允许你使用所有的功能
存储在该文件中。

1090
01:02:22,160 --> 01:02:23,310
>> JASON HIRSCHHORN：这是
一个很好的答案。

1091
01:02:23,310 --> 01:02:28,140
这是header函数具有
的多个函数原型

1092
01:02:28,140 --> 01:02:31,130
如果你要使用那些在
您的图书馆，这是说这些

1093
01:02:31,130 --> 01:02:32,900
功能存在。

1094
01:02:32,900 --> 01:02:37,510
我需要什么别的事情可做，如果我
包括，比方说，CS50库？

1095
01:02:37,510 --> 01:02:39,660
我需要什么别的事情可做的时候
我编译我的程序？

1096
01:02:39,660 --> 01:02:43,550
>> 学生：[听不清]包括：
使用它的破折号升。

1097
01:02:43,550 --> 01:02:46,980
因此，我们需要在那些CS50库链接
与破折号升站立链接。

1098
01:02:46,980 --> 01:02:51,310
在实际的那些破折号升CS50链接和
零，实际执行

1099
01:02:51,310 --> 01:02:55,030
的，也就是说，得到的字符串或得到诠释。

1100
01:02:55,030 --> 01:02:57,090
>> 所以后来我们在主。

1101
01:02:57,090 --> 01:03:00,340
确保用户输入一个且只有
一个命令行参数。

1102
01:03:00,340 --> 01:03:02,780
就像我们的伪代码，我们有
如果这里调理了。

1103
01:03:02,780 --> 01:03:05,650
我们希望，你们是很熟悉
用这条线，并能​​够

1104
01:03:05,650 --> 01:03:10,590
写这段代码很快，
检查的argc。

1105
01:03:10,590 --> 01:03:12,430
>> 接下来，我们正在做一个给我行。

1106
01:03:12,430 --> 01:03:13,490
同样，你以前见过的。

1107
01:03:13,490 --> 01:03:17,310
这是将字符串转换
为整数。

1108
01:03:17,310 --> 01:03:19,520
>> 接下来的事情我做的是我
另外，如果条件。

1109
01:03:19,520 --> 01:03:22,450
我确保他们进入了一个积极的
每海豚的数量

1110
01:03:22,450 --> 01:03:26,810
规范，检查是否
海豚是小于1。

1111
01:03:26,810 --> 01:03:31,090
所以，再一次的第一部分
代码，这三样东西 - 

1112
01:03:31,090 --> 01:03:33,300
检查args来数，n，如果
它是大于零 - 

1113
01:03:33,300 --> 01:03:35,770
你写的代码很多，
验证用户输入。

1114
01:03:35,770 --> 01:03:39,210
你应该很熟悉
编写该代码，并能够

1115
01:03:39,210 --> 01:03:41,100
很快写。

1116
01:03:41,100 --> 01:03:43,220
>> 下一步，我们初始化一个新数组。

1117
01:03:43,220 --> 01:03:45,140
什么类型的东西都是我们
把这个数组？

1118
01:03:45,140 --> 01:03:48,950

1119
01:03:48,950 --> 01:03:53,010
每一次这样的整数
三个字符。

1120
01:03:53,010 --> 01:03:57,020
>> 接下来，我们得到的年龄，和一个正常的
用于遍历数组迭代，

1121
01:03:57,020 --> 01:04:00,405
我们正在调用这个函数getAge，
存储的返回值

1122
01:04:00,405 --> 01:04:02,000
getAge阵列中。

1123
01:04:02,000 --> 01:04:04,630
同样，你写的代码一样
这个有很多之前了。

1124
01:04:04,630 --> 01:04:08,585
有一件事，希望你会搜集
从去通过你的过去

1125
01:04:08,585 --> 01:04:10,930
这个测验的问题是，很多
你将成为怎样继续做

1126
01:04:10,930 --> 01:04:12,730
有些事情你已经做了。

1127
01:04:12,730 --> 01:04:15,820
这是非常重要的，看看那些
模式，让你不会

1128
01:04:15,820 --> 01:04:18,660
使您的工作在超硬你
未来通过思考我从来没有做过

1129
01:04:18,660 --> 01:04:19,050
这之前。

1130
01:04:19,050 --> 01:04:21,400
你以前做过的所有的这些东西。

1131
01:04:21,400 --> 01:04:23,880
>> 接下来，我们的代码最终行。

1132
01:04:23,880 --> 01:04:27,890
我们跟踪的最古老的时代，
经过各年龄，就像你

1133
01:04:27,890 --> 01:04:29,040
建议，奥尔登。

1134
01:04:29,040 --> 01:04:33,060
如果目前的事儿岁
我们正在通过迭代较大

1135
01:04:33,060 --> 01:04:36,350
比我们保存的最古老的号码，
我们更新了最古老的数目。

1136
01:04:36,350 --> 01:04:40,170
>> 终于在年底，我们打印
出的最古老的数目。

1137
01:04:40,170 --> 01:04:41,340
同样，你这样做之前。

1138
01:04:41,340 --> 01:04:43,850
你实际写入线性搜索。

1139
01:04:43,850 --> 01:04:44,980
你需要写一个。

1140
01:04:44,980 --> 01:04:46,190
这是一个有点不同。

1141
01:04:46,190 --> 01:04:48,135
你正在寻找一个具体的数字，
不是最大的，但

1142
01:04:48,135 --> 01:04:50,300
你以前写了这个代码。

1143
01:04:50,300 --> 01:04:52,930
>> 最后，在诠释getAge，
你以前见过这个。

1144
01:04:52,930 --> 01:04:55,780
我们有一个do-whil​​e循环问
用于用户输入，直到它

1145
01:04:55,780 --> 01:04:57,080
满足一定的条件。

1146
01:04:57,080 --> 01:05:00,650
最后，我们只是返回
该整数。

1147
01:05:00,650 --> 01:05:03,650
>> 因此，所有这些代码你已经看到
之前和之前写的。

1148
01:05:03,650 --> 01:05:05,250
这里没有什么是新的。

1149
01:05:05,250 --> 01:05:08,040
当然，我介绍它在一个
不同的方式，我也许太

1150
01:05:08,040 --> 01:05:11,050
我的方向混乱，
但你以前见过这个。

1151
01:05:11,050 --> 01:05:14,870
这个逻辑你是有能力的100％。

1152
01:05:14,870 --> 01:05:18,670
如果我们运行这个程序
真的很快 - 

1153
01:05:18,670 --> 01:05:22,300
我已经做到了，所以
我们将运行。/教练机。

1154
01:05:22,300 --> 01:05:23,110
>> 发生了什么事？

1155
01:05:23,110 --> 01:05:24,878
>> 学生：[听不清]。

1156
01:05:24,878 --> 01:05:26,120
>> JASON HIRSCHHORN：我没有
给任何参数。

1157
01:05:26,120 --> 01:05:27,290
让我们培养5海豚。

1158
01:05:27,290 --> 01:05:30,450
那将是二，三，
四，五岁。

1159
01:05:30,450 --> 01:05:34,240
正如你可以看到在这里，它
打印出的最古老的时代。

1160
01:05:34,240 --> 01:05:35,580
因此，让我们重新回到gedit的。

1161
01:05:35,580 --> 01:05:38,400
>> 不过，当然，这不是什么
规范是要求。

1162
01:05:38,400 --> 01:05:40,870
这是问的原型。

1163
01:05:40,870 --> 01:05:45,070
没有回报的整数，但
回报在整数明星。

1164
01:05:45,070 --> 01:05:47,600
所以，如果我要去那里改变它
在原型我更好

1165
01:05:47,600 --> 01:05:49,660
在这里改变它。

1166
01:05:49,660 --> 01:05:52,140
>> 现在让我们通过工作
这，就在这里。

1167
01:05:52,140 --> 01:05:53,460
让我们从最底层做起。

1168
01:05:53,460 --> 01:05:54,720
年龄不是一个int明星。

1169
01:05:54,720 --> 01:05:56,987
年龄是可变的是什么类型的？

1170
01:05:56,987 --> 01:05:57,861
>> 学生：一个整数。

1171
01:05:57,861 --> 01:06:02,240
>> JASON HIRSCHHORN：所以线63，年龄
不应该是一个整数。

1172
01:06:02,240 --> 01:06:03,070
它应该是一个int明星。

1173
01:06:03,070 --> 01:06:05,680
我如何让它一个int明星？

1174
01:06:05,680 --> 01:06:07,560
>> 学生：[听不清]。

1175
01:06:07,560 --> 01:06:10,750
>> JASON HIRSCHHORN：把一个明星在那里。

1176
01:06:10,750 --> 01:06:13,080
现在让我们来看看这儿吧。

1177
01:06:13,080 --> 01:06:20,070
67，调用getInt返回一个整数，而我们
存储在年龄该整数。

1178
01:06:20,070 --> 01:06:21,980
但是，如果我们对待年龄为
现在指针，我们怎么需要

1179
01:06:21,980 --> 01:06:24,224
更新此行？

1180
01:06:24,224 --> 01:06:25,926
>> 学生：把一个明星。

1181
01:06:25,926 --> 01:06:28,876
>> JASON HIRSCHHORN：将
岁前的明星。

1182
01:06:28,876 --> 01:06:30,397
那是你说什么？

1183
01:06:30,397 --> 01:06:31,311
>> 学生：是啊。

1184
01:06:31,311 --> 01:06:32,100
>> JASON HIRSCHHORN：对。

1185
01:06:32,100 --> 01:06:34,340
因为调用getInt返回一个整数。

1186
01:06:34,340 --> 01:06:39,110
我们想去给位置
我们的年龄，把一个整数那里。

1187
01:06:39,110 --> 01:06:42,420
如果我们做这行代码，我们会去
回到了柯蒂斯在谈论

1188
01:06:42,420 --> 01:06:46,170
早些时候，节约的时代，一些疯狂
整数，也许整数5。

1189
01:06:46,170 --> 01:06:48,860
最后，我们尝试去位置5
在内存中，而我们在很多得到

1190
01:06:48,860 --> 01:06:51,040
该烦恼。

1191
01:06:51,040 --> 01:06:54,550
>> 因此，我们需要一个明星
还有，和第69行？

1192
01:06:54,550 --> 01:06:57,260
同样，年龄，它在内存中
就在这里解决。

1193
01:06:57,260 --> 01:06:59,850
那么，我们如何需要更新这一行？

1194
01:06:59,850 --> 01:07:00,990
别人？

1195
01:07:00,990 --> 01:07:02,612
我们如何需要更新这一行？

1196
01:07:02,612 --> 01:07:04,872
>> 学生：将一个星号出现。

1197
01:07:04,872 --> 01:07:06,180
>> JASON HIRSCHHORN：完全正确。

1198
01:07:06,180 --> 01:07:08,270
添加一个小星星就在那里。

1199
01:07:08,270 --> 01:07:12,060
现在，我们正在提出的价值
由年龄而不是年龄。

1200
01:07:12,060 --> 01:07:15,090
>> 所以，再一次，我们看到这个代码去
从整数到终点。

1201
01:07:15,090 --> 01:07:17,130
非常相似。

1202
01:07:17,130 --> 01:07:19,965
我们需要寻找那些地方我们
有年龄，我们需要改变他们

1203
01:07:19,965 --> 01:07:23,180
一点点，因为我们不希望
变革时代的盒子这么多，什么年龄

1204
01:07:23,180 --> 01:07:26,470
是指向。

1205
01:07:26,470 --> 01:07:30,790
>> 和返回的年龄，是正确的？

1206
01:07:30,790 --> 01:07:32,900
这是正确的，因为
年龄是一个int指针。

1207
01:07:32,900 --> 01:07:33,845
是啊，问题吗？

1208
01:07:33,845 --> 01:07:38,030
>> 学生：我们可以将它诠释年龄
贯穿始终，并在​​最后时刻，把

1209
01:07:38,030 --> 01:07:39,930
在时代前面的符号？

1210
01:07:39,930 --> 01:07:41,780
>> JASON HIRSCHHORN：与
返回它的地址？

1211
01:07:41,780 --> 01:07:43,380
这是一个非常好的问题。

1212
01:07:43,380 --> 01:07:48,720
你可以做到这一点，但让我们来
在第二和答案

1213
01:07:48,720 --> 01:07:49,710
问题在第二。

1214
01:07:49,710 --> 01:07:50,790
奇妙的问题。

1215
01:07:50,790 --> 01:07:58,170
>> 在这里，如果我们打开一个int
指针，什么类型的东西是

1216
01:07:58,170 --> 01:08:00,460
海豚的年龄存储在里面？

1217
01:08:00,460 --> 01:08:03,640
如果我们返回一个int指针向右
在这里，什么类型的东西

1218
01:08:03,640 --> 01:08:06,380
海豚的年龄存储在里面？

1219
01:08:06,380 --> 01:08:10,220
整型指针，所以第37行
应该是int明星。

1220
01:08:10,220 --> 01:08:11,260
这就是这个数组的类型。

1221
01:08:11,260 --> 01:08:12,370
这不是存储整数了。

1222
01:08:12,370 --> 01:08:13,620
它的存储整型指针。

1223
01:08:13,620 --> 01:08:16,340

1224
01:08:16,340 --> 01:08:22,750
>> 终于到这里，海豚的年龄
支架我，那将会给我们，

1225
01:08:22,750 --> 01:08:24,189
再次，和整型指针。

1226
01:08:24,189 --> 01:08:25,590
我们不希望一个int指针。

1227
01:08:25,590 --> 01:08:27,960
我们想要的值指出
由该整数。

1228
01:08:27,960 --> 01:08:29,500
于是哈桑，我们如何能够
改变这一行？

1229
01:08:29,500 --> 01:08:30,939
>> 学生：把一个明星？

1230
01:08:30,939 --> 01:08:32,899
>> JASON HIRSCHHORN：完全正确，
把一个明星在那里。

1231
01:08:32,899 --> 01:08:33,750
这会给我们一个值。

1232
01:08:33,750 --> 01:08:35,587
怎么样线51？

1233
01:08:35,587 --> 01:08:37,050
>> 学生：另一个明星。

1234
01:08:37,050 --> 01:08:39,779
>> JASON HIRSCHHORN：另一个明星。

1235
01:08:39,779 --> 01:08:41,490
这是完全正确的。

1236
01:08:41,490 --> 01:08:45,740
所以，我们正在处理，现在再次，这些
事情如int的指针。

1237
01:08:45,740 --> 01:08:51,015
>> 学生：是不是在所有问题，在
getAge，诠释星级年龄从来没有放弃

1238
01:08:51,015 --> 01:08:51,899
E位置？

1239
01:08:51,899 --> 01:08:54,910
>> 杰森HIRSCHHORN：这是一个问题，即
整型明星的年龄永远不会给出一个

1240
01:08:54,910 --> 01:08:56,930
位置，这将是一个类似
问题你是什么

1241
01:08:56,930 --> 01:08:59,830
与刚刚回国说起
符号的年龄和

1242
01:08:59,830 --> 01:09:00,450
保持它作为一个int。

1243
01:09:00,450 --> 01:09:02,580
但我想先运行此代码
看看会发生什么。

1244
01:09:02,580 --> 01:09:07,229

1245
01:09:07,229 --> 01:09:07,720
>> 确定。

1246
01:09:07,720 --> 01:09:10,399
所以变量年龄UNITIALIZED
这里使用的时候。

1247
01:09:10,399 --> 01:09:14,240
所以说，“初始化变量
“年龄”来关闭此警告，“它

1248
01:09:14,240 --> 01:09:16,630
建议给它空。

1249
01:09:16,630 --> 01:09:19,510
让我们给它空。

1250
01:09:19,510 --> 01:09:20,790
因此，我们应该摆脱THA警告。

1251
01:09:20,790 --> 01:09:22,040
我们应该能够编译。

1252
01:09:22,040 --> 01:09:29,710

1253
01:09:29,710 --> 01:09:30,600
>> 多大年纪是海豚？

1254
01:09:30,600 --> 01:09:33,180
比方说，1。

1255
01:09:33,180 --> 01:09:36,240
赛格故障。

1256
01:09:36,240 --> 01:09:39,300
>> 所以，我会去通过GDB现在，我
鼓励你去通过GDB上

1257
01:09:39,300 --> 01:09:43,250
你自己去弄清楚为什么这
程序只是赛格故障。

1258
01:09:43,250 --> 01:09:45,580
我不会离开这个作为
悬念，虽然和我要去

1259
01:09:45,580 --> 01:09:47,960
打开这个功能。

1260
01:09:47,960 --> 01:09:50,950
我们要去理解为什么
这个程序段故障。

1261
01:09:50,950 --> 01:09:55,640
所以，大家都在栈上，当
函数被调用时，一个托盘被添加到

1262
01:09:55,640 --> 01:09:59,590
众所周知栈，本地
变量被存储。

1263
01:09:59,590 --> 01:10:02,910
当函数返回时，
该纸盘消失。

1264
01:10:02,910 --> 01:10:05,540
这些局部变量走开为好。

1265
01:10:05,540 --> 01:10:11,330
>> 诠释星级年龄等于null是一个本地
变量保存在堆栈帧。

1266
01:10:11,330 --> 01:10:16,570
当此功能消失，这
变量消失为好。

1267
01:10:16,570 --> 01:10:19,980
所以，我们通过对地址
的一切。

1268
01:10:19,980 --> 01:10:22,540
我们通过对年龄。

1269
01:10:22,540 --> 01:10:25,280
这是一个地址，我们通过上。

1270
01:10:25,280 --> 01:10:29,430
但最终，我们 - 

1271
01:10:29,430 --> 01:10:32,580
>> 对不起，我自己走在前面。

1272
01:10:32,580 --> 01:10:36,940
为什么这个节目真的赛格故障的
这种情况下是因为年龄为指向

1273
01:10:36,940 --> 01:10:40,560
为空值，它是一个特定的位置，
和null是你不是一个位置

1274
01:10:40,560 --> 01:10:41,870
不准碰。

1275
01:10:41,870 --> 01:10:45,570
所以，当我们试着写这行
的代码，将年龄和做

1276
01:10:45,570 --> 01:10:49,090
那里的东西，我们就麻烦了，
而这也正是我们赛格故障。

1277
01:10:49,090 --> 01:10:51,630
因为明星的年龄，年龄再
是指为null。

1278
01:10:51,630 --> 01:10:53,450
我们希望为空，这是一个坏的区域。

1279
01:10:53,450 --> 01:10:58,570
我们试图调用getInt有，1在我们的情况下，
而这也正是我们赛格故障。

1280
01:10:58,570 --> 01:11:01,340
>> 但是说一个选择的情况下，说我们
给了这个合法地址

1281
01:11:01,340 --> 01:11:05,800
就在这里，就像bf4ac，东西
我们之前看到的。

1282
01:11:05,800 --> 01:11:10,960
即便如此，当这个程序返回，
我们会碰到一个问题，因为

1283
01:11:10,960 --> 01:11:13,810
该地址就会消失。

1284
01:11:13,810 --> 01:11:16,870
局部变量的地址
会消失。

1285
01:11:16,870 --> 01:11:20,580
不管年龄是指出不会
已经存在了。

1286
01:11:20,580 --> 01:11:22,090
>> 我们修复的方法是
你见过的东西

1287
01:11:22,090 --> 01:11:24,450
之前，malloc函数。

1288
01:11:24,450 --> 01:11:26,240
你已经被引入到
该malloc函数之前。

1289
01:11:26,240 --> 01:11:27,670
你见过吗？

1290
01:11:27,670 --> 01:11:30,140
malloc的给你一些内存
不会消失的时候

1291
01:11:30,140 --> 01:11:31,950
堆栈帧消失。

1292
01:11:31,950 --> 01:11:33,660
所以写这行代码 - 

1293
01:11:33,660 --> 01:11:35,360
我想给
它给你的现在 - 

1294
01:11:35,360 --> 01:11:36,120
malloc的。

1295
01:11:36,120 --> 01:11:41,490
而且，由于我们要存储一个int，我们
打算将malloc足够的空间。

1296
01:11:41,490 --> 01:11:44,480
我们要去说放弃
我一箱大小为int。

1297
01:11:44,480 --> 01:11:49,480
malloc的返回地址，我们
节能年龄的地址。

1298
01:11:49,480 --> 01:11:50,805
>> 现在，当我们运行这个程序 - 

1299
01:11:50,805 --> 01:11:56,810

1300
01:11:56,810 --> 01:12:01,040
我们不会向赛格错，因为
记忆体区块，我们通过了

1301
01:12:01,040 --> 01:12:05,140
malloc的不消失时，
堆栈帧中消失。

1302
01:12:05,140 --> 01:12:07,160
他们住，直到我们想
要摆脱他们。

1303
01:12:07,160 --> 01:12:09,610
>> 而这又回到你的问题，
杰夫，从早期。

1304
01:12:09,610 --> 01:12:17,660
我如何创建的东西在我的
我想以后使用的功能

1305
01:12:17,660 --> 01:12:19,310
在主要的或不同的功能？

1306
01:12:19,310 --> 01:12:25,800
我使用malloc，和我通过
围绕他们的地址。

1307
01:12:25,800 --> 01:12:30,200
>> 这是一个很大，无可否认，
覆盖刚才。

1308
01:12:30,200 --> 01:12:33,380
所以，请，如果您有任何
的问题，问了。

1309
01:12:33,380 --> 01:12:37,817

1310
01:12:37,817 --> 01:12:40,930
>> 学生：所以的malloc不上
堆栈了，然后呢？

1311
01:12:40,930 --> 01:12:42,900
>> JASON HIRSCHHORN：这是
完全正确。

1312
01:12:42,900 --> 01:12:46,620
盒子的malloc是给你
是不是在堆栈中。

1313
01:12:46,620 --> 01:12:49,270
它把它给你在这个部分的其他
内存，并且我们要

1314
01:12:49,270 --> 01:12:51,010
谈谈在讲座上周三。

1315
01:12:51,010 --> 01:12:54,650
这个名字是堆，但我不希望
要过多谈论它比其他

1316
01:12:54,650 --> 01:12:57,920
那就是没有得到这个其他地方
当函数消失删除。

1317
01:12:57,920 --> 01:13:04,790

1318
01:13:04,790 --> 01:13:06,040
>> 还有没有其他问题？

1319
01:13:06,040 --> 01:13:08,999

1320
01:13:08,999 --> 01:13:13,390
>> 学生：我想如果你没有使用
单独的函数，你把所有这一切

1321
01:13:13,390 --> 01:13:16,705
代码放到主，你仍然会
需要使用malloc？

1322
01:13:16,705 --> 01:13:20,250
>> JASON HIRSCHHORN：大问题。

1323
01:13:20,250 --> 01:13:23,180
这可能不是最有效的
写这个程序的方式。

1324
01:13:23,180 --> 01:13:26,270
你可以很容易地做到了这一点的do-whil​​e
圈主并保存

1325
01:13:26,270 --> 01:13:28,800
自己一大堆的麻烦。

1326
01:13:28,800 --> 01:13:31,910
为什么我想要做这样的原因
这是因为我想大家

1327
01:13:31,910 --> 01:13:37,680
可以看到在主，
我们可以创建一个数组

1328
01:13:37,680 --> 01:13:41,060
指针，INT指针。

1329
01:13:41,060 --> 01:13:45,590
我们可以初始化这些指针
别的地方，把他们在这个其他

1330
01:13:45,590 --> 01:13:50,610
内存区域停留，只要
我们希望它留下来，然后我们就可以

1331
01:13:50,610 --> 01:13:51,500
后来访问它们。

1332
01:13:51,500 --> 01:13:53,670
>> 例如，我们在这里搜索
通过他们。

1333
01:13:53,670 --> 01:13:54,770
我们可以做其他
活动它们。

1334
01:13:54,770 --> 01:13:56,820
我们也可以得到他们
发现的平均值。

1335
01:13:56,820 --> 01:13:57,750
我们可以做很多事情。

1336
01:13:57,750 --> 01:14:02,650
问题的关键是，你可以跟踪
有些事情在通过主

1337
01:14:02,650 --> 01:14:05,820
一个数组，创建某处那些事
别的，然后仍然使用

1338
01:14:05,820 --> 01:14:06,620
他们稍后。

1339
01:14:06,620 --> 01:14:09,910
>> 而这种想法，我们现在正在做什么，
要来了很多在未来

1340
01:14:09,910 --> 01:14:13,130
P-集合，你要解决的问题。

1341
01:14:13,130 --> 01:14:16,260
这就是为什么我们做了这样的连
但无可否认它是一个费解

1342
01:14:16,260 --> 01:14:17,440
在此上下文中位。

1343
01:14:17,440 --> 01:14:20,004
>> 学生：[听不清]

1344
01:14:20,004 --> 01:14:25,060
如果你可以把所有的整型年龄为
相对于指针的实际值，

1345
01:14:25,060 --> 01:14:27,610
可能你现在使用的符号的年龄？

1346
01:14:27,610 --> 01:14:28,410
>> JASON HIRSCHHORN：对不起？

1347
01:14:28,410 --> 01:14:32,100
>> 学生：如果你拿出星星
所有的年龄了，只是没有回报

1348
01:14:32,100 --> 01:14:34,610
符号的年龄，到了最后，
将这项工作？

1349
01:14:34,610 --> 01:14:36,670
>> JASON HIRSCHHORN：所以的malloc
返回地址。

1350
01:14:36,670 --> 01:14:37,752
>> 学生：行吧。

1351
01:14:37,752 --> 01:14:41,550
>> JASON HIRSCHHORN：它返回一个地址，
这样的年龄必须是一个整数

1352
01:14:41,550 --> 01:14:43,555
指针，因为它要
被存储在一个地址。

1353
01:14:43,555 --> 01:14:52,980

1354
01:14:52,980 --> 01:14:55,160
>> 我们还剩下六分钟。

1355
01:14:55,160 --> 01:14:58,590
我将跳过说话
有关堆栈现在。

1356
01:14:58,590 --> 01:15:04,090
我要进入​​3分钟
简要地对SPL，最重要的

1357
01:15:04,090 --> 01:15:06,470
事情我认为你需要
知道问题集。

1358
01:15:06,470 --> 01:15:09,430
>> 然而，在我来到这里，因为这
就是我们要完成的，

1359
01:15:09,430 --> 01:15:11,440
最后两个提醒。

1360
01:15:11,440 --> 01:15:14,640
其中，无可否认，我们透过事物去
很快在这一节。

1361
01:15:14,640 --> 01:15:16,340
我该道歉的步伐。

1362
01:15:16,340 --> 01:15:20,120
如果您有任何问题，
这是我们走过去，为什么东西

1363
01:15:20,120 --> 01:15:22,810
工作方式也如此，还是我的东西
不解释的清楚，因为我可以

1364
01:15:22,810 --> 01:15:26,830
有，请拍我的电子邮件或谈话
我下课后，我会很高兴

1365
01:15:26,830 --> 01:15:28,360
解释给你更深入。

1366
01:15:28,360 --> 01:15:30,320
所以，请伸出手，如果
您有任何疑问。

1367
01:15:30,320 --> 01:15:33,270
>> 再次，反馈网站也是如此。

1368
01:15:33,270 --> 01:15:36,120
花一些时间下课，如果你有
它给我一些反馈。

1369
01:15:36,120 --> 01:15:37,730
我明白了很多。

1370
01:15:37,730 --> 01:15:41,050
正如你看到的在类的开头，
我通过他们读，作出回应

1371
01:15:41,050 --> 01:15:43,440
如果你想有一个回应，我
你认为这个心脏。

1372
01:15:43,440 --> 01:15:45,250
这意味着很多给我。

1373
01:15:45,250 --> 01:15:49,250
>> 让我们通过谈论下课
你要去图书馆

1374
01:15:49,250 --> 01:15:50,200
要使用这个星期。

1375
01:15:50,200 --> 01:15:53,220
你可能见过这样的代码就是我
之前在屏幕上，GRect

1376
01:15:53,220 --> 01:15:54,470
桨等于newGRect，（X，
Y，宽，高）。

1377
01:15:54,470 --> 01:15:57,410

1378
01:15:57,410 --> 01:16:00,350
你们有可能通过读
通过规范感到相当

1379
01:16:00,350 --> 01:16:03,530
熟悉这一点，但对于那些
谁是不太舒服，因为你

1380
01:16:03,530 --> 01:16:06,830
家伙，好了，我想重新过这
行，看看它是如何相似，

1381
01:16:06,830 --> 01:16:09,010
我们以前曾经使用过。

1382
01:16:09,010 --> 01:16:11,610
>> 就像任何变量 - 

1383
01:16:11,610 --> 01:16:14,570
这是一个对象，但就像对待
任何变量，我们有第一型

1384
01:16:14,570 --> 01:16:17,490
最重要的是在这里，GRect。

1385
01:16:17,490 --> 01:16:22,600
>> 接下来我们的对象的名称，并
最后我们有功能

1386
01:16:22,600 --> 01:16:27,820
初始化它，给我们
我们想要的桨。

1387
01:16:27,820 --> 01:16:32,040
有时候我们写整数x等于5，而
我们直接初始化的东西。

1388
01:16:32,040 --> 01:16:34,930
有时候我们写字符串
名称等于得到的字符串。

1389
01:16:34,930 --> 01:16:40,110
我们用一个函数来得到的东西，
我们采取它的返回值，并

1390
01:16:40,110 --> 01:16:40,880
这是我们的新的价值。

1391
01:16:40,880 --> 01:16:44,580
>> 因此，我们已经看到过这样的想法，其中
，可能会或可能不需要的功能

1392
01:16:44,580 --> 01:16:47,050
输入实际创建的东西
对我们来说，而不是

1393
01:16:47,050 --> 01:16:49,390
我们直接创建它。

1394
01:16:49,390 --> 01:16:51,060
所以，我们以前见过这种代码。

1395
01:16:51,060 --> 01:16:55,490
我们希望，这个想法的对象，或
至少创建一个对象，是不是

1396
01:16:55,490 --> 01:16:59,550
压倒性的，如果你能概念化
它只是非常类似的东西

1397
01:16:59,550 --> 01:17:01,160
我们以前见过。

1398
01:17:01,160 --> 01:17:04,280
>> 然而，关于对象的很酷的事情
从变量不同的是，我们

1399
01:17:04,280 --> 01:17:06,770
可以做的事情与他们。

1400
01:17:06,770 --> 01:17:09,920
你不能改变的颜色
变量，但你的确可以改变

1401
01:17:09,920 --> 01:17:13,250
一个对象的颜色，或至少
在SPL中您可以更改

1402
01:17:13,250 --> 01:17:14,540
颜色你的对象。

1403
01:17:14,540 --> 01:17:18,540
>> 在不能移动的变量
一个窗口，但可以移动

1404
01:17:18,540 --> 01:17:20,100
一个对象中的一个窗口。

1405
01:17:20,100 --> 01:17:21,450
你可以得到一个对象的位置。

1406
01:17:21,450 --> 01:17:23,110
你不能真正得到
变量的位置。

1407
01:17:23,110 --> 01:17:26,070
这是对很酷的事情
在这个库中的对象。

1408
01:17:26,070 --> 01:17:29,040
>> 然而，这些功能都可以
那种被混淆。

1409
01:17:29,040 --> 01:17:33,410
我们还没有真正使用的功能或
对象之前，所以我觉得这是

1410
01:17:33,410 --> 01:17:38,420
有助于了解一个通用的方法
明示或做事情的对象，或

1411
01:17:38,420 --> 01:17:39,740
理解对象。

1412
01:17:39,740 --> 01:17:41,940
正如你会发现，我有两个
这里写的函数，函数

1413
01:17:41,940 --> 01:17:45,400
你见过前 - 添加，窗口
逗号桨，并设置颜色

1414
01:17:45,400 --> 01:17:47,070
桨逗号黑色。

1415
01:17:47,070 --> 01:17:49,810
在这两种情况下，我们有一个函数
有两个参数，并

1416
01:17:49,810 --> 01:17:51,280
做一些事情。

1417
01:17:51,280 --> 01:17:54,080
>> 现在，更一般地，所有这些
你要编写一个函数

1418
01:17:54,080 --> 01:17:59,760
要处理的对象
采取地方和什么。

1419
01:17:59,760 --> 01:18:03,870
A其中是您想要的对象
做一些事来，在这

1420
01:18:03,870 --> 01:18:06,150
情况下，一个窗口或面板。

1421
01:18:06,150 --> 01:18:09,700
而什么是你想要的
要做到这一点，或给它。

1422
01:18:09,700 --> 01:18:11,140
>> 当你设置颜色
什么，在哪里

1423
01:18:11,140 --> 01:18:11,980
您设置的颜色？

1424
01:18:11,980 --> 01:18:14,160
随着桨对象。

1425
01:18:14,160 --> 01:18:16,230
和你设置什么颜色的？

1426
01:18:16,230 --> 01:18:18,320
黑色。

1427
01:18:18,320 --> 01:18:20,610
与add函数，其中
你在做什么吗？

1428
01:18:20,610 --> 01:18:21,610
与窗口对象。

1429
01:18:21,610 --> 01:18:22,630
什么是你给了吗？

1430
01:18:22,630 --> 01:18:24,230
你给它的桨。

1431
01:18:24,230 --> 01:18:29,070
>> 你会发现，你的功能
使用时，设置颜色，设置位置等

1432
01:18:29,070 --> 01:18:32,140
等等，等等，所有
遵循这个模式。

1433
01:18:32,140 --> 01:18:35,180
他们把你想要做的事
东西，该对象想要

1434
01:18:35,180 --> 01:18:39,970
做的东西，你想什么
用它做什么，或者你想有什么

1435
01:18:39,970 --> 01:18:42,630
改变，或者你想有什么
加入，或者在特定的颜色

1436
01:18:42,630 --> 01:18:43,430
你希望它是。

1437
01:18:43,430 --> 01:18:49,330
或者，如果它不填，你要
使其填充，等等，等等。

1438
01:18:49,330 --> 01:18:53,500
>> 诚然，一个非常简短的讨论
斯坦福 - 

1439
01:18:53,500 --> 01:18:55,950
是什么呢？

1440
01:18:55,950 --> 01:18:59,060
斯坦福大学编程库？

1441
01:18:59,060 --> 01:18:59,890
便携图书馆，这是正确的！

1442
01:18:59,890 --> 01:19:01,340
谢谢类。

1443
01:19:01,340 --> 01:19:04,150
斯坦福便携式图书馆。

1444
01:19:04,150 --> 01:19:06,710
但同样，很多更多的信息
在问题设置规范给定的，但

1445
01:19:06,710 --> 01:19:09,680
希望这使得它一点点
更易于理解对象，

1446
01:19:09,680 --> 01:19:13,710
尤其是当他们已经​​与
我们已经看到和以前做过的事情。

1447
01:19:13,710 --> 01:19:16,010
>> 所以用一点，那就是本周四。

1448
01:19:16,010 --> 01:19:18,140
享受学习
堆的明天。

1449
01:19:18,140 --> 01:19:22,360
好运气在下周您的测验，但
当然，我会在那之前看到的，

1450
01:19:22,360 --> 01:19:24,860
希望在节下周二。

1451
01:19:24,860 --> 01:19:27,970
但也如果你有任何问题，
意见，疑问，请随时

1452
01:19:27,970 --> 01:19:28,930
伸手。

1453
01:19:28,930 --> 01:19:31,745
下了课，我就到外面，如果
你想谈谈你的问题

1454
01:19:31,745 --> 01:19:32,995
设置或有一些问题。

1455
01:19:32,995 --> 01:19:35,915