1
00:00:00,000 --> 00:00:11,046

2
00:00:11,046 --> 00:00:12,170
ZAMYLA陈：嗨，大家好。

3
00:00:12,170 --> 00:00:13,560
欢迎来到部分。

4
00:00:13,560 --> 00:00:17,320
今天只是要所有的测验
检查您的测验周三。

5
00:00:17,320 --> 00:00:20,060
我希望大家记住
他们在周三进行测验。

6
00:00:20,060 --> 00:00:22,560
如果你没有，那么，
现在你已经提醒。

7
00:00:22,560 --> 00:00:26,486
因此，周三一定要显示出来
类或其他的住宿，

8
00:00:26,486 --> 00:00:26,985
有必要的。

9
00:00:26,985 --> 00:00:27,845

10
00:00:27,845 --> 00:00:29,220
你们都将是真棒。

11
00:00:29,220 --> 00:00:30,440
这将是巨大的。

12
00:00:30,440 --> 00:00:34,910
而且我会尽我所能
帮助今天准备为您的测验

13
00:00:34,910 --> 00:00:35,470
现在。

14
00:00:35,470 --> 00:00:39,960
而且如果你不知道，
有一个广泛的课程审查会议

15
00:00:39,960 --> 00:00:45,840
今天在7时
西北实验室B103室。

16
00:00:45,840 --> 00:00:49,950
你可以再次看到我的安可为
我将带领该审查会议的一部分

17
00:00:49,950 --> 00:00:50,510
也。

18
00:00:50,510 --> 00:00:53,218
所以，如果你不能得到足够的我
现在，你可以再来今晚。

19
00:00:53,218 --> 00:00:54,130

20
00:00:54,130 --> 00:00:56,060
>> 好吧，所以首先第一件事情。

21
00:00:56,060 --> 00:00:59,630
之前，我们只是一些测验技巧
实际上下潜到审查。

22
00:00:59,630 --> 00:01:04,160
因此，对于任何考试，实践
一定会帮助你的。

23
00:01:04,160 --> 00:01:09,260
有从过去的考试
六，七年在那里，

24
00:01:09,260 --> 00:01:12,480
所以这是一个大量的实践
材料你们有。

25
00:01:12,480 --> 00:01:15,340
而事实上，今天真的只是
将要会在任何议题

26
00:01:15,340 --> 00:01:18,900
那你们有还有疑问
通过实践工作的问题

27
00:01:18,900 --> 00:01:20,360
从测验为零。

28
00:01:20,360 --> 00:01:22,690
所以，我会扔了竞猜零
从去年开始就在这里，

29
00:01:22,690 --> 00:01:26,410
我们可以通过任何问题工作
那你们想。

30
00:01:26,410 --> 00:01:27,370
>> 所以练习。

31
00:01:27,370 --> 00:01:29,310
你会开始，今天做的事情。

32
00:01:29,310 --> 00:01:30,230
代码在纸面上。

33
00:01:30,230 --> 00:01:32,970
所以是的，如果每个人都
居然可以全身而退

34
00:01:32,970 --> 00:01:35,810
纸，那将是巨大的，
因为你不

35
00:01:35,810 --> 00:01:41,470
要在您的计算机上
考试，写出来的代码手工

36
00:01:41,470 --> 00:01:44,190
往往是困难得多
比你想象的。

37
00:01:44,190 --> 00:01:46,680
你已经习惯了只
看到它，并键入它，

38
00:01:46,680 --> 00:01:49,630
你有你的编译器
帮你当你有错误，

39
00:01:49,630 --> 00:01:52,190
但你没有得到，关于考试。

40
00:01:52,190 --> 00:01:55,140
因此，它实际上很重要
能写出来的代码，

41
00:01:55,140 --> 00:01:58,360
并做了肌肉记忆
它的手会真正帮助你。

42
00:01:58,360 --> 00:01:59,720

43
00:01:59,720 --> 00:02:01,690
>> 所以，我们正在一点点接近。

44
00:02:01,690 --> 00:02:02,340
今天是星期一。

45
00:02:02,340 --> 00:02:03,930
考试是在星期三。

46
00:02:03,930 --> 00:02:06,030
但是，如果你有时间，
肯定需要一

47
00:02:06,030 --> 00:02:10,199
从过去一年的考试中
下一年的时间限制之前

48
00:02:10,199 --> 00:02:11,660
的一个半小时。

49
00:02:11,660 --> 00:02:13,730
刚敲了一小时
和时间的一半，

50
00:02:13,730 --> 00:02:17,480
和自己坐了下来，
通过问题只是工作

51
00:02:17,480 --> 00:02:19,962
因为如果你是真正
服用它，因为一个

52
00:02:19,962 --> 00:02:23,295
那我们听到的最大的事情
该测验是，它们是非常长的。

53
00:02:23,295 --> 00:02:24,900

54
00:02:24,900 --> 00:02:26,660
这是一个很多材​​料。

55
00:02:26,660 --> 00:02:30,850
有很多问题，
大多数人可能无法完成。

56
00:02:30,850 --> 00:02:34,660
我知道，我完全没完成
我的小测验，当我把这个类。

57
00:02:34,660 --> 00:02:37,180
>> 关于这一点，作为少
舒适的节，

58
00:02:37,180 --> 00:02:40,570
明白这当然是指
以满足各个层次的人。

59
00:02:40,570 --> 00:02:43,640
整个原因，我们必须拆分
不太舒服，地方之间的，

60
00:02:43,640 --> 00:02:47,660
和更舒适是
种使之更加公平。

61
00:02:47,660 --> 00:02:51,699
如果你是不舒服，这是
没有必要本身得到的一切。

62
00:02:51,699 --> 00:02:53,990
就像如果你能得到
一切，你可能会

63
00:02:53,990 --> 00:02:55,448
是在更舒适的部分。

64
00:02:55,448 --> 00:03:00,160
所以，很显然不打自己了
太硬，如果你不能完成考试。

65
00:03:00,160 --> 00:03:01,920
请相信我，我没有做到这一点。

66
00:03:01,920 --> 00:03:03,070
我仍然是一个集中器。

67
00:03:03,070 --> 00:03:04,630
我还在帮助教课程。

68
00:03:04,630 --> 00:03:06,170
你会没事的。

69
00:03:06,170 --> 00:03:06,670
行。

70
00:03:06,670 --> 00:03:08,740
最后，得到一些睡眠。

71
00:03:08,740 --> 00:03:11,020
显然，任何考试
我们经常说这个。

72
00:03:11,020 --> 00:03:13,610
临时抱佛脚前一天晚上
而没有得到任何睡眠

73
00:03:13,610 --> 00:03:16,390
确实不是 - 也许，如果是
为你工作，去了。

74
00:03:16,390 --> 00:03:18,790
但对于绝大多数
人，得到一些睡眠，

75
00:03:18,790 --> 00:03:22,390
让你的大脑休息和恢复
未来在考试前，

76
00:03:22,390 --> 00:03:23,480
将真正帮助你。

77
00:03:23,480 --> 00:03:26,120
也将有近
一定是糖果的考试，

78
00:03:26,120 --> 00:03:28,019
所以你必须期待。

79
00:03:28,019 --> 00:03:29,310
你们要做大。

80
00:03:29,310 --> 00:03:30,226
它会好起来的。

81
00:03:30,226 --> 00:03:31,570

82
00:03:31,570 --> 00:03:36,190
而现在，在接下来的一个半小时我
会尝试预习，你是最好的，我可以。

83
00:03:36,190 --> 00:03:41,260
>> 所以，我从基本的幻灯片
所有的部分到现在。

84
00:03:41,260 --> 00:03:45,874
我不会去通过
所有这些，因为这是不

85
00:03:45,874 --> 00:03:49,040
在一个半小时可行，以及
通过实际问题的工作。

86
00:03:49,040 --> 00:03:51,410
所以不是我的主题列表。

87
00:03:51,410 --> 00:03:55,160
这些都是所有的东西
我们可以考考你。

88
00:03:55,160 --> 00:03:56,950

89
00:03:56,950 --> 00:03:58,770
如果有什么事
真正跳出

90
00:03:58,770 --> 00:04:02,140
想要走了过来，说你
要我走了过来概念，

91
00:04:02,140 --> 00:04:04,320
我可以尝试给
您概述那里。

92
00:04:04,320 --> 00:04:07,690
或者，如果你想跳就在以
做练习题一起，

93
00:04:07,690 --> 00:04:08,420
我们可以做到这一点。

94
00:04:08,420 --> 00:04:09,330
这是给你们。

95
00:04:09,330 --> 00:04:10,770
有没有那么多的你。

96
00:04:10,770 --> 00:04:13,180
所以这是什么，你们喜欢做的事。

97
00:04:13,180 --> 00:04:15,667
我想成为最
有用的走向你们。

98
00:04:15,667 --> 00:04:16,827

99
00:04:16,827 --> 00:04:17,910
所以，我就让你只是看看。

100
00:04:17,910 --> 00:04:27,880

101
00:04:27,880 --> 00:04:30,500
>> 听众：有一件事是
我们不断图表

102
00:04:30,500 --> 00:04:33,290
说对栈和堆。

103
00:04:33,290 --> 00:04:34,600

104
00:04:34,600 --> 00:04:37,434
仅落后于整体思路
这一点，是什么意思。

105
00:04:37,434 --> 00:04:38,350
ZAMYLA陈：是的，确定。

106
00:04:38,350 --> 00:04:40,290

107
00:04:40,290 --> 00:04:43,216
这是所有的方式在
年底，所以让我翻阅。

108
00:04:43,216 --> 00:04:45,490
>> 听众：我们不必
现在就这样做，但不管。

109
00:04:45,490 --> 00:04:47,070

110
00:04:47,070 --> 00:04:49,770
>> ZAMYLA陈：有没有
anything--这一个。

111
00:04:49,770 --> 00:04:51,570

112
00:04:51,570 --> 00:04:53,555
这是一种模糊的人吗？

113
00:04:53,555 --> 00:04:54,390

114
00:04:54,390 --> 00:04:55,640
听众：是的，我是第二个。

115
00:04:55,640 --> 00:04:57,718
并能我们也做缓冲区溢出？

116
00:04:57,718 --> 00:04:58,926
ZAMYLA陈：缓冲区溢出？

117
00:04:58,926 --> 00:04:59,820
行。

118
00:04:59,820 --> 00:05:03,460
因此，缓冲区溢出是相当
易只是说说。

119
00:05:03,460 --> 00:05:08,217
它基本上是缓冲你想想
一些数组的内存，你有，对不对？

120
00:05:08,217 --> 00:05:10,050
我们通常讲
缓冲区溢出时

121
00:05:10,050 --> 00:05:15,160
你不检查多少钱
用户投入，对不对？

122
00:05:15,160 --> 00:05:18,540
这种想法是
与缓冲区溢出

123
00:05:18,540 --> 00:05:21,535
他们把在远
太多的数据的空间

124
00:05:21,535 --> 00:05:23,780
你已经分配给他们，对不对？

125
00:05:23,780 --> 00:05:28,310
>> 所以，如果你说，给
我的一些消息，我们

126
00:05:28,310 --> 00:05:31,860
假设他们打算给
我们一个合理的长度的消息。

127
00:05:31,860 --> 00:05:33,910
也许几行，诸如此类的东西。

128
00:05:33,910 --> 00:05:35,150
因此，我们不检查。

129
00:05:35,150 --> 00:05:38,160
相反，他们养活我们的
整本书就是一个消息，

130
00:05:38,160 --> 00:05:42,450
和溢出的量
我们已经分配给这个空间。

131
00:05:42,450 --> 00:05:48,140
什么情况是它可能会覆盖
这是不应该的地方。

132
00:05:48,140 --> 00:05:52,890
>> 所以我知道马兰教授说：
一些关于缓冲区溢出攻击。

133
00:05:52,890 --> 00:05:59,050
所以这就是用户将输入
在希望中的一些数据量庞大

134
00:05:59,050 --> 00:06:02,840
他过去覆盖
您的缓冲区的末尾

135
00:06:02,840 --> 00:06:06,479
并取代something--我不知道
我我们这些幻灯片在这里。

136
00:06:06,479 --> 00:06:08,270
我不认为我们有
这些幻灯片在这里。

137
00:06:08,270 --> 00:06:09,960

138
00:06:09,960 --> 00:06:14,460
但基本上，他改写
内存的某些部分

139
00:06:14,460 --> 00:06:17,780
这让他有机会接触
到您的计算机的某些部分

140
00:06:17,780 --> 00:06:19,530
你会不会
通常有机会获得。

141
00:06:19,530 --> 00:06:20,750

142
00:06:20,750 --> 00:06:23,155
>> 最重要的事情有
缓冲区溢出是刚刚

143
00:06:23,155 --> 00:06:26,420
要明白，它
当你不发生

144
00:06:26,420 --> 00:06:29,210
检查多少钱你
用户把英寸

145
00:06:29,210 --> 00:06:32,770
如果你是那种不
维护反对，

146
00:06:32,770 --> 00:06:36,820
并在其最简单的
的东西，它只是你的用户

147
00:06:36,820 --> 00:06:39,130
输入巨量
企图数据

148
00:06:39,130 --> 00:06:45,090
覆盖一些安全
你的内存的一部分。

149
00:06:45,090 --> 00:06:46,310
这就是它。

150
00:06:46,310 --> 00:06:49,810
>> 因此，这在这里，堆栈和堆。

151
00:06:49,810 --> 00:06:53,090
基本上所有这仅仅是
的存储器中的表示

152
00:06:53,090 --> 00:06:54,449
和那里的东西都存放。

153
00:06:54,449 --> 00:06:56,240
这是一种真正的
所有你需要知道的。

154
00:06:56,240 --> 00:06:58,520
最大的事情
你需要知道的

155
00:06:58,520 --> 00:07:01,910
that--如果让我看看
这里有个better--。

156
00:07:01,910 --> 00:07:05,380
因此，这是堆栈在这里。

157
00:07:05,380 --> 00:07:08,410
>> 所以栈，是因为有
所有的功能

158
00:07:08,410 --> 00:07:10,140
你调用在任何给定的时间。

159
00:07:10,140 --> 00:07:15,060
和什么是重要的要记住
上周去关闭使用malloc

160
00:07:15,060 --> 00:07:21,080
是你真的没有
必要的控制权。

161
00:07:21,080 --> 00:07:24,780
这一切都依赖于一定的时
函数执行。

162
00:07:24,780 --> 00:07:28,170
并且当它们被执行时，它们
有所谓的堆栈帧

163
00:07:28,170 --> 00:07:29,290
那去了这里。

164
00:07:29,290 --> 00:07:32,520
>> 因此，那种一切发生
没有你的任何真正的投入。

165
00:07:32,520 --> 00:07:33,630

166
00:07:33,630 --> 00:07:35,510
你写你的程序，
你让它运行，

167
00:07:35,510 --> 00:07:38,470
与层叠种取
关心本身，因为它需要。

168
00:07:38,470 --> 00:07:42,940
所以，如果在主你打电话
多维数据集，将在这里通过了。

169
00:07:42,940 --> 00:07:44,110
这将创建一个框架。

170
00:07:44,110 --> 00:07:48,330
但有明确你做什么
创建比其他​​栈帧

171
00:07:48,330 --> 00:07:51,430
写开头的函数，OK？

172
00:07:51,430 --> 00:07:56,500
>> 是什么样的你下
控制是使用malloc堆。

173
00:07:56,500 --> 00:08:01,950
所以每当你malloc的东西，
你是从堆取内存。

174
00:08:01,950 --> 00:08:05,110
那就是记忆，你
有，由于缺乏一个更好的词，

175
00:08:05,110 --> 00:08:10,300
显式控制，
因为记得使用malloc

176
00:08:10,300 --> 00:08:12,530
它基本上有
直到你说，否则。

177
00:08:12,530 --> 00:08:14,890
对于那些你谁
观看节最后一周，

178
00:08:14,890 --> 00:08:17,670
它的存在，直到你告诉它去了。

179
00:08:17,670 --> 00:08:20,850
它会在那里，除非
否则不能说。

180
00:08:20,850 --> 00:08:24,750
所以堆只是一些
你能想到的内存

181
00:08:24,750 --> 00:08:26,150
你有控制权。

182
00:08:26,150 --> 00:08:29,010
而这些仅仅是
两个不同的大事情。

183
00:08:29,010 --> 00:08:31,320

184
00:08:31,320 --> 00:08:38,330
>> 除此之外，你不应该有
要过分担心堆栈和堆

185
00:08:38,330 --> 00:08:42,159
疑问或通常更公正
如果你有本地的参数

186
00:08:42,159 --> 00:08:45,385
或函数会是
在堆栈或堆。

187
00:08:45,385 --> 00:08:47,260
显然，在这种情况下
这将是堆栈。

188
00:08:47,260 --> 00:08:49,630
如果你mallocing的东西，
那是哪里来的？

189
00:08:49,630 --> 00:08:50,129
堆。

190
00:08:50,129 --> 00:08:51,147

191
00:08:51,147 --> 00:08:54,230
如果你看一下练习测验，那些
一般问题的类型

192
00:08:54,230 --> 00:08:55,460
他们有。

193
00:08:55,460 --> 00:08:57,340
>> 您不必担心
太多了。

194
00:08:57,340 --> 00:09:00,980
你进入更明确
关于堆栈和堆

195
00:09:00,980 --> 00:09:03,460
稍后或在其它的CS类。

196
00:09:03,460 --> 00:09:06,220
所以只是有样的
什么是总体思路

197
00:09:06,220 --> 00:09:09,100
会好的，这是我
刚种走了过去。

198
00:09:09,100 --> 00:09:10,650

199
00:09:10,650 --> 00:09:12,090
任何其他议题？

200
00:09:12,090 --> 00:09:12,590
是吗？

201
00:09:12,590 --> 00:09:14,923
>> 听众：你可以走了
再次三分球真的很快？

202
00:09:14,923 --> 00:09:15,870
ZAMYLA陈：指针？

203
00:09:15,870 --> 00:09:18,470
你想概念
指针概述

204
00:09:18,470 --> 00:09:19,994
或者你用指针练？

205
00:09:19,994 --> 00:09:21,410
有点像语法：受众。

206
00:09:21,410 --> 00:09:22,360
ZAMYLA陈：语法？

207
00:09:22,360 --> 00:09:22,860
是啊。

208
00:09:22,860 --> 00:09:32,090

209
00:09:32,090 --> 00:09:33,090
OK，我们到达那里。

210
00:09:33,090 --> 00:09:38,300

211
00:09:38,300 --> 00:09:42,040
是啊，所以这只是种东西
当你有一个递归函数，

212
00:09:42,040 --> 00:09:45,954
每一次递归函数是
所谓的，它只是增加了其它的堆栈帧。

213
00:09:45,954 --> 00:09:47,870
相当多的例子
怎么，你真的不

214
00:09:47,870 --> 00:09:50,330
有超过控制
在您的堆栈帧。

215
00:09:50,330 --> 00:09:54,010

216
00:09:54,010 --> 00:09:54,585
>> OK，指针。

217
00:09:54,585 --> 00:09:57,120

218
00:09:57,120 --> 00:09:59,235
好吧，所以创建的指针。

219
00:09:59,235 --> 00:10:00,300

220
00:10:00,300 --> 00:10:02,420
请记住，这只是输入的明星。

221
00:10:02,420 --> 00:10:07,140
所以，无论数据类型
你会被指向。

222
00:10:07,140 --> 00:10:08,720

223
00:10:08,720 --> 00:10:11,440
因此，这将是一个指向整数的指针。

224
00:10:11,440 --> 00:10:13,140
这将是一个指针，指向一个char。

225
00:10:13,140 --> 00:10:14,740
这将是一个指针，指向一个float。

226
00:10:14,740 --> 00:10:17,980
因此，它基本上是什么
你希望它是指向，

227
00:10:17,980 --> 00:10:22,300
明星是如何声明的指针，好不好？

228
00:10:22,300 --> 00:10:26,200
>> 不过，那显然就有点
当你有麻烦的指针

229
00:10:26,200 --> 00:10:27,370
或者你有什么明星。

230
00:10:27,370 --> 00:10:31,260
所以，最大的区别是
当你declaring--

231
00:10:31,260 --> 00:10:45,590
所以我们有some--这样
这需要一些INT明星。

232
00:10:45,590 --> 00:10:49,650
因此，这是一些指针
要求X为int，对不对？

233
00:10:49,650 --> 00:10:54,600
所以请记住这是什么呢
这是调用系统X。

234
00:10:54,600 --> 00:10:56,970
并且这将
有一些地址，对吧？

235
00:10:56,970 --> 00:11:00,515
所以，我们只能说这是我们的地址。

236
00:11:00,515 --> 00:11:01,590

237
00:11:01,590 --> 00:11:03,570
指针持有地址。

238
00:11:03,570 --> 00:11:08,660
那么，这说的是，在这
位置，我们存储一个int。

239
00:11:08,660 --> 00:11:10,770

240
00:11:10,770 --> 00:11:15,770
>> 因此，另一种方式，我们能想到的
这是这是某些整数。

241
00:11:15,770 --> 00:11:17,010

242
00:11:17,010 --> 00:11:20,350
我们还没有真正分配给
做任何事，但它只是一个int。

243
00:11:20,350 --> 00:11:31,540
因此，我们可以做的是，如果我们不出演X
等于5，这将成为一个5，OK？

244
00:11:31,540 --> 00:11:38,350
这是说去什么x是
指着，所以去这个地址

245
00:11:38,350 --> 00:11:40,210
并使其等于5。

246
00:11:40,210 --> 00:11:44,390
因此，我们分配5到这个地址，对吧？

247
00:11:44,390 --> 00:11:52,540
>> 如果你这样做的话，
这给我们的地址。

248
00:11:52,540 --> 00:11:54,730
这是操作者的地址。

249
00:11:54,730 --> 00:11:57,700
那么，什么是x的地址？

250
00:11:57,700 --> 00:11:58,809
我们不知道。

251
00:11:58,809 --> 00:12:00,225
我们还没有分配它的地址。

252
00:12:00,225 --> 00:12:03,000

253
00:12:03,000 --> 00:12:09,105
我们可以说这是some--现在我们给
它的地址，所以地址为4。

254
00:12:09,105 --> 00:12:10,690

255
00:12:10,690 --> 00:12:16,980
而实际上，如果我们经历的东西
种这样的，我们所做的事情。

256
00:12:16,980 --> 00:12:25,800
所以通过这里 - 我觉得工作
它帮助，如果你画出来的指针。

257
00:12:25,800 --> 00:12:28,270
如果你对你的考试，我
强烈推荐绘图框。

258
00:12:28,270 --> 00:12:29,490

259
00:12:29,490 --> 00:12:33,310
>> 所以这第一个，诠释x等于5。

260
00:12:33,310 --> 00:12:37,370
这只是意味着我们有一些
放置在内存中是5，对不对？

261
00:12:37,370 --> 00:12:38,540

262
00:12:38,540 --> 00:12:44,760
而我们在这里表告诉我们
它的地址为0×04。

263
00:12:44,760 --> 00:12:48,770

264
00:12:48,770 --> 00:12:50,280
然后我们创建一些指针。

265
00:12:50,280 --> 00:12:51,820

266
00:12:51,820 --> 00:12:55,310
因此，让我们打破这一次。

267
00:12:55,310 --> 00:12:59,820
因此，这带来了一些
盒为int，对不对？

268
00:12:59,820 --> 00:13:01,970
这是怎么回事举行
在它的一些地址。

269
00:13:01,970 --> 00:13:03,470
因此，这是一些指针。

270
00:13:03,470 --> 00:13:04,940

271
00:13:04,940 --> 00:13:06,510
这粉笔是非常小的。

272
00:13:06,510 --> 00:13:07,472

273
00:13:07,472 --> 00:13:08,680
因此，我们在这里有一些指针。

274
00:13:08,680 --> 00:13:10,060

275
00:13:10,060 --> 00:13:13,530
和我们同桌告诉我们
这是地址为0x08的。

276
00:13:13,530 --> 00:13:15,190

277
00:13:15,190 --> 00:13:16,200
凉爽。

278
00:13:16,200 --> 00:13:23,240
我们正在分配
它到x的地址。

279
00:13:23,240 --> 00:13:26,330
>> 请记住，指针持有地址，OK？

280
00:13:26,330 --> 00:13:32,050
因此，如果我们要举行的x，我们有
使用地址运算符，它

281
00:13:32,050 --> 00:13:36,520
为符号，以获取地址
的x，对在这种情况下，0×04。

282
00:13:36,520 --> 00:13:39,130

283
00:13:39,130 --> 00:13:44,430
然后，如果我们有
一些INT副本，这只是

284
00:13:44,430 --> 00:13:48,060
创建一些其他的盒子
拥有一个int称为复制。

285
00:13:48,060 --> 00:13:49,410

286
00:13:49,410 --> 00:13:55,330
如果我们给它分配给this--
所以这是引用它。

287
00:13:55,330 --> 00:14:00,090
所以说去什么
地址指针持有。

288
00:14:00,090 --> 00:14:05,330
指针保持这个地址，
所以我们会去在这里，

289
00:14:05,330 --> 00:14:07,130
我们说好，有什么的呢？

290
00:14:07,130 --> 00:14:08,610
这是5。

291
00:14:08,610 --> 00:14:09,815
所以副本将成为5。

292
00:14:09,815 --> 00:14:11,800

293
00:14:11,800 --> 00:14:12,540
有意义吗？

294
00:14:12,540 --> 00:14:15,540

295
00:14:15,540 --> 00:14:25,020
>> 如果我想指定
这只是指针。

296
00:14:25,020 --> 00:14:26,476

297
00:14:26,476 --> 00:14:27,850
什么指针实际上等于？

298
00:14:27,850 --> 00:14:31,126

299
00:14:31,126 --> 00:14:34,315
这纯粹是什么
指针包含，对不对？

300
00:14:34,315 --> 00:14:36,400

301
00:14:36,400 --> 00:14:37,580
然后，如果我这样做？

302
00:14:37,580 --> 00:14:38,922

303
00:14:38,922 --> 00:14:39,880
什么副本呢？

304
00:14:39,880 --> 00:14:41,365

305
00:14:41,365 --> 00:14:42,275
>> 听众：0x08的。

306
00:14:42,275 --> 00:14:44,150
ZAMYLA陈：是的，在
我们的指针的地址。

307
00:14:44,150 --> 00:14:46,832

308
00:14:46,832 --> 00:14:48,790
的任何一部分
需要被重新解释？

309
00:14:48,790 --> 00:14:50,170

310
00:14:50,170 --> 00:14:50,670
凉爽。

311
00:14:50,670 --> 00:14:53,350

312
00:14:53,350 --> 00:14:57,740
肯定是有非常
在测验一个有趣的问题

313
00:14:57,740 --> 00:15:00,100
我们可以通过这
为您提供了更多的实践。

314
00:15:00,100 --> 00:15:00,937

315
00:15:00,937 --> 00:15:03,270
从上周的家伙可以
告诉你，这不是那么糟糕。

316
00:15:03,270 --> 00:15:06,000
我们通过一个完整的有
图中，每个人都做得很好。

317
00:15:06,000 --> 00:15:10,830
>> 好了，所以这是概述
的指针的语法。

318
00:15:10,830 --> 00:15:15,070
最重要的事情是如何理解
创建它们，做参考，

319
00:15:15,070 --> 00:15:18,190
和，确定地址？

320
00:15:18,190 --> 00:15:18,690
凉爽。

321
00:15:18,690 --> 00:15:20,775
在任何其他的话题
我们将深入实践。

322
00:15:20,775 --> 00:15:24,280

323
00:15:24,280 --> 00:15:28,011
此外，如果我们正在经历
实践中的问题

324
00:15:28,011 --> 00:15:30,760
这里面的东西，你想要一个
复习时，我们可以做到这一点。

325
00:15:30,760 --> 00:15:31,300
你有什么？

326
00:15:31,300 --> 00:15:32,758
>> 听众：结构体和链表。

327
00:15:32,758 --> 00:15:35,130
ZAMYLA陈：结构体
和链表，确定。

328
00:15:35,130 --> 00:15:37,100
如此结构。

329
00:15:37,100 --> 00:15:38,990
实际上，我们打算
在今晚了。

330
00:15:38,990 --> 00:15:40,130

331
00:15:40,130 --> 00:15:41,890
OK，所以结构。

332
00:15:41,890 --> 00:15:47,490
结构基本上
只是一种方式为你举行

333
00:15:47,490 --> 00:15:50,430
不同类型的多个值。

334
00:15:50,430 --> 00:15:55,150
所以用一个数组我们
收缩到一个数据类型。

335
00:15:55,150 --> 00:16:00,965
我们的数组要么有只是数字，
或者仅仅是字符，或仅仅是花车。

336
00:16:00,965 --> 00:16:02,240

337
00:16:02,240 --> 00:16:05,470
>> 但是，也许你需要
包含不止于此。

338
00:16:05,470 --> 00:16:09,130
也许你需要的，如果要hold--
你在谈论一个学生，

339
00:16:09,130 --> 00:16:13,660
你将拥有自己的房子，他们的
ID号，他们的年龄，他们居住的地方，

340
00:16:13,660 --> 00:16:14,240
对不对？

341
00:16:14,240 --> 00:16:16,460
而所有这些都
不同种类的类型。

342
00:16:16,460 --> 00:16:18,680
所以，你不能存储
这些都在一个数组中。

343
00:16:18,680 --> 00:16:21,750
>> 所以你能做的就是你
可以创建一个结构，它

344
00:16:21,750 --> 00:16:26,240
你能想到的是你
自己的个人数据类型。

345
00:16:26,240 --> 00:16:29,130
而不是那么仅仅有整型
而不是仅仅有花车和，

346
00:16:29,130 --> 00:16:33,210
你可以有一个类型的学生
拥有所有这这些领域。

347
00:16:33,210 --> 00:16:39,740
因此，我们初始化方式
我们的结构is--实际

348
00:16:39,740 --> 00:16:44,921
因为我的写作是可怕的，我们
要过渡到打字。

349
00:16:44,921 --> 00:16:45,420
呜。

350
00:16:45,420 --> 00:16:48,800

351
00:16:48,800 --> 00:16:53,150
>> 好了，如果我们想创建一个struct--
我只是把它倒在这里。

352
00:16:53,150 --> 00:16:57,730
无视于任何主
我们将在以后使用。

353
00:16:57,730 --> 00:17:02,330
所以，你想要做的方式
它是用typedef结构。

354
00:17:02,330 --> 00:17:10,530

355
00:17:10,530 --> 00:17:13,349
让我们只需要调用这个学生
因为这是我使用。

356
00:17:13,349 --> 00:17:17,801
好了，类型定义意味着你
定义一个新类型，行吗？

357
00:17:17,801 --> 00:17:20,140

358
00:17:20,140 --> 00:17:24,355
也有细微的差别，当你做进
只是一个结构与一个typedef结构。

359
00:17:24,355 --> 00:17:26,313
对于所有意图和
的目的，你们只是

360
00:17:26,313 --> 00:17:29,490
要承担他们
大致相同，只是

361
00:17:29,490 --> 00:17:30,820
使用typedef结构现在。

362
00:17:30,820 --> 00:17:35,180
它会成为这样更明显的
下一个P所设置的这些差异，

363
00:17:35,180 --> 00:17:37,960
但我不认为你需要
担心现在。

364
00:17:37,960 --> 00:17:40,360
我宁愿你
知道如何创建一个，

365
00:17:40,360 --> 00:17:41,880
访问它，并分配[？值。 ？]

366
00:17:41,880 --> 00:17:47,820
>> 一种新型结构，并
我们要求它的学生。

367
00:17:47,820 --> 00:17:52,640
所以，我们就大功告成了创建此之后，
对于所有意图和目的，

368
00:17:52,640 --> 00:17:55,070
你将有一个名为学生类型。

369
00:17:55,070 --> 00:17:59,610
你可以把它仅仅作为一种类型
就像一个int或浮点或字符。

370
00:17:59,610 --> 00:18:01,820
这只是另一种类型，好不好？

371
00:18:01,820 --> 00:18:04,530
>> 所以在这一块，我们有什么？

372
00:18:04,530 --> 00:18:05,420
我们也许有一个名字。

373
00:18:05,420 --> 00:18:08,275
因此，也许我们需要一个字符串名称。

374
00:18:08,275 --> 00:18:09,610

375
00:18:09,610 --> 00:18:14,065
我们有可能为int这是一个ID。

376
00:18:14,065 --> 00:18:16,360

377
00:18:16,360 --> 00:18:19,085
此外，我们还有另一
这就是电话号码。

378
00:18:19,085 --> 00:18:21,990

379
00:18:21,990 --> 00:18:26,200
我们已经some--让我们来看看。

380
00:18:26,200 --> 00:18:27,200
还有什么可能我们有吗？

381
00:18:27,200 --> 00:18:29,385
我们将有一些字符串在他的家里。

382
00:18:29,385 --> 00:18:32,340

383
00:18:32,340 --> 00:18:34,510
所有的事情，有个学生了。

384
00:18:34,510 --> 00:18:36,960
>> 所以这个现在创建一个结构。

385
00:18:36,960 --> 00:18:41,450
那么，如何可能我们创建了一个学生吗？

386
00:18:41,450 --> 00:18:46,960
如果我们有一些变量是
要谈论沃克在这里，

387
00:18:46,960 --> 00:18:51,245
所以我们have--我们只是
要调用此walker。

388
00:18:51,245 --> 00:18:52,520
他需要的类型。

389
00:18:52,520 --> 00:18:53,770
什么是你喜欢的类型？

390
00:18:53,770 --> 00:18:54,520
听众：学生。

391
00:18:54,520 --> 00:18:55,395
ZAMYLA陈：学生。

392
00:18:55,395 --> 00:18:57,130

393
00:18:57,130 --> 00:19:04,800
因此，这只是创建一个对象，你可以
想拥有这一切。

394
00:19:04,800 --> 00:19:07,880
您刚刚创建了一个学步车学生。

395
00:19:07,880 --> 00:19:10,910
所以，现在我们需要能够
指定所有这些，对不对？

396
00:19:10,910 --> 00:19:13,500
因此，没有人记得如何
我们一个结构中访问？

397
00:19:13,500 --> 00:19:14,762

398
00:19:14,762 --> 00:19:15,470
听众：期。

399
00:19:15,470 --> 00:19:16,730
ZAMYLA陈：没错时期。

400
00:19:16,730 --> 00:19:23,795
因此，如果我们想分配
他的名字，我们可以做到这一点。

401
00:19:23,795 --> 00:19:24,820

402
00:19:24,820 --> 00:19:28,680
显然，这会
在这里be--这部分将

403
00:19:28,680 --> 00:19:31,831
以内为主，所以
居然让我做到这一点。

404
00:19:31,831 --> 00:19:40,980

405
00:19:40,980 --> 00:19:44,250
此声明上述主让
我们可以在主要使用它。

406
00:19:44,250 --> 00:19:52,250

407
00:19:52,250 --> 00:20:00,980
所以，现在我希望它做的ID，
而我们只是做一些在那里，

408
00:20:00,980 --> 00:20:02,970
然后我们会分配一个房子。

409
00:20:02,970 --> 00:20:07,990

410
00:20:07,990 --> 00:20:09,000
巴姆。

411
00:20:09,000 --> 00:20:09,650
凉爽。

412
00:20:09,650 --> 00:20:19,870
>> 所以，现在我们应该永远需要访问
任何后来on--也许we--

413
00:20:19,870 --> 00:20:25,920
如果我们需要访问什么，
我们只是做一个int副本ID。

414
00:20:25,920 --> 00:20:27,400

415
00:20:27,400 --> 00:20:30,530
我想复制
沃克的ID到这一点。

416
00:20:30,530 --> 00:20:31,370
我会如何做呢？

417
00:20:31,370 --> 00:20:33,670

418
00:20:33,670 --> 00:20:37,790
你需要助行器中访问
结构为[？去那？] [？ E']。

419
00:20:37,790 --> 00:20:41,280
并以同样的方式，我们
在这里，如何分配它

420
00:20:41,280 --> 00:20:45,573
也许我们访问它的时候，我们要
给该值到别的东西？

421
00:20:45,573 --> 00:20:46,406
听众：Walker.id。

422
00:20:46,406 --> 00:20:47,252

423
00:20:47,252 --> 00:20:48,376
ZAMYLA陈：是的，没错。

424
00:20:48,376 --> 00:20:51,884

425
00:20:51,884 --> 00:20:54,175
这就是几乎所有的
你需要知道的结构。

426
00:20:54,175 --> 00:20:55,750

427
00:20:55,750 --> 00:20:58,560
你只需要想想
它们作为另一个变量。

428
00:20:58,560 --> 00:21:01,710
基本上是一个创建
自己的变量类型，好不好？

429
00:21:01,710 --> 00:21:04,440

430
00:21:04,440 --> 00:21:07,970
您可以使用它来声明
变量以任何方式。

431
00:21:07,970 --> 00:21:10,290
在这里，沃克仍然是一个变数。

432
00:21:10,290 --> 00:21:14,230
它只是一个类型的学生，而不是现在
，一个int类型，或字符串类型

433
00:21:14,230 --> 00:21:15,070
或char类型。

434
00:21:15,070 --> 00:21:17,014

435
00:21:17,014 --> 00:21:19,930
如果有一个简单的方法来说话
关于结构，它真的只是一个

436
00:21:19,930 --> 00:21:24,430
创建自己的数据类型
这可以让你组

437
00:21:24,430 --> 00:21:28,320
所有这些不同的
样的数据一起。

438
00:21:28,320 --> 00:21:29,754

439
00:21:29,754 --> 00:21:31,595
这是否有道理？

440
00:21:31,595 --> 00:21:33,920

441
00:21:33,920 --> 00:21:34,420
行。

442
00:21:34,420 --> 00:21:35,920

443
00:21:35,920 --> 00:21:37,530
这和访问点使用。

444
00:21:37,530 --> 00:21:38,790

445
00:21:38,790 --> 00:21:39,960
几乎所有你所需要的。

446
00:21:39,960 --> 00:21:41,150

447
00:21:41,150 --> 00:21:46,600
>> OK，在哪里我的PowerPoint中去？

448
00:21:46,600 --> 00:21:47,580
这里是。

449
00:21:47,580 --> 00:21:49,050

450
00:21:49,050 --> 00:21:50,520
嗯，这是奇怪的。

451
00:21:50,520 --> 00:21:53,950

452
00:21:53,950 --> 00:21:55,420
啊哈。

453
00:21:55,420 --> 00:21:56,766
OK，爽。

454
00:21:56,766 --> 00:21:58,876

455
00:21:58,876 --> 00:22:01,000
任何其他的事情还是我们
要前往练？

456
00:22:01,000 --> 00:22:02,210

457
00:22:02,210 --> 00:22:02,710
实践？

458
00:22:02,710 --> 00:22:03,501
行。

459
00:22:03,501 --> 00:22:04,000
真棒。

460
00:22:04,000 --> 00:22:05,642

461
00:22:05,642 --> 00:22:06,600
我要退出了。

462
00:22:06,600 --> 00:22:08,490
如果在任何点期间
练习题，

463
00:22:08,490 --> 00:22:12,630
我很高兴地改造
并通过东西。

464
00:22:12,630 --> 00:22:15,240
所以，我有竞猜零在这里。

465
00:22:15,240 --> 00:22:18,370
如果你们想拉
它在您的计算机上，

466
00:22:18,370 --> 00:22:20,670
就像需要五
几分钟浏览。

467
00:22:20,670 --> 00:22:23,540
也许选择一些顶级
你想问题，走了过来。

468
00:22:23,540 --> 00:22:27,390
如果你们不能决定，我们只
慢慢地开始通过他们的工作，

469
00:22:27,390 --> 00:22:31,590
但我敢肯定，有一些将要
你是特别的问题

470
00:22:31,590 --> 00:22:34,890
热衷于谈论，并有
我的工作，通过与你的所有。

471
00:22:34,890 --> 00:22:36,580
因此，只要继续前进，走五分钟。

472
00:22:36,580 --> 00:22:37,780
翻阅。

473
00:22:37,780 --> 00:22:40,620
这是从2013年的测验。

474
00:22:40,620 --> 00:22:41,841
>> 听众：零？

475
00:22:41,841 --> 00:22:43,630
>> ZAMYLA陈：是啊，测验为零。

476
00:22:43,630 --> 00:22:45,647
我们不是在做测验1东西。

477
00:22:45,647 --> 00:22:46,980
我们会做，在一两个星期。

478
00:22:46,980 --> 00:22:52,941

479
00:22:52,941 --> 00:22:55,190
也为那些你们谁
进来晚了，我们有糖果，

480
00:22:55,190 --> 00:23:00,580
所以做你们要糖果？

481
00:23:00,580 --> 00:23:01,530
>> 听众：当然。

482
00:23:01,530 --> 00:23:03,321
>> ZAMYLA陈：我只是
要通过身边。

483
00:23:03,321 --> 00:23:09,774

484
00:23:09,774 --> 00:23:11,940
嘿，如果你们到这里来
早期，你会得到更多的糖果。

485
00:23:11,940 --> 00:23:12,500
没关系。

486
00:23:12,500 --> 00:23:13,550
本，你要糖果？

487
00:23:13,550 --> 00:23:19,350

488
00:23:19,350 --> 00:23:20,556
你想点？

489
00:23:20,556 --> 00:23:24,122

490
00:23:24,122 --> 00:23:26,080
还有，如果士力架
有人想士力架。

491
00:23:26,080 --> 00:23:27,640

492
00:23:27,640 --> 00:23:29,360
我会留下来在这里和这里。

493
00:23:29,360 --> 00:23:30,946
随意。

494
00:23:30,946 --> 00:23:32,485
你想了吗？

495
00:23:32,485 --> 00:23:33,235
听众：所有设置。

496
00:23:33,235 --> 00:23:33,540
谢谢。

497
00:23:33,540 --> 00:23:36,248
>> ZAMYLA陈：我有一个不错的
小桩有开头。

498
00:23:36,248 --> 00:23:49,080

499
00:23:49,080 --> 00:23:51,980
你们去参加测验和
我到有一个测验分级派对。

500
00:23:51,980 --> 00:23:54,496

501
00:23:54,496 --> 00:23:55,360
这是一片混乱。

502
00:23:55,360 --> 00:23:56,460

503
00:23:56,460 --> 00:23:57,385
900考试。

504
00:23:57,385 --> 00:23:58,650
这将是这么多的乐趣。

505
00:23:58,650 --> 00:24:00,441

506
00:24:00,441 --> 00:24:02,036
将是巨大的。

507
00:24:02,036 --> 00:24:04,430
我敢肯定这是1
最大工作人员粘接

508
00:24:04,430 --> 00:24:05,380
在今年的夜晚。

509
00:24:05,380 --> 00:24:15,660

510
00:24:15,660 --> 00:24:19,175
有没有人在做测验零
去年又出于好奇？

511
00:24:19,175 --> 00:24:20,335
>> 听众：它的一部分。

512
00:24:20,335 --> 00:24:21,543
>> ZAMYLA陈：它的部分，确定。

513
00:24:21,543 --> 00:24:24,272

514
00:24:24,272 --> 00:24:26,482
你对其中任何一个问题吗？

515
00:24:26,482 --> 00:24:28,190
观众：我已经
去了办公时间。

516
00:24:28,190 --> 00:24:28,898
谢谢你，虽然。

517
00:24:28,898 --> 00:24:30,187

518
00:24:30,187 --> 00:24:32,520
ZAMYLA陈：嗯，希望
它仍然是种有益的。

519
00:24:32,520 --> 00:24:42,990

520
00:24:42,990 --> 00:24:45,634
你什么时候去
办公时间是什么？

521
00:24:45,634 --> 00:24:47,300
听众：我的TF有他们今天下午。

522
00:24:47,300 --> 00:24:47,966
ZAMYLA陈：哦。

523
00:24:47,966 --> 00:24:48,977
谁是你的TF？

524
00:24:48,977 --> 00:24:49,854

525
00:24:49,854 --> 00:24:51,020
听众：弗雷德[？ Wujaya？]。

526
00:24:51,020 --> 00:24:52,622

527
00:24:52,622 --> 00:24:54,080
ZAMYLA陈：有这么多的转录因子。

528
00:24:54,080 --> 00:24:55,350

529
00:24:55,350 --> 00:24:55,850
这么多。

530
00:24:55,850 --> 00:25:16,530

531
00:25:16,530 --> 00:25:17,340
行。

532
00:25:17,340 --> 00:25:45,310

533
00:25:45,310 --> 00:25:48,950
任何人有任何开始，我可以
记下我们要工作？

534
00:25:48,950 --> 00:25:53,770

535
00:25:53,770 --> 00:25:55,685
我假设指针
1用表。

536
00:25:55,685 --> 00:25:56,890

537
00:25:56,890 --> 00:25:57,610
去了。

538
00:25:57,610 --> 00:25:59,180
>> 听众：也许交换机之一。

539
00:25:59,180 --> 00:26:02,362

540
00:26:02,362 --> 00:26:03,445
ZAMYLA陈：所以12号？

541
00:26:03,445 --> 00:26:06,750

542
00:26:06,750 --> 00:26:10,770
我认为数字8和9很可能是
那些人想要走了过来。

543
00:26:10,770 --> 00:26:12,116
>> 听众：而10和11。

544
00:26:12,116 --> 00:26:21,860

545
00:26:21,860 --> 00:26:25,806
>> ZAMYLA陈：而且你们知道
你的笔记一页，对不对？

546
00:26:25,806 --> 00:26:28,450
>> 听众：是啊，所以什么
我们可以把上。

547
00:26:28,450 --> 00:26:30,658
>> ZAMYLA陈：你自己也可以
把你想要的任何东西。

548
00:26:30,658 --> 00:26:31,887

549
00:26:31,887 --> 00:26:32,720
并且它可以键入。

550
00:26:32,720 --> 00:26:35,270
据我记得，我们进行了类型化的。

551
00:26:35,270 --> 00:26:37,022
>> 听众：你可以做
背部和两侧？

552
00:26:37,022 --> 00:26:38,780
>> ZAMYLA陈：是啊，两侧。

553
00:26:38,780 --> 00:26:42,940
因此，像堆和
[？后端？]堆，你的跑步

554
00:26:42,940 --> 00:26:43,780
次。

555
00:26:43,780 --> 00:26:44,840
有用的。

556
00:26:44,840 --> 00:26:47,990
有关可能的小事
指针来提醒你。

557
00:26:47,990 --> 00:26:49,205
语法的东西。

558
00:26:49,205 --> 00:26:51,600

559
00:26:51,600 --> 00:26:54,830
其就像一个骨架
程序可超有用。

560
00:26:54,830 --> 00:27:00,719
我知道，我总是忘了什么
我应该写INT为主，

561
00:27:00,719 --> 00:27:03,010
因为我一直只是复制
我以前的P组贴

562
00:27:03,010 --> 00:27:06,232
或者它已经存在，所以
我从来没有真正写的，

563
00:27:06,232 --> 00:27:07,690
所以具有可超有用。

564
00:27:07,690 --> 00:27:09,280

565
00:27:09,280 --> 00:27:14,320
>> 好了，我们为什么不
先从8号呢？

566
00:27:14,320 --> 00:27:21,730

567
00:27:21,730 --> 00:27:22,810
行。

568
00:27:22,810 --> 00:27:23,310
行。

569
00:27:23,310 --> 00:27:25,060

570
00:27:25,060 --> 00:27:26,310
因此，考虑下面的程序。

571
00:27:26,310 --> 00:27:28,110

572
00:27:28,110 --> 00:27:30,700
当我们看到这么明显
指针，这可能

573
00:27:30,700 --> 00:27:32,200
一个好主意，开始绘制，对不对？

574
00:27:32,200 --> 00:27:34,552

575
00:27:34,552 --> 00:27:36,760
我想知道我所有的
大支粉笔去了。

576
00:27:36,760 --> 00:27:37,870
这是种烦人。

577
00:27:37,870 --> 00:27:40,210

578
00:27:40,210 --> 00:27:45,820
>> 所以，我们在这里的一些交换功能
那将采取两个指针。

579
00:27:45,820 --> 00:27:48,630
所以在这种情况下，它们
实际上应该是切换

580
00:27:48,630 --> 00:27:53,400
事情与我们原来的交换
函数，只用了复印件。

581
00:27:53,400 --> 00:27:57,030
那么，它会做的
is--让我们先从主，

582
00:27:57,030 --> 00:27:58,450
因为这是1。

583
00:27:58,450 --> 00:28:04,296
>> 因此，我们有一些INT×1。

584
00:28:04,296 --> 00:28:11,860
我们有一些Ÿ这等于2。

585
00:28:11,860 --> 00:28:14,390
然后我们有一些互换
那将采取这些。

586
00:28:14,390 --> 00:28:17,320
让我们看看我们是否在这里。

587
00:28:17,320 --> 00:28:19,542

588
00:28:19,542 --> 00:28:22,709
而在我们的table--哦男孩。

589
00:28:22,709 --> 00:28:23,792
我怎么做呢？

590
00:28:23,792 --> 00:28:25,900
我要吸取我的表在这里。

591
00:28:25,900 --> 00:28:49,490

592
00:28:49,490 --> 00:28:50,552
勉强使其存在。

593
00:28:50,552 --> 00:28:51,260
几乎没有做它。

594
00:28:51,260 --> 00:28:52,470

595
00:28:52,470 --> 00:28:57,960
1，2，3，4，5，6，7。

596
00:28:57,960 --> 00:29:11,220

597
00:29:11,220 --> 00:29:15,706
他们给我们1为1，1 2。

598
00:29:15,706 --> 00:29:16,206
凉爽。

599
00:29:16,206 --> 00:29:17,674

600
00:29:17,674 --> 00:29:18,174
真棒。

601
00:29:18,174 --> 00:29:19,650

602
00:29:19,650 --> 00:29:20,464
因此，3。

603
00:29:20,464 --> 00:29:21,380
这里面的[？一个1？]

604
00:29:21,380 --> 00:29:24,500

605
00:29:24,500 --> 00:29:25,250
>> 行。

606
00:29:25,250 --> 00:29:35,202
然后x的地址为0x123。

607
00:29:35,202 --> 00:29:41,260
而Y是Ox127。

608
00:29:41,260 --> 00:29:41,760
凉爽。

609
00:29:41,760 --> 00:29:42,940

610
00:29:42,940 --> 00:29:43,595
行。

611
00:29:43,595 --> 00:29:46,710
我希望你们在这方面努力
就只是like--工作

612
00:29:46,710 --> 00:29:48,385
与你周围的人。

613
00:29:48,385 --> 00:29:50,340
我想我已经说
当我成立。

614
00:29:50,340 --> 00:29:50,840
在它的工作。

615
00:29:50,840 --> 00:29:53,270
试图通过它的工作
自己一两分钟，

616
00:29:53,270 --> 00:29:54,930
然后我将它和你在一起。

617
00:29:54,930 --> 00:29:57,034

618
00:29:57,034 --> 00:30:00,117
因为你是真正的唯一途径
要学习就是做你自己。

619
00:30:00,117 --> 00:31:29,580

620
00:31:29,580 --> 00:31:30,110
别担心。

621
00:31:30,110 --> 00:31:30,610
祝好运。

622
00:31:30,610 --> 00:32:17,390

623
00:32:17,390 --> 00:32:20,030
>> OK，我们为什么不慢
开始通过这个工作。

624
00:32:20,030 --> 00:32:23,695
因此，每个人都盯着一行，x为1。

625
00:32:23,695 --> 00:32:26,860
2行后中，x和
y是1和2，对吧？

626
00:32:26,860 --> 00:32:27,400
凉爽。

627
00:32:27,400 --> 00:32:30,310
所以三线是哪里的东西
获得有趣的课程。

628
00:32:30,310 --> 00:32:34,970
>> 因此，我们在这里所做的
是我们现在已经交换。

629
00:32:34,970 --> 00:32:42,360
我们说的x和y有那些点
或者它们具有x和y的地址，

630
00:32:42,360 --> 00:32:43,390
对不对？

631
00:32:43,390 --> 00:32:48,451
所以在这种情况下，三个
什么是a的值？

632
00:32:48,451 --> 00:32:52,379

633
00:32:52,379 --> 00:32:59,806
一个已经通过了，已经给出
x的地址值，对不对？

634
00:32:59,806 --> 00:33:02,542

635
00:33:02,542 --> 00:33:03,454
>> 听众：1？

636
00:33:03,454 --> 00:33:05,200
>> ZAMYLA陈：所以我们把它添加到X？

637
00:33:05,200 --> 00:33:06,420
什么是X的地址？

638
00:33:06,420 --> 00:33:07,212
>> 听众：0x123的。

639
00:33:07,212 --> 00:33:08,087
>> ZAMYLA陈：没错。

640
00:33:08,087 --> 00:33:13,960

641
00:33:13,960 --> 00:33:16,790
但究竟什么是真正指向？

642
00:33:16,790 --> 00:33:20,790
如果我们取消引用，
什么样的价值会不会得到。

643
00:33:20,790 --> 00:33:21,290
听众：1。

644
00:33:21,290 --> 00:33:23,164
ZAMYLA陈：那就
给我们1，原因是什么

645
00:33:23,164 --> 00:33:27,810
我们说是去这个
地址告诉我们的价值是什么。

646
00:33:27,810 --> 00:33:28,890
那么，什么将B？

647
00:33:28,890 --> 00:33:30,500

648
00:33:30,500 --> 00:33:31,445
>> 听众：0x127。

649
00:33:31,445 --> 00:33:32,320
ZAMYLA陈：没错。

650
00:33:32,320 --> 00:33:33,610

651
00:33:33,610 --> 00:33:35,410
所以它的y的地址。

652
00:33:35,410 --> 00:33:36,580

653
00:33:36,580 --> 00:33:39,811
然后呢[？提领？ ？]

654
00:33:39,811 --> 00:33:40,310
听众：2。

655
00:33:40,310 --> 00:33:42,172

656
00:33:42,172 --> 00:33:43,380
ZAMYLA陈：好了，现在4。

657
00:33:43,380 --> 00:33:44,390

658
00:33:44,390 --> 00:33:51,300
我们说一个是equal--现在好了，我们已经
做整型温度等于一个明星。

659
00:33:51,300 --> 00:33:53,580
那么什么样的变化？

660
00:33:53,580 --> 00:33:55,680
这里只有一件事
改变在这里。

661
00:33:55,680 --> 00:33:56,180
它是什么？

662
00:33:56,180 --> 00:33:57,892

663
00:33:57,892 --> 00:33:58,624
>> 听众：温度。

664
00:33:58,624 --> 00:33:59,540
ZAMYLA陈：临时。

665
00:33:59,540 --> 00:34:06,120
因此，我们可以重写所有这些。

666
00:34:06,120 --> 00:34:07,790

667
00:34:07,790 --> 00:34:10,690
这些一个好的策略
刚刚搞清楚

668
00:34:10,690 --> 00:34:14,050
什么样的变化，因为最常见
这里只有一件事，就是

669
00:34:14,050 --> 00:34:16,300
要改变在任何给定的点，好不好？

670
00:34:16,300 --> 00:34:17,960

671
00:34:17,960 --> 00:34:20,100
因此，我们已经临时指派。

672
00:34:20,100 --> 00:34:26,929
>> 现在，我们的下一个点，五，我们
取得明星等于星级的住宿。

673
00:34:26,929 --> 00:34:28,880
还等什么，现在的变化？

674
00:34:28,880 --> 00:34:29,760
>> 听众：一星。

675
00:34:29,760 --> 00:34:32,081
>> ZAMYLA陈：一星，所以
一切保持不变。

676
00:34:32,081 --> 00:34:38,610

677
00:34:38,610 --> 00:34:39,900
又是什么明星一个平等的？

678
00:34:39,900 --> 00:34:40,659
>> 听众：2。

679
00:34:40,659 --> 00:34:41,283
ZAMYLA陈：2。

680
00:34:41,283 --> 00:34:42,460

681
00:34:42,460 --> 00:34:42,960
可爱的。

682
00:34:42,960 --> 00:34:45,360

683
00:34:45,360 --> 00:34:46,239
真棒。

684
00:34:46,239 --> 00:34:51,190
OK，然后现在我们有
开始b等于温度。

685
00:34:51,190 --> 00:34:53,907
所以，唯一的变化是星级的住宿。

686
00:34:53,907 --> 00:34:55,344
其他一切保持不变。

687
00:34:55,344 --> 00:35:01,100

688
00:35:01,100 --> 00:35:02,610
什么是明星B等于现在呢？

689
00:35:02,610 --> 00:35:04,840

690
00:35:04,840 --> 00:35:06,190
你已经完成了表。

691
00:35:06,190 --> 00:35:11,620

692
00:35:11,620 --> 00:35:18,460
因为现在到了最后，如果说X
和y，我们知道，在这个point--

693
00:35:18,460 --> 00:35:23,060
我们知道，当我们
改一星2，

694
00:35:23,060 --> 00:35:29,620
它说，这是什么做的还算可以，
地址为0x123这里，改变它。

695
00:35:29,620 --> 00:35:31,780

696
00:35:31,780 --> 00:35:33,290
现在，这是2。

697
00:35:33,290 --> 00:35:34,460

698
00:35:34,460 --> 00:35:40,600
然后在这一点上，
我们说好了，去星级的住宿。

699
00:35:40,600 --> 00:35:45,305
所以去的地址在
0x127，并使其成为1。

700
00:35:45,305 --> 00:35:49,670

701
00:35:49,670 --> 00:35:53,110
所以，现在在非常时候结束
我们实际上回归了主，

702
00:35:53,110 --> 00:35:56,445
我们其实有x是
等于2且y等于1。

703
00:35:56,445 --> 00:35:58,500

704
00:35:58,500 --> 00:35:59,500
每个人都好有吗？

705
00:35:59,500 --> 00:36:00,720

706
00:36:00,720 --> 00:36:02,320
OK，爽。

707
00:36:02,320 --> 00:36:04,030
9号。

708
00:36:04,030 --> 00:36:05,950
你们在这方面努力。

709
00:36:05,950 --> 00:36:09,016
我要成立一个董事会
因此，我们可以通过它借鉴。

710
00:36:09,016 --> 00:36:09,910
这将是一个爆炸。

711
00:36:09,910 --> 00:36:13,760

712
00:36:13,760 --> 00:36:16,320
大表可以是
真正可怕的，我知道。

713
00:36:16,320 --> 00:36:19,910
但如果你只是把他们一行
一时间，他们得到少了很多可怕的。

714
00:36:19,910 --> 00:38:12,025

715
00:38:12,025 --> 00:38:12,860
行。

716
00:38:12,860 --> 00:38:16,230

717
00:38:16,230 --> 00:38:21,190
>> 所以，你知道，这将有
通过主首先，对到哪里去了？

718
00:38:21,190 --> 00:38:24,140
x和y初始化和
然后尝试交换它们。

719
00:38:24,140 --> 00:38:28,560
因此，即使是掉上面的，真正的方式，
那张是，我们正在经历为主，

720
00:38:28,560 --> 00:38:31,040
然后它调用
高达掉，好吗？

721
00:38:31,040 --> 00:38:32,810
因此，每个人都知道这一点。

722
00:38:32,810 --> 00:38:34,960
>> 那么，哪一个你
男人想下手？

723
00:38:34,960 --> 00:38:37,240
有没有人真的知道
关于其中之一？

724
00:38:37,240 --> 00:38:38,307

725
00:38:38,307 --> 00:38:39,265
甚至部分吗？

726
00:38:39,265 --> 00:38:44,170

727
00:38:44,170 --> 00:38:48,120
为什么我们不使用X开始？

728
00:38:48,120 --> 00:38:49,060
什么是我们认为X是？

729
00:38:49,060 --> 00:38:49,735
>> 听众：1。

730
00:38:49,735 --> 00:38:50,360
ZAMYLA陈：1。

731
00:38:50,360 --> 00:38:54,500

732
00:38:54,500 --> 00:38:56,340
那么，为什么是2。

733
00:38:56,340 --> 00:38:58,880

734
00:38:58,880 --> 00:39:01,380
而这是因为
这里的区别很大

735
00:39:01,380 --> 00:39:04,890
是我们唯一
通过副本，对不对？

736
00:39:04,890 --> 00:39:06,520
我们不通过引用传递。

737
00:39:06,520 --> 00:39:08,850
因此，即使在结束时
这一计划的x和y

738
00:39:08,850 --> 00:39:14,170
住一样的，因为他们
只是副本中的交换功能。

739
00:39:14,170 --> 00:39:16,320
他们没有真正改变，对不对？

740
00:39:16,320 --> 00:39:17,570

741
00:39:17,570 --> 00:39:19,290
>> 那么，关于A，B，和温度？

742
00:39:19,290 --> 00:39:21,540

743
00:39:21,540 --> 00:39:22,890
>> 听众：A是B。

744
00:39:22,890 --> 00:39:23,940
>> ZAMYLA陈：A是B。

745
00:39:23,940 --> 00:39:28,569
所以在这种情况下，为
x，它是1，对不对？

746
00:39:28,569 --> 00:39:29,860
所以在这里，我们通过它走。

747
00:39:29,860 --> 00:39:33,940
所以，在开始时，一个与
b是1和2和不确定的。

748
00:39:33,940 --> 00:39:35,000

749
00:39:35,000 --> 00:39:40,850
所以，最初的临时变
分配到一个，所以温度是1。

750
00:39:40,850 --> 00:39:46,150
一个等于b，那么我们得到
2，和b等于温度。

751
00:39:46,150 --> 00:39:47,284
现在，我们得到1。

752
00:39:47,284 --> 00:39:49,454

753
00:39:49,454 --> 00:39:55,860
>> 听众：在上一个其
交换符号x和符号年。

754
00:39:55,860 --> 00:39:57,390
究竟是什么意思呢？

755
00:39:57,390 --> 00:39:59,890
ZAMYLA陈：所以这意味着，
你是通过引用传递。

756
00:39:59,890 --> 00:40:03,830
因此，这意味着你实际上
通过在那里的地址

757
00:40:03,830 --> 00:40:04,814
x和y的存储位置。

758
00:40:04,814 --> 00:40:06,730
听众：但是你不
换地址。

759
00:40:06,730 --> 00:40:07,860
ZAMYLA陈：你不是
换地址。

760
00:40:07,860 --> 00:40:10,015
你换什么在其中。

761
00:40:10,015 --> 00:40:11,510

762
00:40:11,510 --> 00:40:14,460
比如什么是在这个地址，
这就是为什么它的工作原理。

763
00:40:14,460 --> 00:40:20,750
与这一计划在这里是什么
你做的是你要创建的副本。

764
00:40:20,750 --> 00:40:27,440
所以，你有存在的x和y
作为自己的变量在这里。

765
00:40:27,440 --> 00:40:31,530

766
00:40:31,530 --> 00:40:34,140
但是当你通过
这些掉期，它的

767
00:40:34,140 --> 00:40:38,090
因为如果你正在创建
这完全是另外一套。

768
00:40:38,090 --> 00:40:41,272
所以你从来没有真正
动人的x和y。

769
00:40:41,272 --> 00:40:46,890
>> 听众：如果符号X是什么东西在
x的地址，你会出演X是什么？

770
00:40:46,890 --> 00:40:53,290
>> ZAMYLA陈：与号x是什么时
x的地址，然后star--好，

771
00:40:53,290 --> 00:40:54,950
在这种情况下，x不是指针。

772
00:40:54,950 --> 00:40:56,332

773
00:40:56,332 --> 00:40:57,040
听众：哦，好吧。

774
00:40:57,040 --> 00:40:58,998
所以，你只能这样做
因为它不是一个指针。

775
00:40:58,998 --> 00:40:59,890
ZAMYLA陈：对。

776
00:40:59,890 --> 00:41:03,046
你只能做明星
东西是一个指针。

777
00:41:03,046 --> 00:41:05,920
也许你可以做的事情了
都没有，但编译您

778
00:41:05,920 --> 00:41:07,350
做疯狂的事情会发生。

779
00:41:07,350 --> 00:41:09,570
而且我不完全
肯定会发生什么。

780
00:41:09,570 --> 00:41:11,880
您可以随时拿
东西地址，

781
00:41:11,880 --> 00:41:14,255
但你不能提领
东西是不是一个指针。

782
00:41:14,255 --> 00:41:14,805

783
00:41:14,805 --> 00:41:17,860
如果是有道理的，这是
一个很好的区分有。

784
00:41:17,860 --> 00:41:19,870

785
00:41:19,870 --> 00:41:21,340
>> 所以不是太糟糕，不是吗？

786
00:41:21,340 --> 00:41:23,650
该表是希望
让略少吓人。

787
00:41:23,650 --> 00:41:25,450

788
00:41:25,450 --> 00:41:26,690
行。

789
00:41:26,690 --> 00:41:28,370
啊，好玩的。

790
00:41:28,370 --> 00:41:31,265
所以，现在，写自己的代码。

791
00:41:31,265 --> 00:41:33,640

792
00:41:33,640 --> 00:41:37,950
所以我打算让你们的工作
在此约4分钟，

793
00:41:37,950 --> 00:41:41,480
然后我们可以谈谈
约的方式接近它。

794
00:41:41,480 --> 00:41:45,080

795
00:41:45,080 --> 00:41:47,110
随意交谈的人在你身边。

796
00:41:47,110 --> 00:41:48,114

797
00:41:48,114 --> 00:41:49,155
另外，这是有意思的。

798
00:41:49,155 --> 00:41:51,460
这就像一个所有女孩
部分现在。

799
00:41:51,460 --> 00:41:52,190
非常令人兴奋。

800
00:41:52,190 --> 00:41:53,310

801
00:41:53,310 --> 00:41:54,502
除了张。

802
00:41:54,502 --> 00:41:56,190
但张是不是真的一节的一部分。

803
00:41:56,190 --> 00:42:17,282

804
00:42:17,282 --> 00:42:17,985
真棒。

805
00:42:17,985 --> 00:42:18,485
完美的。

806
00:42:18,485 --> 00:42:38,059

807
00:42:38,059 --> 00:42:39,475
所以，我会给你几个提示。

808
00:42:39,475 --> 00:42:43,450

809
00:42:43,450 --> 00:42:46,890
当你有这样
多个字符，其中

810
00:42:46,890 --> 00:42:49,990
你有别的东西
像123或1000的东西，

811
00:42:49,990 --> 00:42:53,790
需要能够循环
通过和每个转换那些。

812
00:42:53,790 --> 00:42:55,340

813
00:42:55,340 --> 00:42:58,699
因此，有一对夫妇
你如何能做到这一点，

814
00:42:58,699 --> 00:43:01,740
但你肯定会拥有
一个for循环的地方在那里循环

815
00:43:01,740 --> 00:43:05,150
通过它们，这是
有点像赠品

816
00:43:05,150 --> 00:43:09,540
即使你调用strlen用，
哪一种是喜欢哦

817
00:43:09,540 --> 00:43:12,418
也许你要使用的长度
字符串中的一些方式。

818
00:43:12,418 --> 00:45:17,300

819
00:45:17,300 --> 00:45:17,829
>> 行。

820
00:45:17,829 --> 00:45:20,870
那么，你们认为可能是
我们想要做的第一件事情之一？

821
00:45:20,870 --> 00:45:23,149

822
00:45:23,149 --> 00:45:25,690
有一对夫妇的情况下在这里
我们需要考虑到，对不对？

823
00:45:25,690 --> 00:45:27,360
无论我们有什么事情，就是空。

824
00:45:27,360 --> 00:45:28,685

825
00:45:28,685 --> 00:45:30,383
我们有什么？

826
00:45:30,383 --> 00:45:30,882
个案。

827
00:45:30,882 --> 00:45:32,760

828
00:45:32,760 --> 00:45:33,260
空。

829
00:45:33,260 --> 00:45:34,400

830
00:45:34,400 --> 00:45:42,414
我们认为其具有壳体
东西比09之外，对不对？

831
00:45:42,414 --> 00:45:43,580
所以我们可以说有字母。

832
00:45:43,580 --> 00:45:44,900

833
00:45:44,900 --> 00:45:46,510
或者我们这是合法的情况下。

834
00:45:46,510 --> 00:45:48,450

835
00:45:48,450 --> 00:45:50,130
三种情况下想到的。

836
00:45:50,130 --> 00:45:53,527
那么，哪一个你认为可能是
一个最简单的采取先照顾？

837
00:45:53,527 --> 00:45:54,152
听众：空。

838
00:45:54,152 --> 00:45:55,527
ZAMYLA陈：此案为null。

839
00:45:55,527 --> 00:45:56,610
那么我们该怎么办呢？

840
00:45:56,610 --> 00:45:57,954

841
00:45:57,954 --> 00:45:58,870
听众：[听不清]。

842
00:45:58,870 --> 00:46:02,434

843
00:46:02,434 --> 00:46:03,184
ZAMYLA陈：是的。

844
00:46:03,184 --> 00:46:05,140

845
00:46:05,140 --> 00:46:06,550
什么做我想做的事？

846
00:46:06,550 --> 00:46:07,341
>> 听众：返回0。

847
00:46:07,341 --> 00:46:07,935

848
00:46:07,935 --> 00:46:09,110
>> ZAMYLA陈：没错。

849
00:46:09,110 --> 00:46:09,860
真棒。

850
00:46:09,860 --> 00:46:10,640
行。

851
00:46:10,640 --> 00:46:15,270
所以，现在情况有信
和的情况下，它是有效的。

852
00:46:15,270 --> 00:46:19,140
实际上，我们可以照顾
在一个循环的这个，好不好？

853
00:46:19,140 --> 00:46:22,710
因此从另一个角度做它 - 可能是什么
一个简单的方法来检查它是否有效。

854
00:46:22,710 --> 00:46:25,150

855
00:46:25,150 --> 00:46:29,144
我们将不得不通过
每一个字母，做什么？

856
00:46:29,144 --> 00:46:34,336

857
00:46:34,336 --> 00:46:35,640
>> 听众：检查是否是in--

858
00:46:35,640 --> 00:46:39,570
>> ZAMYLA陈：对，你可以检查
如果是0到9之间，对不对？

859
00:46:39,570 --> 00:46:40,880

860
00:46:40,880 --> 00:46:42,700
然后在该情况下
它是有效的，我们

861
00:46:42,700 --> 00:46:46,550
去年底，通过迭代
我们的字符串反正，对不对？

862
00:46:46,550 --> 00:46:48,690
那么，为什么我们不尝试
它们合并成一个。

863
00:46:48,690 --> 00:46:51,260
我们要遍历
通过了字符串，并作为我们

864
00:46:51,260 --> 00:46:56,400
做到这一点，我们将第一
做一个检查，如果那封信看

865
00:46:56,400 --> 00:46:58,110
或者，如果该字符是有效的。

866
00:46:58,110 --> 00:47:02,150
如果是，我们要执行
操作时，我们需要将其转换。

867
00:47:02,150 --> 00:47:05,050
否则，将返回0，对不对？

868
00:47:05,050 --> 00:47:09,160
>> 所以，在我们这样做，我们
可能需要一些变量

869
00:47:09,160 --> 00:47:12,820
我们可以在端返回
这将是我们的实际值。

870
00:47:12,820 --> 00:47:17,005
所以，我们要初始化
些值是0。

871
00:47:17,005 --> 00:47:18,390
而这仅仅是我们如何开始。

872
00:47:18,390 --> 00:47:22,452

873
00:47:22,452 --> 00:47:23,785
所以，我要摆脱这一点。

874
00:47:23,785 --> 00:47:26,750

875
00:47:26,750 --> 00:47:30,489
那么我们如何去
遍历这个字符串。

876
00:47:30,489 --> 00:47:31,280
顾客：循环。

877
00:47:31,280 --> 00:47:32,280
ZAMYLA陈：一个for循环。

878
00:47:32,280 --> 00:47:33,160
那么，什么是我们的？

879
00:47:33,160 --> 00:47:34,710

880
00:47:34,710 --> 00:47:35,909
>> 观众：我是0。

881
00:47:35,909 --> 00:47:36,700
ZAMYLA陈：嗯。

882
00:47:36,700 --> 00:47:38,620

883
00:47:38,620 --> 00:47:41,180
什么是我们迭代，直到？

884
00:47:41,180 --> 00:47:42,450
>> 听众：第STR长度。

885
00:47:42,450 --> 00:47:47,920

886
00:47:47,920 --> 00:47:50,900
>> ZAMYLA陈：好了，现在还记得
还有一个更好的方法。 [听不清]。

887
00:47:50,900 --> 00:47:52,935
>> 听众：是的，我们能做到n等于。

888
00:47:52,935 --> 00:47:53,810
ZAMYLA陈：没错。

889
00:47:53,810 --> 00:47:55,010

890
00:47:55,010 --> 00:47:56,190
>> 观众：我是小于n。

891
00:47:56,190 --> 00:47:57,559

892
00:47:57,559 --> 00:47:59,475
ZAMYLA陈：为什么
将我们想要做的是什么？

893
00:47:59,475 --> 00:48:00,815

894
00:48:00,815 --> 00:48:01,940
你还记得原因吗？

895
00:48:01,940 --> 00:48:04,180

896
00:48:04,180 --> 00:48:05,680
听众：我们必须重新计算。

897
00:48:05,680 --> 00:48:08,735
ZAMYLA陈：Becasue这样你
只需要计算strlen的一次。

898
00:48:08,735 --> 00:48:09,750

899
00:48:09,750 --> 00:48:14,400
如果你这样做我是小于的strlen
S，这意味着它会重新计算

900
00:48:14,400 --> 00:48:17,050
每时间长度
您运行的for循环，

901
00:48:17,050 --> 00:48:20,800
这是不是一个巨大的成本
能源，但它的

902
00:48:20,800 --> 00:48:24,280
更好的做法，试图
做一次这样的事情。

903
00:48:24,280 --> 00:48:27,610
除非也许你有一个疯狂的字符串
这是不断变化的，在每一次迭代。

904
00:48:27,610 --> 00:48:30,371
但是，如果它保持相同，保存。

905
00:48:30,371 --> 00:48:30,870
行。

906
00:48:30,870 --> 00:48:33,430
然后我加再加。

907
00:48:33,430 --> 00:48:34,040
真棒。

908
00:48:34,040 --> 00:48:35,789
我们对我们的方式。

909
00:48:35,789 --> 00:48:36,830
听众：真的很快。

910
00:48:36,830 --> 00:48:39,600
首先，让我们说，我们只是
确实比第strlen的少我，

911
00:48:39,600 --> 00:48:42,175
他们是我们的分级设计
在所有或正确性？

912
00:48:42,175 --> 00:48:43,640

913
00:48:43,640 --> 00:48:44,610
他们不是。

914
00:48:44,610 --> 00:48:47,920
我们对分级的正确性
对于测验，据我所知。

915
00:48:47,920 --> 00:48:52,670
我不能让一个完整的
保证，但在大多数情况下，

916
00:48:52,670 --> 00:48:57,060
绝大多数是正确的，因为
你是下了很大的时间限制的。

917
00:48:57,060 --> 00:48:59,704
设计通常是指
你有时间去思考

918
00:48:59,704 --> 00:49:01,245
关于你的情况的风采。

919
00:49:01,245 --> 00:49:03,710

920
00:49:03,710 --> 00:49:05,770
>> 好了，我们正在通过迭代。

921
00:49:05,770 --> 00:49:10,640
因此，我们需要两种检查
看看这个字符是有效的

922
00:49:10,640 --> 00:49:14,550
或者，如果我们能够履行我们
正常的[？ A至I？]功能。

923
00:49:14,550 --> 00:49:16,600
我们担心什么
即在一秒钟。

924
00:49:16,600 --> 00:49:19,340
那么，为什么我们不take--
如果任何人都可以想

925
00:49:19,340 --> 00:49:21,930
约的方式来检查
查看这是否是有效的。

926
00:49:21,930 --> 00:49:23,346

927
00:49:23,346 --> 00:49:25,740
我们知道这将是
如果某些条件下，对​​吧？

928
00:49:25,740 --> 00:49:26,830

929
00:49:26,830 --> 00:49:32,300
请记住，这是
在ASCII码，因此如何可能

930
00:49:32,300 --> 00:49:37,359
我们看到，如果它不是0,1，
2，3，4，5，6，7，8，或9。

931
00:49:37,359 --> 00:49:38,150
听众：如果字母。

932
00:49:38,150 --> 00:49:39,800

933
00:49:39,800 --> 00:49:44,100
>> ZAMYLA陈：所以，如果将阿尔法
只是让我们知道，如果它是一个字母。

934
00:49:44,100 --> 00:49:47,810
如果他们给我们一个象征，它的
还是不太去检查。

935
00:49:47,810 --> 00:49:54,270
所以，如果你拉你的ASCII
表中，我们知道，从0到9

936
00:49:54,270 --> 00:49:55,340
是在一个段中。

937
00:49:55,340 --> 00:49:57,560

938
00:49:57,560 --> 00:50:00,540
请告诉我这些数字，他们
对应于可能的话。

939
00:50:00,540 --> 00:50:08,136

940
00:50:08,136 --> 00:50:08,677
听众：40。

941
00:50:08,677 --> 00:50:11,440

942
00:50:11,440 --> 00:50:13,714
>> ZAMYLA陈：所以范围是喜欢40--

943
00:50:13,714 --> 00:50:14,380
听众：也许吧。

944
00:50:14,380 --> 00:50:16,110

945
00:50:16,110 --> 00:50:16,765
48至57。

946
00:50:16,765 --> 00:50:17,430
我不知道。

947
00:50:17,430 --> 00:50:18,510
>> ZAMYLA陈：40〜57？

948
00:50:18,510 --> 00:50:19,426
>> 听众：48，我想。

949
00:50:19,426 --> 00:50:20,730
ZAMYLA陈：48〜57。

950
00:50:20,730 --> 00:50:26,070
所以我们知道，那些ASCII
symbols--如果ASCII值不

951
00:50:26,070 --> 00:50:29,940
48至57，
它不是有效的，对不对？

952
00:50:29,940 --> 00:50:32,050
所以，我们可以用它来
我们的优势可能？

953
00:50:32,050 --> 00:50:33,770

954
00:50:33,770 --> 00:50:38,082
我们如何获得
这封信，第一关？

955
00:50:38,082 --> 00:50:40,910
我们如何访问
这个这个角色？

956
00:50:40,910 --> 00:50:42,010
>> 听众：■支架我。

957
00:50:42,010 --> 00:50:42,801
>> ZAMYLA陈：嗯。

958
00:50:42,801 --> 00:50:43,790

959
00:50:43,790 --> 00:50:46,285
因为我们能想到的
作为字符串数组，记住了。

960
00:50:46,285 --> 00:50:47,470

961
00:50:47,470 --> 00:50:48,740
那么，我们想说的？

962
00:50:48,740 --> 00:50:55,920
我们想，如果这样说的
is--我会给你一个提示。

963
00:50:55,920 --> 00:50:56,920
这是一个小于。

964
00:50:56,920 --> 00:50:58,711
什么你认为它
需要小于？

965
00:50:58,711 --> 00:50:59,074

966
00:50:59,074 --> 00:50:59,615
听众：57？

967
00:50:59,615 --> 00:51:01,550

968
00:51:01,550 --> 00:51:02,900
>> ZAMYLA陈：47，对不对？

969
00:51:02,900 --> 00:51:08,920
但它也代表了您一个0
在单[？辐条？]，因为这是

970
00:51:08,920 --> 00:51:09,689
字符0。

971
00:51:09,689 --> 00:51:10,605
你也可以把47。

972
00:51:10,605 --> 00:51:11,660

973
00:51:11,660 --> 00:51:14,350
具有ASCII表，如
你看到的，只是一些

974
00:51:14,350 --> 00:51:18,580
你应该对你的测验表。

975
00:51:18,580 --> 00:51:25,830
>> 因此，如果是这样的话，如果它是一个
比0--不见得少。

976
00:51:25,830 --> 00:51:30,890
它只有两种将是
小于或大于9。

977
00:51:30,890 --> 00:51:33,055
所以，你可以填写这最后给我吗？

978
00:51:33,055 --> 00:51:36,440
所以，还是I S是什么，雷亚？

979
00:51:36,440 --> 00:51:39,810

980
00:51:39,810 --> 00:51:41,536
>> 听众：大于9。

981
00:51:41,536 --> 00:51:42,970

982
00:51:42,970 --> 00:51:44,221
>> ZAMYLA陈：有。

983
00:51:44,221 --> 00:51:47,280
这是否有意义
大家好，我们是如何到达那里？

984
00:51:47,280 --> 00:51:51,340
这些问题，他们就像一旦你
看到的解决方案，它就像哦，OK。

985
00:51:51,340 --> 00:51:52,312

986
00:51:52,312 --> 00:51:53,937
这就是为什么练习会帮助你。

987
00:51:53,937 --> 00:51:55,070

988
00:51:55,070 --> 00:51:57,400
好了，我们返回0。

989
00:51:57,400 --> 00:51:57,900
可爱的。

990
00:51:57,900 --> 00:51:59,000

991
00:51:59,000 --> 00:51:59,670
行。

992
00:51:59,670 --> 00:52:00,780

993
00:52:00,780 --> 00:52:02,365
否则，我们怎么想干什么？

994
00:52:02,365 --> 00:52:04,640
这是最有趣的部分
它是一个多一点

995
00:52:04,640 --> 00:52:07,550
喜欢数学与CS在我看来。

996
00:52:07,550 --> 00:52:09,479

997
00:52:09,479 --> 00:52:11,520
没有任何人有一个想法
对我们如何做到这一点？

998
00:52:11,520 --> 00:52:15,822

999
00:52:15,822 --> 00:52:18,155
因此，重要的是要
意识到的是第一个字符

1000
00:52:18,155 --> 00:52:21,510
我们正在采取将是
最高阶位的，对不对？

1001
00:52:21,510 --> 00:52:25,975
所以，如果我们正在寻找转换
123，我们第一次迭代

1002
00:52:25,975 --> 00:52:30,800
是将是1，但是我们需要
这是100到底对不对？

1003
00:52:30,800 --> 00:52:34,450
所以，有一件事你可以做的是，
与以后每位数

1004
00:52:34,450 --> 00:52:39,670
你拿，你乘以10的数值，
使得由一次到达终点，

1005
00:52:39,670 --> 00:52:42,960
一切都已经
向上移动，对不对？

1006
00:52:42,960 --> 00:52:46,490
>> 所以第一次运行
它，你有1作为你的价值。

1007
00:52:46,490 --> 00:52:50,370
第二次你运行它，你
乘以10的数值。

1008
00:52:50,370 --> 00:52:55,180
所以，它现在将更新
10，你加你的下一个值。

1009
00:52:55,180 --> 00:52:57,830
然后乘上
10，添加你的下一个值。

1010
00:52:57,830 --> 00:53:01,880
这就是为什么他们这么一说
更像测试

1011
00:53:01,880 --> 00:53:06,920
数学算法与
CS，但我离题。

1012
00:53:06,920 --> 00:53:08,080
我不写测验。

1013
00:53:08,080 --> 00:53:13,520
>> 所以，有一件事我们可以做的是我们
说值倍等于10。

1014
00:53:13,520 --> 00:53:16,630
所以，这是怎么回事转移
每一天，你的数字。

1015
00:53:16,630 --> 00:53:18,770

1016
00:53:18,770 --> 00:53:20,915
然后，我们只想补充。

1017
00:53:20,915 --> 00:53:22,070

1018
00:53:22,070 --> 00:53:24,290
我们希望在加什么
我们刚刚得到的，对不对？

1019
00:53:24,290 --> 00:53:25,350

1020
00:53:25,350 --> 00:53:31,649
那么，如何才能真正转变我们
ASCII字符插入数字

1021
00:53:31,649 --> 00:53:32,440
它代表？

1022
00:53:32,440 --> 00:53:37,680

1023
00:53:37,680 --> 00:53:40,800
>> 所以我们知道，0等于47，对不对？

1024
00:53:40,800 --> 00:53:44,260
所以，如果0是47，是什么
就我们所要做的吧

1025
00:53:44,260 --> 00:53:47,376
实际上使其成为0的int？

1026
00:53:47,376 --> 00:53:48,384
>> 听众：这是48。

1027
00:53:48,384 --> 00:53:49,050
ZAMYLA陈：48？

1028
00:53:49,050 --> 00:53:49,550
抱歉。

1029
00:53:49,550 --> 00:53:53,500

1030
00:53:53,500 --> 00:53:55,100
我们将减去48，对不对？

1031
00:53:55,100 --> 00:53:58,580

1032
00:53:58,580 --> 00:53:59,550
还记得ASCII数学？

1033
00:53:59,550 --> 00:54:01,565
我们只是把它们
像正常的数字。

1034
00:54:01,565 --> 00:54:02,570

1035
00:54:02,570 --> 00:54:05,900
如果你像对待数字，
他们成为有效的数字。

1036
00:54:05,900 --> 00:54:10,410
所以，如果我们有I S，这让我们
说，在这种情况下等于0。

1037
00:54:10,410 --> 00:54:14,420
第i在这种情况下，以便s
将是ASCII--

1038
00:54:14,420 --> 00:54:16,675
ASCII码int作为这将是47。

1039
00:54:16,675 --> 00:54:17,750

1040
00:54:17,750 --> 00:54:19,875
因此，我们可以subtract--或48。

1041
00:54:19,875 --> 00:54:20,930

1042
00:54:20,930 --> 00:54:22,440
你可以做到这一点，是一种方法。

1043
00:54:22,440 --> 00:54:25,125
有谁知道一个更好的
这样，我们可以做48？

1044
00:54:25,125 --> 00:54:27,220

1045
00:54:27,220 --> 00:54:31,608
我们刚才说的0 is--进入
ASCII码，你可以做报价。

1046
00:54:31,608 --> 00:54:39,740

1047
00:54:39,740 --> 00:54:43,160
所以不种它使
意识是如何工作的？

1048
00:54:43,160 --> 00:54:50,080
>> 听众：在这一点上，是值0
因为即使你乘以10，

1049
00:54:50,080 --> 00:54:53,340
你开始用零，
所以它应该被切换？

1050
00:54:53,340 --> 00:54:59,360
>> ZAMYLA陈：所以在这种情况下，你
希望在你添加到乘它，

1051
00:54:59,360 --> 00:55:06,650
因为在这种情况下，是的，它会
还是be--我指针丢失。

1052
00:55:06,650 --> 00:55:09,980
在这种情况下的值，所述第一
一次，我们运行将是零。

1053
00:55:09,980 --> 00:55:12,320
所以你只需添加
在这第一个数字。

1054
00:55:12,320 --> 00:55:15,930
下一次最重要的是
你迭代，要调换起来

1055
00:55:15,930 --> 00:55:18,722
你把你的下一个数字之前。

1056
00:55:18,722 --> 00:55:21,223
这是否澄清的吗？

1057
00:55:21,223 --> 00:55:21,723
行。

1058
00:55:21,723 --> 00:55:23,050

1059
00:55:23,050 --> 00:55:25,900
>> 有时候，你会
让更多的怪异MATHY的东西。

1060
00:55:25,900 --> 00:55:28,020

1061
00:55:28,020 --> 00:55:30,750
如果你有最
这一点，你还是会

1062
00:55:30,750 --> 00:55:32,610
以get--你要做的非常好。

1063
00:55:32,610 --> 00:55:35,150
部分信贷是一个很
大的事情上CS50测验。

1064
00:55:35,150 --> 00:55:36,270
所以写你知道什么。

1065
00:55:36,270 --> 00:55:39,640
如果你得到的一切
除了这里，你

1066
00:55:39,640 --> 00:55:41,390
还是打算做
很好的问题。

1067
00:55:41,390 --> 00:55:43,750
因为你有显示，
OK，我几乎知道。

1068
00:55:43,750 --> 00:55:45,570
我知道我需要遍历。

1069
00:55:45,570 --> 00:55:47,260
我知道我需要检查。

1070
00:55:47,260 --> 00:55:50,584
我只是不太
获得如何转换它。

1071
00:55:50,584 --> 00:55:51,500
你会好的。

1072
00:55:51,500 --> 00:55:52,850
是的，你要
失去了两分，

1073
00:55:52,850 --> 00:55:55,641
但你仍然会得到一个
东西分好多个

1074
00:55:55,641 --> 00:55:57,990
这样，如果你
失踪的这两条线。

1075
00:55:57,990 --> 00:56:00,660
我会是这样确定，此人
知道他们在做什么。

1076
00:56:00,660 --> 00:56:02,070
数学是很难的。

1077
00:56:02,070 --> 00:56:04,930
所以，我要说你会被罚款。

1078
00:56:04,930 --> 00:56:09,474
>> 好了，你们准备好
立即试用strlen的使用指针

1079
00:56:09,474 --> 00:56:10,890
那你们是指针的主人？

1080
00:56:10,890 --> 00:56:12,400

1081
00:56:12,400 --> 00:56:15,106
所以，我会让你们的工作
上一点点。

1082
00:56:15,106 --> 00:56:17,131

1083
00:56:17,131 --> 00:56:19,090
如果有人需要复习。

1084
00:56:19,090 --> 00:56:23,120

1085
00:56:23,120 --> 00:56:28,060
所以，你要使用指针
算术，然后如果s为null，

1086
00:56:28,060 --> 00:56:29,624
你的实现应该返回0。

1087
00:56:29,624 --> 00:56:37,045

1088
00:56:37,045 --> 00:56:39,670
像这样的事情，让你
真的很高兴只是调用strlen

1089
00:56:39,670 --> 00:56:40,586
在一天结束。

1090
00:56:40,586 --> 00:57:24,874

1091
00:57:24,874 --> 00:57:27,624
我觉得这个可能是有点
比最后一个，这容易

1092
00:57:27,624 --> 00:57:28,123
还是不错的。

1093
00:57:28,123 --> 00:58:51,789

1094
00:58:51,789 --> 00:58:55,690
我给你们一分钟，
然后，我们将努力通过它。

1095
00:58:55,690 --> 00:58:56,896

1096
00:58:56,896 --> 00:58:58,320
然后我们能去的交换机。

1097
00:58:58,320 --> 00:59:32,480

1098
00:59:32,480 --> 00:59:34,660
>> OK，准备家伙？

1099
00:59:34,660 --> 00:59:35,790

1100
00:59:35,790 --> 00:59:37,420
也许一点点。

1101
00:59:37,420 --> 00:59:40,210
所以，我已经给了你
两种选择，不是吗？

1102
00:59:40,210 --> 00:59:45,810
无论是检查空，如果返回0
它是，或实际计算的长度。

1103
00:59:45,810 --> 00:59:48,220
那么，谁愿意写检查空？

1104
00:59:48,220 --> 00:59:50,100

1105
00:59:50,100 --> 00:59:51,790
去了。

1106
00:59:51,790 --> 00:59:56,460
>> 听众：如果括号s
等于等于空返回0。

1107
00:59:56,460 --> 00:59:57,342

1108
00:59:57,342 --> 00:59:58,175
ZAMYLA陈：可爱。

1109
00:59:58,175 --> 00:59:59,350

1110
00:59:59,350 --> 01:00:02,320
我喜欢你一半的问题
只是检查空。

1111
01:00:02,320 --> 01:00:04,820
我知道跟你们最后
上周我当时想检查null

1112
01:00:04,820 --> 01:00:06,630
从字面上每一次。

1113
01:00:06,630 --> 01:00:07,510
OK，so--

1114
01:00:07,510 --> 01:00:08,716

1115
01:00:08,716 --> 01:00:12,750
>> 听众：如果返回0是只有一条线，
我们还需要在大括号？

1116
01:00:12,750 --> 01:00:15,860
>> ZAMYLA陈：在技术上不
需要他们，只要你是一致的。

1117
01:00:15,860 --> 01:00:19,240
这是很好的做法只是
取得的习惯

1118
01:00:19,240 --> 01:00:21,650
使用花括号，
但在技术上没有。

1119
01:00:21,650 --> 01:00:23,320
你不需要他们一行。

1120
01:00:23,320 --> 01:00:26,030
我们只是倾向于推荐
对于开始计划的人。

1121
01:00:26,030 --> 01:00:27,740

1122
01:00:27,740 --> 01:00:30,450
>> 所以，现在什么可能我们要在这里做？

1123
01:00:30,450 --> 01:00:32,222
所以，现在我们知道，我们的字符串是有效的。

1124
01:00:32,222 --> 01:00:33,680
我们要保持的计算长度。

1125
01:00:33,680 --> 01:00:35,620
什么是可能是第一个
我们想要做的事情吗？

1126
01:00:35,620 --> 01:00:38,770

1127
01:00:38,770 --> 01:00:41,276
>> 听众：创建
INT这就是长度。

1128
01:00:41,276 --> 01:00:42,150
ZAMYLA陈：没错。

1129
01:00:42,150 --> 01:00:43,450
听众：我们希望能够将其设置为？

1130
01:00:43,450 --> 01:00:44,210
ZAMYLA陈：0。

1131
01:00:44,210 --> 01:00:44,710
完美的。

1132
01:00:44,710 --> 01:00:46,050

1133
01:00:46,050 --> 01:00:47,290
行。

1134
01:00:47,290 --> 01:00:48,750
现在确实想做些什么？

1135
01:00:48,750 --> 01:00:50,000
这是真正的大头吧。

1136
01:00:50,000 --> 01:00:50,890
去了。

1137
01:00:50,890 --> 01:00:54,370
>> 听众：所以你可能会做一个for循环。

1138
01:00:54,370 --> 01:01:03,150
然后，因为当你打电话是你是
得到的第一件事情的地址，

1139
01:01:03,150 --> 01:01:05,660
你将开始与我等于0。

1140
01:01:05,660 --> 01:01:07,980

1141
01:01:07,980 --> 01:01:15,755
然后只要X
再加上我是不回斜线0。

1142
01:01:15,755 --> 01:01:17,130
ZAMYLA陈：空终结。

1143
01:01:17,130 --> 01:01:18,380
听众：空终结。

1144
01:01:18,380 --> 01:01:18,890

1145
01:01:18,890 --> 01:01:21,088
然后添加一个长度。

1146
01:01:21,088 --> 01:01:22,372
>> ZAMYLA陈：是的。

1147
01:01:22,372 --> 01:01:25,940
好了，让把那
到非常具体的代码。

1148
01:01:25,940 --> 01:01:27,537
但是，这是一个完美的主意。

1149
01:01:27,537 --> 01:01:28,870
这正是我们正在做的。

1150
01:01:28,870 --> 01:01:31,910
我们将要迭代
通过使用指针。

1151
01:01:31,910 --> 01:01:34,590
所以我们想要做的
是不是一个int

1152
01:01:34,590 --> 01:01:36,660
在这里，因为我们
不是指的它。

1153
01:01:36,660 --> 01:01:42,390
我们指的是一个开始
字符串，开始被一些地址，

1154
01:01:42,390 --> 01:01:43,300
对不对？

1155
01:01:43,300 --> 01:01:44,600
>> 所以，我们希望有一个指针。

1156
01:01:44,600 --> 01:01:47,610

1157
01:01:47,610 --> 01:01:52,310
因此，我们将有一些烧焦的明星，
因为它符合我们的对吗？

1158
01:01:52,310 --> 01:01:57,270
因此，这是一些点，我们正在初始化
字符串的开始，好不好？

1159
01:01:57,270 --> 01:01:58,949
因此，让我们叫它我。

1160
01:01:58,949 --> 01:02:01,740
如果是字符串的开始，
什么是将要分配给？

1161
01:02:01,740 --> 01:02:03,690

1162
01:02:03,690 --> 01:02:04,530
不为0。

1163
01:02:04,530 --> 01:02:06,238
我们希望它是
开始我们的字符串。

1164
01:02:06,238 --> 01:02:07,170

1165
01:02:07,170 --> 01:02:09,960
什么表示的起始
我们这是给我们的字符串？

1166
01:02:09,960 --> 01:02:10,800
>> 听众：刚才秒。

1167
01:02:10,800 --> 01:02:11,425
>> ZAMYLA陈：秒。

1168
01:02:11,425 --> 01:02:13,070

1169
01:02:13,070 --> 01:02:17,890
因此，这带来了一些新的指针
代表了我们的字符串的开始，好不好？

1170
01:02:17,890 --> 01:02:19,430

1171
01:02:19,430 --> 01:02:22,777
另一种方式把它
就像这里是我们的数组。

1172
01:02:22,777 --> 01:02:26,690
这就是我们的字符串，S。

1173
01:02:26,690 --> 01:02:28,650

1174
01:02:28,650 --> 01:02:32,400
所以我们可以说这是
第一点，这是为0x4。

1175
01:02:32,400 --> 01:02:34,400

1176
01:02:34,400 --> 01:02:34,900
04。

1177
01:02:34,900 --> 01:02:36,330

1178
01:02:36,330 --> 01:02:38,535
这是我们的S，其中包含该地址。

1179
01:02:38,535 --> 01:02:39,810

1180
01:02:39,810 --> 01:02:45,960
而我们刚刚创建另外一个名为
i的仅仅指的是同一件事。

1181
01:02:45,960 --> 01:02:49,437
所以，他们都只是指向
我们的字符串的开头。

1182
01:02:49,437 --> 01:02:51,020
这仅仅是一个图形表示。

1183
01:02:51,020 --> 01:02:53,830

1184
01:02:53,830 --> 01:02:57,100
>> 所以，现在我们要
做的是我们要遍历

1185
01:02:57,100 --> 01:03:02,040
我们的条件迭代
通过我们的字符串。

1186
01:03:02,040 --> 01:03:02,920
现在购物。

1187
01:03:02,920 --> 01:03:04,150
到了店，伙计们。

1188
01:03:04,150 --> 01:03:06,290

1189
01:03:06,290 --> 01:03:12,390
是我们要不断更新，直到
我们到达空终止，对不对？

1190
01:03:12,390 --> 01:03:14,930
那么，什么会是什么样子的？

1191
01:03:14,930 --> 01:03:17,760

1192
01:03:17,760 --> 01:03:21,880
难道我们要我，还是我们想要
明星是我的问题吗？

1193
01:03:21,880 --> 01:03:26,160

1194
01:03:26,160 --> 01:03:29,255
是空终止地址
什么存放的地址？

1195
01:03:29,255 --> 01:03:31,420

1196
01:03:31,420 --> 01:03:33,660
位于地址，对吧？

1197
01:03:33,660 --> 01:03:38,420
>> 因此，我们需要解引用是什么
这里，因为这仅仅是一些地址。

1198
01:03:38,420 --> 01:03:44,350
要真正得到启动
我们需要解引用这个

1199
01:03:44,350 --> 01:03:46,770
所以，我们实际上得到
什么是在这个第一的位置。

1200
01:03:46,770 --> 01:03:48,690

1201
01:03:48,690 --> 01:03:52,910
因此，如果我们做明星我什么
我们不希望它等于？

1202
01:03:52,910 --> 01:03:53,885

1203
01:03:53,885 --> 01:03:54,760
听众：反斜杠？

1204
01:03:54,760 --> 01:03:57,760

1205
01:03:57,760 --> 01:03:59,260
>> ZAMYLA陈：有。

1206
01:03:59,260 --> 01:04:01,430
这是否有意义大家？

1207
01:04:01,430 --> 01:04:05,620
我们需要进入我们的字符串，
确保它不是结束。

1208
01:04:05,620 --> 01:04:07,200

1209
01:04:07,200 --> 01:04:08,990
然后我们就可以只更新这个样子。

1210
01:04:08,990 --> 01:04:09,680
正常更新。

1211
01:04:09,680 --> 01:04:11,910

1212
01:04:11,910 --> 01:04:15,070
因此，只要这些
MET，你有什么需要我们做什么？

1213
01:04:15,070 --> 01:04:17,700

1214
01:04:17,700 --> 01:04:18,852
>> 听众：长度加再加。

1215
01:04:18,852 --> 01:04:20,656

1216
01:04:20,656 --> 01:04:21,560
>> ZAMYLA陈：嗯。

1217
01:04:21,560 --> 01:04:25,540
再经过循环
结束，有什么事我们要回来吗？

1218
01:04:25,540 --> 01:04:27,082

1219
01:04:27,082 --> 01:04:27,790
听众：长度？

1220
01:04:27,790 --> 01:04:28,623
ZAMYLA陈：长度。

1221
01:04:28,623 --> 01:04:29,910

1222
01:04:29,910 --> 01:04:30,760
你去那里。

1223
01:04:30,760 --> 01:04:33,790

1224
01:04:33,790 --> 01:04:37,810
这其中显然肉
为理解这一循环。

1225
01:04:37,810 --> 01:04:39,280

1226
01:04:39,280 --> 01:04:41,090
每个人都得到了怎样的工作？

1227
01:04:41,090 --> 01:04:42,460

1228
01:04:42,460 --> 01:04:44,170
我很高兴能重来一次。

1229
01:04:44,170 --> 01:04:48,400
>> 听众：第二
部分，所以明星我有，

1230
01:04:48,400 --> 01:04:51,834
这就是first--地址

1231
01:04:51,834 --> 01:04:53,250
ZAMYLA陈：这不是地址。

1232
01:04:53,250 --> 01:04:54,142
这是什么的。

1233
01:04:54,142 --> 01:04:55,600
听众：这实际上是在那里。

1234
01:04:55,600 --> 01:04:57,475
ZAMYLA陈：这是
什么是真正在那里。

1235
01:04:57,475 --> 01:05:01,280
因此，这是saying--让
我做这更好的。

1236
01:05:01,280 --> 01:05:07,940
因此，这是0×04，而我只是去
说我打算让我的这个名字。

1237
01:05:07,940 --> 01:05:14,531

1238
01:05:14,531 --> 01:05:15,030
行。

1239
01:05:15,030 --> 01:05:17,456

1240
01:05:17,456 --> 01:05:19,080
是的，我知道我有测验检讨今晚。

1241
01:05:19,080 --> 01:05:20,620

1242
01:05:20,620 --> 01:05:21,540
很多测验审查。

1243
01:05:21,540 --> 01:05:23,500

1244
01:05:23,500 --> 01:05:26,620
所以我们说这个字符串
是我的名字，佳佳。

1245
01:05:26,620 --> 01:05:28,600
有点乱，但它的存在。

1246
01:05:28,600 --> 01:05:33,640
和s表示的位置
字符串开始的地方，

1247
01:05:33,640 --> 01:05:41,950
所以我打算让这个
real--这是一个地址，

1248
01:05:41,950 --> 01:05:45,000
其中字符串开始，对不对？

1249
01:05:45,000 --> 01:05:48,560
>> 因此，我们在这里做什么是我们想要
使用指针遍历。

1250
01:05:48,560 --> 01:05:49,920

1251
01:05:49,920 --> 01:05:56,870
因此，我们创建了一些指针，我，也
等于该字符串的开始。

1252
01:05:56,870 --> 01:05:57,880

1253
01:05:57,880 --> 01:06:03,820
并且在每个点处，我们希望
继续经历阵列

1254
01:06:03,820 --> 01:06:07,570
在这里，直到我们打空终止。

1255
01:06:07,570 --> 01:06:12,320
所以，我们总是要检查什么
在这些地址。

1256
01:06:12,320 --> 01:06:15,730
>> 因此，我们解引用我，让
我们第一次做到这一点，我们

1257
01:06:15,730 --> 01:06:17,810
说好，什么是地址0×04？

1258
01:06:17,810 --> 01:06:19,060

1259
01:06:19,060 --> 01:06:19,720
这是一个一。

1260
01:06:19,720 --> 01:06:20,660
OK，我们是很好的。

1261
01:06:20,660 --> 01:06:21,770
增加的长度。

1262
01:06:21,770 --> 01:06:22,790
移动到下一个。

1263
01:06:22,790 --> 01:06:32,410
所以，我 - 记三分球增加的
无论他们指向的大小。

1264
01:06:32,410 --> 01:06:35,320
所以在这种情况下，由于它是
一个char，它会通过一个更新。

1265
01:06:35,320 --> 01:06:38,755
所以，现在我们要看看5，
这意味着它是怎么回事了。

1266
01:06:38,755 --> 01:06:39,860

1267
01:06:39,860 --> 01:06:43,440
所以说，好了，去0x05的。

1268
01:06:43,440 --> 01:06:44,270
是什么在那里？

1269
01:06:44,270 --> 01:06:44,930
这是一个l。

1270
01:06:44,930 --> 01:06:47,870
它会继续这样做，
直到遇到这一个。

1271
01:06:47,870 --> 01:06:50,990
它说，OK，什么在
无论地址是？

1272
01:06:50,990 --> 01:06:53,060
空终止，OK。

1273
01:06:53,060 --> 01:06:53,870
出口。

1274
01:06:53,870 --> 01:06:55,240
而刚刚返回的长度。

1275
01:06:55,240 --> 01:06:56,370

1276
01:06:56,370 --> 01:06:59,800
因为你需要什么是真正的
该地址，而不是地址本身。

1277
01:06:59,800 --> 01:07:03,110

1278
01:07:03,110 --> 01:07:05,790
>> 也有极少数的地方
你真正需要的地址。

1279
01:07:05,790 --> 01:07:08,720
大多数时间，当
您正在使用的，它的

1280
01:07:08,720 --> 01:07:12,424
当你第一次
分配指针或时

1281
01:07:12,424 --> 01:07:14,090
你传递到另一个函数。

1282
01:07:14,090 --> 01:07:16,350

1283
01:07:16,350 --> 01:07:21,330
好了，大家都好有？

1284
01:07:21,330 --> 01:07:21,830
的种类？

1285
01:07:21,830 --> 01:07:23,810

1286
01:07:23,810 --> 01:07:25,040
行。

1287
01:07:25,040 --> 01:07:28,210
>> 所以看起来我们已经
留下了约12分钟，

1288
01:07:28,210 --> 01:07:31,340
所以我们会去到
也许我们的最后一个问题，

1289
01:07:31,340 --> 01:07:34,230
然后再有任何
已经想出概念

1290
01:07:34,230 --> 01:07:36,830
在此期间，我们可以
很快就离开了这一点。

1291
01:07:36,830 --> 01:07:42,310
>> 所以切换齿轮中的最后一个
问题就在这里，switch语句。

1292
01:07:42,310 --> 01:07:44,970

1293
01:07:44,970 --> 01:07:49,450
所以，你的工作就是重写这个
这样它的行为相同

1294
01:07:49,450 --> 01:07:50,580
但不使用交换机。

1295
01:07:50,580 --> 01:07:53,684

1296
01:07:53,684 --> 01:07:54,666
垩白的双手。

1297
01:07:54,666 --> 01:08:11,630

1298
01:08:11,630 --> 01:08:13,420
所以这个蝙蝠的问题吗？

1299
01:08:13,420 --> 01:08:15,420

1300
01:08:15,420 --> 01:08:15,920
无？

1301
01:08:15,920 --> 01:08:16,420
行。

1302
01:08:16,420 --> 01:08:17,920

1303
01:08:17,920 --> 01:08:22,170
大家都明白，如果
案件没有经过任何事情，

1304
01:08:22,170 --> 01:08:25,029
这意味着，它应该
按照下一步？

1305
01:08:25,029 --> 01:08:28,200
所以壳体1和2在此情况下
做同样的事情。

1306
01:08:28,200 --> 01:08:31,153

1307
01:08:31,153 --> 01:08:32,444
有时容易混淆的地方。

1308
01:08:32,444 --> 01:09:32,700

1309
01:09:32,700 --> 01:09:33,488
>> 行。

1310
01:09:33,488 --> 01:09:34,404
任何人有任何想法？

1311
01:09:34,404 --> 01:09:36,364

1312
01:09:36,364 --> 01:09:36,864
是吗？

1313
01:09:36,864 --> 01:09:40,120
>> 听众：所以，你可以
只是做if语句。

1314
01:09:40,120 --> 01:09:41,140
>> ZAMYLA陈：嗯。

1315
01:09:41,140 --> 01:09:42,880
那么，什么是我们的第一次？

1316
01:09:42,880 --> 01:09:48,120
>> 听众：如果n等于等于1，
和2线或n等于

1317
01:09:48,120 --> 01:09:51,059
等于2，然后打印小。

1318
01:09:51,059 --> 01:09:57,760

1319
01:09:57,760 --> 01:09:59,520
然后，你可以做的，如果其他人？

1320
01:09:59,520 --> 01:10:02,160
或者，你可以只是做一个if？

1321
01:10:02,160 --> 01:10:03,650
>> ZAMYLA陈：如果你可以做别的吗？

1322
01:10:03,650 --> 01:10:05,274
>> 听众：这是否重要，如果你这样做的话？

1323
01:10:05,274 --> 01:10:06,320
ZAMYLA陈：所以它的作用。

1324
01:10:06,320 --> 01:10:10,160
是否anyone--这样，你
会得到相同的输出

1325
01:10:10,160 --> 01:10:13,930
如果你只使用IFS与
如果使用其他IFS。

1326
01:10:13,930 --> 01:10:17,090
你们可以想到的原因
为什么您可能希望使用其他

1327
01:10:17,090 --> 01:10:18,680
如果对大量IFS的？

1328
01:10:18,680 --> 01:10:20,260

1329
01:10:20,260 --> 01:10:21,510
要与效率。

1330
01:10:21,510 --> 01:10:22,225
是吗？

1331
01:10:22,225 --> 01:10:24,783
>> 听众：它会检查
所有的IFS每次。

1332
01:10:24,783 --> 01:10:26,076

1333
01:10:26,076 --> 01:10:28,110
>> ZAMYLA陈：所以，即使
它击中了这第一个，

1334
01:10:28,110 --> 01:10:29,880
它会在去检查每隔之一。

1335
01:10:29,880 --> 01:10:36,690
所以，你要使用的情况下，如果其他IFS
其中只有永远都适用其中之一。

1336
01:10:36,690 --> 01:10:39,380
所以互相排斥
我们往往会说。

1337
01:10:39,380 --> 01:10:41,410

1338
01:10:41,410 --> 01:10:46,550
如果您有一堆IFS的，这意味着
也许不止一个人

1339
01:10:46,550 --> 01:10:49,630
问题，也许比多
其中之一可以是真实的。

1340
01:10:49,630 --> 01:10:51,910
而您希望他们两个
如果他们真的来执行。

1341
01:10:51,910 --> 01:10:57,180
如果你只想要其中的一个工作
在这些相互排斥的情况下，

1342
01:10:57,180 --> 01:11:00,790
你想，如果用别的，因为
这一切，是因为有效率。

1343
01:11:00,790 --> 01:11:05,350
你的代码仅仅是更好的设计
如果坚持这种做法。

1344
01:11:05,350 --> 01:11:07,330
因此，在这种情况下，我们将有一个ELSE IF。

1345
01:11:07,330 --> 01:11:09,080
这会是什么？

1346
01:11:09,080 --> 01:11:11,890
>> 听众：n等于等于3。

1347
01:11:11,890 --> 01:11:12,765
ZAMYLA陈：完美。

1348
01:11:12,765 --> 01:11:19,420

1349
01:11:19,420 --> 01:11:20,445
打印介质。

1350
01:11:20,445 --> 01:11:25,190

1351
01:11:25,190 --> 01:11:29,930
然后在我们的最后
情况下，我们有什么？

1352
01:11:29,930 --> 01:11:31,495
否则否则，如果？

1353
01:11:31,495 --> 01:11:32,120
听众：否则。

1354
01:11:32,120 --> 01:11:33,450

1355
01:11:33,450 --> 01:11:37,900
>> ZAMYLA陈：我们want--你想
否则，如果因为我们有具体的案例。

1356
01:11:37,900 --> 01:11:39,270
这不是那种一抓所有。

1357
01:11:39,270 --> 01:11:44,247
如果在switch--有一个缺省
记得交换机可以有情况，

1358
01:11:44,247 --> 01:11:45,330
然后你有默认值。

1359
01:11:45,330 --> 01:11:48,760
如果你有一个默认的，这是一种
你else语句出现。

1360
01:11:48,760 --> 01:11:52,180
但是如果它具有唯一的情况，
这意味着你需要

1361
01:11:52,180 --> 01:11:54,315
进行检查，看它是否每个那些。

1362
01:11:54,315 --> 01:11:57,755
所以在这种情况下，它会在4或5。

1363
01:11:57,755 --> 01:12:00,480

1364
01:12:00,480 --> 01:12:01,450
我们要打印关闭。

1365
01:12:01,450 --> 01:12:02,990

1366
01:12:02,990 --> 01:12:03,630
这是大的。

1367
01:12:03,630 --> 01:12:06,640

1368
01:12:06,640 --> 01:12:07,509
和你去。

1369
01:12:07,509 --> 01:12:08,800
这将是你的程序。

1370
01:12:08,800 --> 01:12:11,890

1371
01:12:11,890 --> 01:12:17,050
>> 所以在这种情况下，如果我们
有一个默认的东西，

1372
01:12:17,050 --> 01:12:20,470
我们将有一个东西在
不管它希望我们做的。

1373
01:12:20,470 --> 01:12:23,365
所以这是一个很好的区别
要知道，了解。

1374
01:12:23,365 --> 01:12:25,368

1375
01:12:25,368 --> 01:12:27,790
这是否有助于开关吗？

1376
01:12:27,790 --> 01:12:28,800
完美的。

1377
01:12:28,800 --> 01:12:29,390
行。

1378
01:12:29,390 --> 01:12:31,320

1379
01:12:31,320 --> 01:12:33,340
>> 我们拥有约八分钟离开。

1380
01:12:33,340 --> 01:12:37,090
难道你们有什么
其他高层次的概念？

1381
01:12:37,090 --> 01:12:38,720
一般的问题？

1382
01:12:38,720 --> 01:12:39,220
是吗？

1383
01:12:39,220 --> 01:12:42,860
>> 观众：我有一个
对他们中的一个问题，

1384
01:12:42,860 --> 01:12:46,257
这是关于随机
在测验零数发生器。

1385
01:12:46,257 --> 01:12:47,340
ZAMYLA陈：哦，那一个。

1386
01:12:47,340 --> 01:12:51,460
一个是另一个的地方
它更多的数学than--肯定的。

1387
01:12:51,460 --> 01:12:53,800

1388
01:12:53,800 --> 01:12:59,452
该解决方案以that--连我的时候
我看到它，我很喜欢，这是什么。

1389
01:12:59,452 --> 01:13:00,590
>> 听众：这是7号。

1390
01:13:00,590 --> 01:13:02,720

1391
01:13:02,720 --> 01:13:05,310
>> ZAMYLA陈：这在我看来很奇怪。

1392
01:13:05,310 --> 01:13:07,260

1393
01:13:07,260 --> 01:13:11,630
所以基本上你想要
使用drand48，这

1394
01:13:11,630 --> 01:13:15,420
会给你一些
介于0和1个数。

1395
01:13:15,420 --> 01:13:21,200
并且你想用它，
你以某种方式得到A--

1396
01:13:21,200 --> 01:13:26,690
而且它更的一道数学题
比我想象的CS问题。

1397
01:13:26,690 --> 01:13:29,040

1398
01:13:29,040 --> 01:13:37,845
>> 你做它 - 的方式，
有时它也只是这样。

1399
01:13:37,845 --> 01:13:39,340

1400
01:13:39,340 --> 01:13:41,090
再次，这些是
情况下，它是一种

1401
01:13:41,090 --> 01:13:46,310
像写什么你
可以和部分信用。

1402
01:13:46,310 --> 01:13:47,800

1403
01:13:47,800 --> 01:13:51,510
因此，如果我们想一回，
我们知道，我们是

1404
01:13:51,510 --> 01:13:54,182
将要使用drand48
在某种程度上，对不对？

1405
01:13:54,182 --> 01:13:55,640
那么，为什么我们不记下来。

1406
01:13:55,640 --> 01:13:58,286

1407
01:13:58,286 --> 01:13:59,410
我们使用它以某种方式。

1408
01:13:59,410 --> 01:14:00,780

1409
01:14:00,780 --> 01:14:04,190
他们有办法
你们用它

1410
01:14:04,190 --> 01:14:08,175
这样，我会尽量解释。

1411
01:14:08,175 --> 01:14:10,200

1412
01:14:10,200 --> 01:14:15,340
>> 所以基本上这里会发生什么
是因为它是一个介于0和1，

1413
01:14:15,340 --> 01:14:19,300
你在做什么，是你乘
by--这不能不说是一个数学问题。

1414
01:14:19,300 --> 01:14:22,010
刚满免责声明，这是
完全是数学问题。

1415
01:14:22,010 --> 01:14:23,990
你正在做的是
因为0和1，您

1416
01:14:23,990 --> 01:14:26,460
希望它是内
这个范围，你居然

1417
01:14:26,460 --> 01:14:29,360
弄清楚如何大
的范围是，然后

1418
01:14:29,360 --> 01:14:32,710
你基本上按比例放大，
这是这是什么做的。

1419
01:14:32,710 --> 01:14:39,050
>> B减一给你的范围内，
这些数字之间的差异。

1420
01:14:39,050 --> 01:14:44,040
您可以在0繁殖
和1，再加入一刚

1421
01:14:44,040 --> 01:14:48,870
意味着你的缩放起来
所以，它的a和b之间，

1422
01:14:48,870 --> 01:14:52,377
我真的不喜欢这个问题。

1423
01:14:52,377 --> 01:14:58,380

1424
01:14:58,380 --> 01:15:01,790
正如我所说的，本测验
是指包括

1425
01:15:01,790 --> 01:15:04,110
人谁不舒服，
介于两者之间，

1426
01:15:04,110 --> 01:15:05,070
，更舒适。

1427
01:15:05,070 --> 01:15:07,550
因此，如果他们说得那么
这是什么

1428
01:15:07,550 --> 01:15:10,050
每个人都在少
舒适的地方会得到，

1429
01:15:10,050 --> 01:15:12,259
我们将有太多太多
人得分完善，

1430
01:15:12,259 --> 01:15:13,925
和更舒适的会是无聊。

1431
01:15:13,925 --> 01:15:14,980

1432
01:15:14,980 --> 01:15:18,970
>> 因此，他们总是有这些
种脑筋急转弯问题

1433
01:15:18,970 --> 01:15:22,695
那些原本应该是有点困难
这需要一定的创造性思维。

1434
01:15:22,695 --> 01:15:25,030

1435
01:15:25,030 --> 01:15:27,790
当你看到他们，
不要太难倒。

1436
01:15:27,790 --> 01:15:31,720
我肯定会说的倒装
通过你的第一次测验。

1437
01:15:31,720 --> 01:15:35,020
解决问题
你知道你可以，

1438
01:15:35,020 --> 01:15:38,480
因为没有使用卡住
在一个问题，当存在三个

1439
01:15:38,480 --> 01:15:42,090
或在网页上四个或五个
之后，你可以很容易地做到。

1440
01:15:42,090 --> 01:15:45,331

1441
01:15:45,331 --> 01:15:48,520
>> 听众：到底为什么你
由范围乘以？

1442
01:15:48,520 --> 01:15:54,935
>> ZAMYLA陈：你乘的范围
你知道 - 它是怎么样经过多少

1443
01:15:54,935 --> 01:15:55,485
你想要？

1444
01:15:55,485 --> 01:15:57,840

1445
01:15:57,840 --> 01:16:02,130
所以，你能想到的，因为它
返回一个介于0和1之间的数，

1446
01:16:02,130 --> 01:16:03,890
你可以把它看成是一个百分比。

1447
01:16:03,890 --> 01:16:12,195
因此，它基本上是说，如果我们有
我们的数字线在这里，在这里，

1448
01:16:12,195 --> 01:16:13,840
b是在这里。

1449
01:16:13,840 --> 01:16:19,170
你就像多少钱过去呢？

1450
01:16:19,170 --> 01:16:20,010
就是我们正在做的。

1451
01:16:20,010 --> 01:16:24,920
所以你刚才问的
该范围，百分数

1452
01:16:24,920 --> 01:16:26,170
就是它给你。

1453
01:16:26,170 --> 01:16:30,915
然后你基本上只是
通过增加其放大。

1454
01:16:30,915 --> 01:16:32,302
这是一个数学脑筋急转弯。

1455
01:16:32,302 --> 01:16:35,400

1456
01:16:35,400 --> 01:16:39,060
>> 如果有任何最后一分钟的意见，我
将通过提问说，翻转，

1457
01:16:39,060 --> 01:16:41,660
找出哪些是你
知道似的，哦，我得到这个。

1458
01:16:41,660 --> 01:16:43,196

1459
01:16:43,196 --> 01:16:45,820
几乎可以肯定他们会
是你不知道的问题

1460
01:16:45,820 --> 01:16:49,580
或者，你要去有时间
对，所以打你的长处，好不好？

1461
01:16:49,580 --> 01:16:50,990
你们要大。

1462
01:16:50,990 --> 01:16:52,740
有很多的
是有原因的问题，

1463
01:16:52,740 --> 01:16:57,140
让您有时间
种有机会

1464
01:16:57,140 --> 01:16:59,330
证明了什么
你在真的很好。

1465
01:16:59,330 --> 01:17:02,370
因此，它是确定的，如果你是
在一切都不好。

1466
01:17:02,370 --> 01:17:03,371
发挥你的长处。

1467
01:17:03,371 --> 01:17:03,870
是吗？

1468
01:17:03,870 --> 01:17:06,536
>> 听众：原来是这样打算
返回东西是截断？

1469
01:17:06,536 --> 01:17:10,810

1470
01:17:10,810 --> 01:17:15,015
是的，它会因为drand
0和1之间的回报。

1471
01:17:15,015 --> 01:17:17,459

1472
01:17:17,459 --> 01:17:19,250
它会返回一个int，
因为它会截断

1473
01:17:19,250 --> 01:17:22,933
当我们添加一个或它繁殖。

1474
01:17:22,933 --> 01:17:27,670

1475
01:17:27,670 --> 01:17:28,442
凉爽。

1476
01:17:28,442 --> 01:17:29,525
在最后一分钟的问题吗？

1477
01:17:29,525 --> 01:17:31,310

1478
01:17:31,310 --> 01:17:32,615
>> 你们要做大。

1479
01:17:32,615 --> 01:17:34,440
你会是美妙的。

1480
01:17:34,440 --> 01:17:37,100
并且即使不是这样，将
是这里的糖果下周。

1481
01:17:37,100 --> 01:17:39,040

1482
01:17:39,040 --> 01:17:40,020
我会爱你。

1483
01:17:40,020 --> 01:17:41,270
我爱你们不管。

1484
01:17:41,270 --> 01:17:42,550

1485
01:17:42,550 --> 01:17:43,930
好了，祝大家好运。

1486
01:17:43,930 --> 01:17:44,680
有一个伟大的时间。

1487
01:17:44,680 --> 01:17:45,620

1488
01:17:45,620 --> 01:17:46,620
你会好起来的。

1489
01:17:46,620 --> 01:17:47,370
你知道吗？

1490
01:17:47,370 --> 01:17:50,310
在两天它会
要结束了，而我

1491
01:17:50,310 --> 01:17:53,675
对周四2期中考试，所以
至少你们会做。

1492
01:17:53,675 --> 01:17:56,550
好吧，我会看到你们下周。

1493
01:17:56,550 --> 01:17:58,208