1
00:00:00,000 --> 00:00:02,000
[Powered by Google Translate] [第4条] [舒适]

2
00:00:02,000 --> 00:00:04,000
内特 - 哈迪森] [哈佛大学]

3
00:00:04,000 --> 00:00:07,000
这是CS50。[CS50.TV]

4
00:00:07,000 --> 00:00:10,000
>> 好了，欢迎回款。

5
00:00:10,000 --> 00:00:13,000
在本周的部分中，我们要做的几件事情。

6
00:00:13,000 --> 00:00:17,000
我们将首先回顾一下习题集2，

7
00:00:17,000 --> 00:00:20,000
这是在的凯撒和维琼内尔问题集。

8
00:00:20,000 --> 00:00:23,000
然后，我们将潜入测验0个评论

9
00:00:23,000 --> 00:00:26,000
并花一点点的时间，扼要我们所谈论的

10
00:00:26,000 --> 00:00:30,000
的讲座中，到目前为止，我们还会做的几个问题

11
00:00:30,000 --> 00:00:32,000
从上一年度的测验。

12
00:00:32,000 --> 00:00:36,000
这样，你们有一个很好的方式准备。

13
00:00:36,000 --> 00:00:40,000
>> 首先，我已经启动了一对夫妇的良好的解决方案，

14
00:00:40,000 --> 00:00:45,000
对于前一个问题集，习题集2，进入这个空间。

15
00:00:45,000 --> 00:00:48,000
如果你们打这个环节，

16
00:00:48,000 --> 00:00:53,000
如果你点击我的名字，然后单击“我的第一次修订

17
00:00:53,000 --> 00:00:56,000
，你会看到caesar.c的，而这正是我在寻找。

18
00:00:56,000 --> 00:01:00,000
让我们来谈谈这真的很快。

19
00:01:00,000 --> 00:01:02,000
这仅仅是一个样品溶液。

20
00:01:02,000 --> 00:01:05,000
这不一定是最完美的解决方案。

21
00:01:05,000 --> 00:01:08,000
有许多不同的方法来写这个，

22
00:01:08,000 --> 00:01:10,000
但也有几件事情，我想强调

23
00:01:10,000 --> 00:01:13,000
我看到了，因为我是分级的，常见的错误，我认为

24
00:01:13,000 --> 00:01:18,000
这个解决方案做了很好的处理工作。

25
00:01:18,000 --> 00:01:22,000
>> 第一的是，在顶部具有某种头注释。

26
00:01:22,000 --> 00:01:25,000
在第1行至第7，你看到的细节，

27
00:01:25,000 --> 00:01:28,000
究竟是什么程序在做什么。

28
00:01:28,000 --> 00:01:32,000
当你写C代码的一个很好的标准做法

29
00:01:32,000 --> 00:01:35,000
不管你的程序是包含在一个单一的文件或

30
00:01:35,000 --> 00:01:38,000
无论是拆分到多个文件中是有某种

31
00:01:38,000 --> 00:01:40,000
定向开头处的注释。

32
00:01:40,000 --> 00:01:43,000
这也为走出去写代码，在现实世界中的人。

33
00:01:43,000 --> 00:01:47,000
这是他们会把版权信息。

34
00:01:47,000 --> 00:01:50,000
下面是＃包括。

35
00:01:50,000 --> 00:01:55,000
第16行有这样的定义，我们会回来的，在短短位。

36
00:01:55,000 --> 00:01:59,000
，然后再次启动的功能，一旦主开始，

37
00:01:59,000 --> 00:02:03,000
因为这个程序已经都包含在一个单一的功能

38
00:02:03,000 --> 00:02:09,000
第一件事发生这种情况，这是很惯用的，典型的C程序

39
00:02:09,000 --> 00:02:14,000
，它的命令行参数的是，它会立即检查

40
00:02:14,000 --> 00:02:18,000
>> 计数参数是argc。

41
00:02:18,000 --> 00:02:24,000
在这里，我们看到，这个程序需要2个参数完全相同。

42
00:02:24,000 --> 00:02:27,000
记得有，第一个参数的特殊

43
00:02:27,000 --> 00:02:29,000
这是永远的正在运行的程序的名称，

44
00:02:29,000 --> 00:02:31,000
的可执行文件的名称。

45
00:02:31,000 --> 00:02:36,000
因此，这是什么做的是，它可以防止用户运行该程序

46
00:02:36,000 --> 00:02:42,000
更多或更少的参数。

47
00:02:42,000 --> 00:02:44,000
究其原因是因为我们要检查这项权利了

48
00:02:44,000 --> 00:02:52,000
我们实际上无法访问此argv数组，这里可靠

49
00:02:52,000 --> 00:02:55,000
直到我们检查，看它有多大。

50
00:02:55,000 --> 00:02:58,000
>> 我看到了常见的错误之一是，人们马上会去

51
00:02:58,000 --> 00:03:01,000
和抓斗的argv [1]。

52
00:03:01,000 --> 00:03:06,000
他们会抓住关键参数的数组，并做一个我检查它，

53
00:03:06,000 --> 00:03:11,000
然后，他们会做的测试为argc以及接下来的测试，

54
00:03:11,000 --> 00:03:16,000
不是第一个参数是否确实是在相同的时间的整数，

55
00:03:16,000 --> 00:03:20,000
不工作，因为的情况下，没有提供参数

56
00:03:20,000 --> 00:03:26,000
你会被抓住的参数是不存在，或试图抓住一个不存在的。

57
00:03:26,000 --> 00:03:29,000
>> 其他大的事情，你应该注意到的是，

58
00:03:29,000 --> 00:03:32,000
你总是希望打印出某种有用的错误信息

59
00:03:32,000 --> 00:03:34,000
定位他们的用户。

60
00:03:34,000 --> 00:03:37,000
我敢肯定，你的所有运行程序，所有的突然崩溃，

61
00:03:37,000 --> 00:03:41,000
你这是荒谬的小对话框弹出，并说

62
00:03:41,000 --> 00:03:44,000
一些可怕的神秘，也许给你一个错误的代码，或类似的东西

63
00:03:44,000 --> 00:03:47,000
那是没有意义的。

64
00:03:47,000 --> 00:03:50,000
这是你真正想要提供一些有益

65
00:03:50,000 --> 00:03:54,000
并针对用户，这样当他们运行它，他们“哦，”面对手掌。

66
00:03:54,000 --> 00:03:58,000
“我知道该怎么做，我知道如何解决这个问题。”

67
00:03:58,000 --> 00:04:01,000
>> 如果你不打印一条消息，那么你最终实际

68
00:04:01,000 --> 00:04:04,000
让用户去检查你的源代码

69
00:04:04,000 --> 00:04:07,000
出了什么错。

70
00:04:07,000 --> 00:04:11,000
也有一些时候，你会使用不同的错误代码。

71
00:04:11,000 --> 00:04:14,000
在这里，我们只是说有一个错误，

72
00:04:14,000 --> 00:04:16,000
有一个错误，出现了错误。

73
00:04:16,000 --> 00:04:20,000
更大的程序，通常被称为由其他程序的程序，

74
00:04:20,000 --> 00:04:25,000
在不同的情况下，将返回某种特殊的错误代码

75
00:04:25,000 --> 00:04:28,000
以编程方式沟通，否则你会

76
00:04:28,000 --> 00:04:32,000
只使用一个好听的英文消息。

77
00:04:32,000 --> 00:04:35,000
酷。

78
00:04:35,000 --> 00:04:37,000
当我们的工作，你可以看到我们拉的关键了。

79
00:04:37,000 --> 00:04:40,000
我们测试一下，看看如果钥匙和。

80
00:04:40,000 --> 00:04:42,000
我们从用户得到一个消息。

81
00:04:42,000 --> 00:04:46,000
我们之所以这样做，在这个do while循环，这是什么，我们将覆盖

82
00:04:46,000 --> 00:04:50,000
一点点，但事实证明，如果你输入控制D

83
00:04:50,000 --> 00:04:54,000
当你在终端上的提示，GetString的

84
00:04:54,000 --> 00:04:59,000
实际上做的是，它发送一个特殊字符

85
00:04:59,000 --> 00:05:01,000
到该程序。

86
00:05:01,000 --> 00:05:05,000
这就是所谓的ELF文件结束符。

87
00:05:05,000 --> 00:05:08,000
在这种情况下，我们的消息字符串，是空的，

88
00:05:08,000 --> 00:05:14,000
所以这不是我们检查中的问题，为自己的东西。

89
00:05:14,000 --> 00:05:17,000
>> 但是，当我们去，现在我们已经开始谈论指针

90
00:05:17,000 --> 00:05:21,000
和动态内存分配在堆上，

91
00:05:21,000 --> 00:05:25,000
检查是否为空，只要你有一个功能，可能

92
00:05:25,000 --> 00:05:30,000
返回null值是在做的习惯，你会希望得到的东西。

93
00:05:30,000 --> 00:05:33,000
这是在这里主要是为例证。

94
00:05:33,000 --> 00:05:36,000
但是，当你看到的GetString在未来，

95
00:05:36,000 --> 00:05:41,000
所以从习题集4上，你要记住这一点。

96
00:05:41,000 --> 00:05:44,000
再次，这是不是一个问题，问题3，因为我们没有遮盖。

97
00:05:44,000 --> 00:05:53,000
最后，我们得到的这部分，我们得到的主要加密循环，

98
00:05:53,000 --> 00:05:57,000
有一对夫妇的事情在这里。

99
00:05:57,000 --> 00:06:02,000
首先，我们遍历整个消息字符串本身。

100
00:06:02,000 --> 00:06:07,000
在这里，我们已经把strlen的要求的条件，

101
00:06:07,000 --> 00:06:12,000
一些你所指出的，是不是一个伟大的方式去。

102
00:06:12,000 --> 00:06:15,000
事实证明，在这种情况下，它也没有很大的，

103
00:06:15,000 --> 00:06:20,000
部分原因是因为我们要修改的消息本身的内容

104
00:06:20,000 --> 00:06:27,000
在fo​​r循环中，所以，如果我们有10个字符长的消息，

105
00:06:27,000 --> 00:06:32,000
我们第一次启动，strlen的循环，将返回什么呢？

106
00:06:32,000 --> 00:06:35,000
10。

107
00:06:35,000 --> 00:06:40,000
>> 但是，如果我们再修改的消息，说我们修改它的第5个字符，

108
00:06:40,000 --> 00:06:46,000
我们扔在一个\ 0字符在第5位，

109
00:06:46,000 --> 00:06:49,000
在随后的迭代中的strlen（消息）将不会返回它的所作所为

110
00:06:49,000 --> 00:06:52,000
我们第一次迭代，

111
00:06:52,000 --> 00:06:56,000
但是，它会直接返回5，因为我们扔在了空终止，

112
00:06:56,000 --> 00:06:59,000
定义字符串的长度

113
00:06:59,000 --> 00:07:03,000
由位置，\ 0。

114
00:07:03,000 --> 00:07:09,000
在这种情况下，这是一个伟大的路要走，因为我们修改它。

115
00:07:09,000 --> 00:07:13,000
但是你注意，这实际上是出奇的简单加密

116
00:07:13,000 --> 00:07:16,000
如果你能得到正确的数学。

117
00:07:16,000 --> 00:07:19,000
所有这一切需要的是检查是否或不信你看

118
00:07:19,000 --> 00:07:21,000
是大写还是小写。

119
00:07:21,000 --> 00:07:24,000
>> 究其原因，我们只需要检查，我们并不一定要检查

120
00:07:24,000 --> 00:07:27,000
是α的情况下是因为

121
00:07:27,000 --> 00:07:30,000
如果一个字符是大写的，或者如果它是小写

122
00:07:30,000 --> 00:07:33,000
这绝对是一个字母，

123
00:07:33,000 --> 00:07:38,000
因为我们没有大写和小写的数字。

124
00:07:38,000 --> 00:07:41,000
我们做其他的事情，这是一个小技巧 - 

125
00:07:41,000 --> 00:07:45,000
我们已经修改了标准的恺撒密码式

126
00:07:45,000 --> 00:07:49,000
我们给问题集规范。

127
00:07:49,000 --> 00:07:52,000
这里有什么不同的是，我们减去

128
00:07:52,000 --> 00:07:58,000
A，大写的情况下，资本，然后我们增加了大写字母A

129
00:07:58,000 --> 00:08:02,000
备份结束时。

130
00:08:02,000 --> 00:08:05,000
>> 我知道一些你在你的代码中已经这样做了。

131
00:08:05,000 --> 00:08:09,000
有没有你这样做您提交的吗？

132
00:08:09,000 --> 00:08:13,000
你这样做。你能解释一下这是什么做的，Sahb？

133
00:08:13,000 --> 00:08:18,000
通过减去它，因为你做了一个mod后，

134
00:08:18,000 --> 00:08:21,000
你必须把它拿出来，这样一来你[咳嗽]位置。

135
00:08:21,000 --> 00:08:25,000
然后加入回来后移了过来，你想。

136
00:08:25,000 --> 00:08:27,000
是的，没错。

137
00:08:27,000 --> 00:08:32,000
什么Sahb说的是，当我们要添加

138
00:08:32,000 --> 00:08:36,000
我们的信息和我们的键

139
00:08:36,000 --> 00:08:42,000
然后国防部称，国防部，的NUM_LETTERS，

140
00:08:42,000 --> 00:08:50,000
如果我们不扩大我们的信息到相应的0至25的范围内，第一，

141
00:08:50,000 --> 00:08:54,000
那么，我们可能最终得到一个非常奇怪的数字

142
00:08:54,000 --> 00:08:59,000
因为，我们正在寻找时，我们期待在消息[I]的值，

143
00:08:59,000 --> 00:09:03,000
当我们看到我们的纯文本消息在第i个字符，

144
00:09:03,000 --> 00:09:08,000
在这65至122的范围内，是一种价值的地方

145
00:09:08,000 --> 00:09:13,000
通过小写字母z的大写字母A的ASCII值的基础上。

146
00:09:13,000 --> 00:09:18,000
因此，当我们mod这26或由NUM_LETTERS的，

147
00:09:18,000 --> 00:09:23,000
因为那是我们的＃define在这里的右上角，

148
00:09:23,000 --> 00:09:28,000
这给我们一个值，在0至25的范围内，

149
00:09:28,000 --> 00:09:30,000
我们需要一个方法，然后，备份扩展

150
00:09:30,000 --> 00:09:32,000
并在适当的ASCII范围。

151
00:09:32,000 --> 00:09:36,000
做到这一点最简单的方法是，只是规模都记录下来

152
00:09:36,000 --> 00:09:39,000
到0至25的范围内，首先，

153
00:09:39,000 --> 00:09:43,000
然后改变一切结束时。

154
00:09:43,000 --> 00:09:46,000
>> 另一个常见的​​错误，我看到了人碰上的是，

155
00:09:46,000 --> 00:09:50,000
实际上，如果你不这样做缩放马上

156
00:09:50,000 --> 00:09:53,000
和你添加消息和关键，你将它们添加，也就是说，

157
00:09:53,000 --> 00:09:58,000
到一个char变量，问题与

158
00:09:58,000 --> 00:10:01,000
既然这个消息[i]是一个比较大的数量开始

159
00:10:01,000 --> 00:10:05,000
记得至少65，如果它是一个大写字符

160
00:10:05,000 --> 00:10:09,000
如果你有一个大的关键，说，像100，

161
00:10:09,000 --> 00:10:13,000
和你添加那些连成一个符号的字符，你将得到一个溢出。

162
00:10:13,000 --> 00:10:17,000
你会得到一个值，该值大于127，

163
00:10:17,000 --> 00:10:22,000
这是一个char变量可以容纳的最大价值。

164
00:10:22,000 --> 00:10:26,000
同样的，这就是为什么你会想要做那种事情开始。

165
00:10:26,000 --> 00:10:29,000
有些人得到了解决这种情况下做的，如果其他测试

166
00:10:29,000 --> 00:10:33,000
在这之前，看看它会溢出，

167
00:10:33,000 --> 00:10:36,000
但这种方式得到解决的。

168
00:10:36,000 --> 00:10:40,000
然后在此解决方案中，我们打印出整个字符串在最后。

169
00:10:40,000 --> 00:10:45,000
其他人打印出一个字符的时间。真棒。

170
00:10:45,000 --> 00:10:51,000
在这一点上，你们有任何问题，任何意见？

171
00:10:51,000 --> 00:10:56,000
你喜欢的东西，你不喜欢的东西吗？

172
00:10:56,000 --> 00:10:58,000
>> 我有一个问题。

173
00:10:58,000 --> 00:11:01,000
也许我错过了在你的解释，但如何做这个节目

174
00:11:01,000 --> 00:11:07,000
跳过空格连接的关键文本的长度吗？

175
00:11:07,000 --> 00:11:10,000
这仅仅是恺撒密码。哦，对不起，是的。

176
00:11:10,000 --> 00:11:13,000
是的，我们会看到这一点。

177
00:11:13,000 --> 00:11:16,000
在恺撒密码，我们得到了解决，因为

178
00:11:16,000 --> 00:11:18,000
我们只翻个字符。

179
00:11:18,000 --> 00:11:27,000
我们只旋转他们，如果他们是大写或小写。

180
00:11:27,000 --> 00:11:32,000
你们感觉还不错，对这个吗？

181
00:11:32,000 --> 00:11:34,000
感觉自由复制这个家，把它，

182
00:11:34,000 --> 00:11:37,000
给你们写了什么。

183
00:11:37,000 --> 00:11:42,000
肯定会觉得免费发送关于它的问题。

184
00:11:42,000 --> 00:11:46,000
再次，认识到这里的目标与您的问题集

185
00:11:46,000 --> 00:11:50,000
不要让你们来编写完美的代码为您的问题集。

186
00:11:50,000 --> 00:11:57,000
这是一个学习的经验。是啊。

187
00:11:57,000 --> 00:12:01,000
>> 返回的do while循环，如果它等于空，

188
00:12:01,000 --> 00:12:06,000
所以空只是意味着什么，他们只投中输入？

189
00:12:06,000 --> 00:12:12,000
null是一个特殊的指针的值，

190
00:12:12,000 --> 00:12:17,000
我们使用空当我们想要说

191
00:12:17,000 --> 00:12:23,000
我们有一个指针变量，它指向没有。

192
00:12:23,000 --> 00:12:28,000
因此，它通常意味着这个变量，这个消息变量

193
00:12:28,000 --> 00:12:35,000
是空的，在这里，因为我们使用的是CS50特殊的字符串类型，

194
00:12:35,000 --> 00:12:37,000
的CS50的字符串类型是什么？

195
00:12:37,000 --> 00:12:42,000
你见过它是什么，当大卫拉了回来罩在演讲吗？

196
00:12:42,000 --> 00:12:44,000
这是一个时髦的，它是一个指针，对不对？

197
00:12:44,000 --> 00:12:48,000
好吧，是的。>>这是一个char *。

198
00:12:48,000 --> 00:12:52,000
因此，我们真的可以取代

199
00:12:52,000 --> 00:12:56,000
在这里用char *的消息，

200
00:12:56,000 --> 00:13:04,000
等GetString函数，如果它没有成功地得到一个字符串的用户，

201
00:13:04,000 --> 00:13:08,000
它不能解析的字符串，在一种情况下，它不能解析的字符串

202
00:13:08,000 --> 00:13:11,000
是，如果用户键入文件结束字符，控制D，

203
00:13:11,000 --> 00:13:17,000
这是不是你通常做的事情，但如果出现这种情况

204
00:13:17,000 --> 00:13:20,000
然后该函数将返回为空值的一种说法

205
00:13:20,000 --> 00:13:23,000
“嘿，我没有得到一个字符串。”

206
00:13:23,000 --> 00:13:27,000
会发生什么，如果我们不把消息= 0，

207
00:13:27,000 --> 00:13:30,000
这是一件好事，我们还没有做呢？

208
00:13:30,000 --> 00:13:32,000
为什么会是这样一个问题在这里吗？

209
00:13:32,000 --> 00:13:38,000
因为我知道，我们谈了一点点的内存泄漏演讲。

210
00:13:38,000 --> 00:13:42,000
是啊，让我们做到这一点，让我们看看会发生什么。

211
00:13:42,000 --> 00:13:44,000
>> 罗勒的问题是会发生什么，如果我们实际上并没有

212
00:13:44,000 --> 00:13:48,000
此消息= NULL测试？

213
00:13:48,000 --> 00:13:51,000
让我们来滚动到顶部。

214
00:13:51,000 --> 00:13:53,000
你们可以评论了这一点。

215
00:13:53,000 --> 00:13:55,000
其实，我将它保存在一个修订。

216
00:13:55,000 --> 00:13:58,000
这将是第三次修订版。

217
00:13:58,000 --> 00:14:02,000
你必须运行此程序是，你必须点击齿轮图标，在这里，

218
00:14:02,000 --> 00:14:04,000
你就必须给它添加一个参数。

219
00:14:04,000 --> 00:14:10,000
你必须给它的主要论点，因为我们要通过在命令行中的参数。

220
00:14:10,000 --> 00:14:13,000
在这里，我要去给它的数量3。我喜欢3。

221
00:14:13,000 --> 00:14:19,000
现在放大，运行该程序。

222
00:14:19,000 --> 00:14:24,000
它的运行，编译，构建。

223
00:14:24,000 --> 00:14:27,000
在这里，我们走了。它的等待提示。

224
00:14:27,000 --> 00:14:33,000
如果我输入的东西，喜欢Hello哪里去了？

225
00:14:33,000 --> 00:14:38,000
哦，我的程序运行时间太长。我jawing太长时间。

226
00:14:38,000 --> 00:14:40,000
在这里不言而喻。

227
00:14:40,000 --> 00:14:43,000
现在，我输入你好。

228
00:14:43,000 --> 00:14:46,000
我们看到它加密适当。

229
00:14:46,000 --> 00:14:52,000
现在会发生什么，如果我们这样做迅速的GetString返回null？

230
00:14:52,000 --> 00:14:57,000
请记住，我说，我们这样做，同时按控制D。

231
00:14:57,000 --> 00:14:59,000
在这里，我会向上滚动。我们将再次运行。

232
00:14:59,000 --> 00:15:01,000
建设中。就这样吧。

233
00:15:01,000 --> 00:15:04,000
现在，当我打控制D

234
00:15:04,000 --> 00:15:12,000
我说opt/sandbox50/bin/run.sh，这条线分割故障。

235
00:15:12,000 --> 00:15:15,000
你们有没有看到过吗？

236
00:15:15,000 --> 00:15:17,000
>> [学生]：为什么没有“对不起？

237
00:15:17,000 --> 00:15:20,000
[学生]：为什么在这种情况下，是没有核心转储？

238
00:15:20,000 --> 00:15:26,000
核心转储的问题是，为什么没有核心转储这里吗？

239
00:15:26,000 --> 00:15:29,000
问题是有可能，但核心转储的文件

240
00:15:29,000 --> 00:15:31,000
被存储在硬盘驱动器。

241
00:15:31,000 --> 00:15:34,000
在这种情况下，我们已禁用核心转储

242
00:15:34,000 --> 00:15:37,000
运行服务器上，所以我们没有人段断层

243
00:15:37,000 --> 00:15:40,000
建立核心转储吨。

244
00:15:40,000 --> 00:15:46,000
但你可能会得到一个。

245
00:15:46,000 --> 00:15:48,000
核心内存转储文件之类的事情，你经常可以禁用，

246
00:15:48,000 --> 00:15:52,000
有时你做的。

247
00:15:52,000 --> 00:15:55,000
分割故障，回答你的问题，罗勒，

248
00:15:55,000 --> 00:16:00,000
是说，在我们试图访问一个指针

249
00:16:00,000 --> 00:16:05,000
没有被设置为指向任何。

250
00:16:05,000 --> 00:16:09,000
视频的时候Binky试图记住Binky

251
00:16:09,000 --> 00:16:12,000
去访问的指针没有指向什么？

252
00:16:12,000 --> 00:16:16,000
在这种情况下，我想技术上的指针指向的东西。

253
00:16:16,000 --> 00:16:20,000
它指向空，这在技术上是0，

254
00:16:20,000 --> 00:16:25,000
但是这被定义为在一个段是无法访问的

255
00:16:25,000 --> 00:16:28,000
你的程序，你会得到一个分割故障

256
00:16:28,000 --> 00:16:31,000
因为你不访问内存中一个有效的段

257
00:16:31,000 --> 00:16:38,000
像堆段或堆栈段或数据段。

258
00:16:38,000 --> 00:16:40,000
酷。

259
00:16:40,000 --> 00:16:48,000
任何更多的问题，凯撒？

260
00:16:48,000 --> 00:16:51,000
>> 让我们继续前进。让我们来看看在第二次修订真的很快。

261
00:16:51,000 --> 00:17:00,000
这是维琼内尔。

262
00:17:00,000 --> 00:17:04,000
在这里，维琼内尔

263
00:17:04,000 --> 00:17:06,000
我们将步行通过这个很快，因为再次，

264
00:17:06,000 --> 00:17:10,000
维琼内尔和凯撒是非常相似的。

265
00:17:10,000 --> 00:17:12,000
头注释之前，

266
00:17:12,000 --> 00:17:17,000
＃define的前避免使用这些神奇的数字。

267
00:17:17,000 --> 00:17:21,000
这种做法的好处是说，我们希望迁移到

268
00:17:21,000 --> 00:17:23,000
不同的字母或类似的东西。

269
00:17:23,000 --> 00:17:26,000
而不是去手动更改所有的26个代码中的

270
00:17:26,000 --> 00:17:30,000
我们可以改变这27或砸下来

271
00:17:30,000 --> 00:17:34,000
如果我们使用不同的字母表，不同的语言。

272
00:17:34,000 --> 00:17:38,000
同样，我们已经得到了这个检查计数参数，

273
00:17:38,000 --> 00:17:42,000
真的是你几乎可以作为一个模板。

274
00:17:42,000 --> 00:17:46,000
几乎每一个你写的程序应该有

275
00:17:46,000 --> 00:17:50,000
如果需要命令行参数的一些序列的线

276
00:17:50,000 --> 00:17:55,000
在开始的时候是这样的。

277
00:17:55,000 --> 00:17:59,000
这是一个你想要做的第一次完整性测试。

278
00:17:59,000 --> 00:18:03,000
>> 这里，我们所做的只是我们确信，

279
00:18:03,000 --> 00:18:06,000
关键字是有效的，那就是，我们做了第二次检查。

280
00:18:06,000 --> 00:18:11,000
再次注意，我们分开argc和2。

281
00:18:11,000 --> 00:18:14,000
请注意，在这种情况下，我们需要做的是一件事，而不是

282
00:18:14,000 --> 00:18:18,000
使用我，我们想验证的整个字符串，

283
00:18:18,000 --> 00:18:21,000
在为了做到这一点，你确实有去逐个字符

284
00:18:21,000 --> 00:18:23,000
在字符串。

285
00:18:23,000 --> 00:18:29,000
有没有很好的方法来调用一下就可以了

286
00:18:29,000 --> 00:18:31,000
因为即使，例如，一个我将返回0

287
00:18:31,000 --> 00:18:37,000
如果它不能解析一个整数，所以，甚至不工作。

288
00:18:37,000 --> 00:18:42,000
同样，不错的消息，告诉用户究竟发生了什么事。

289
00:18:42,000 --> 00:18:45,000
那么在这里，再次，我们也处理的情况下，

290
00:18:45,000 --> 00:18:50,000
用户控制三维随机字符类型。

291
00:18:50,000 --> 00:18:54,000
>> 然后夏洛特有一个问题，我们如何管理跳过空格

292
00:18:54,000 --> 00:18:57,000
在我们的字符串。

293
00:18:57,000 --> 00:19:00,000
这是一种类似我们所做的Myspace程序

294
00:19:00,000 --> 00:19:04,000
我们所做的部分，工作的方式，这

295
00:19:04,000 --> 00:19:08,000
是我们跟踪的数量，我们看到的字母。

296
00:19:08,000 --> 00:19:13,000
当我们走在消息字符串，因为我们逐个字符地走了过来，

297
00:19:13,000 --> 00:19:16,000
我们跟踪的指数的一部分，我们的for循环，然后我们也跟踪

298
00:19:16,000 --> 00:19:21,000
数量的字母，所以非特殊字符，非数字，非空白

299
00:19:21,000 --> 00:19:27,000
我们看到在单独的变量。

300
00:19:27,000 --> 00:19:33,000
然后，该解决方案修改的关键

301
00:19:33,000 --> 00:19:41,000
得到一个实际的的关键整数，它确实是在飞行中，

302
00:19:41,000 --> 00:19:47,000
右，然后到实际的消息字符进行加密。

303
00:19:47,000 --> 00:19:50,000
有一些解决方案，是完全

304
00:19:50,000 --> 00:19:58,000
将修改键时，关键的有效性进行测试。

305
00:19:58,000 --> 00:20:01,000
除，以确保该字符和关键字

306
00:20:01,000 --> 00:20:05,000
是按字母顺序排列的字符也变成为一个整数

307
00:20:05,000 --> 00:20:13,000
在0至25的范围内，然后跳过做到这一点后来在for循环。

308
00:20:13,000 --> 00:20:18,000
同样，你在这里看到的，这真的是完全一样的代码

309
00:20:18,000 --> 00:20:22,000
在这一点上，我们在凯撒。

310
00:20:22,000 --> 00:20:25,000
你这样做完全一样的东西，所以真正的关键是搞清楚

311
00:20:25,000 --> 00:20:30,000
如何把关键字转换为整数。

312
00:20:30,000 --> 00:20:35,000
>> 有一件事，我们在这里做的是有点晦涩难懂

313
00:20:35,000 --> 00:20:39,000
是我们重复这句话，我想你可以称它，

314
00:20:39,000 --> 00:20:45,000
3个独立的上线58，59和61倍。

315
00:20:45,000 --> 00:20:52,000
有人可以解释这句话究竟是什么做的吗？

316
00:20:52,000 --> 00:20:55,000
访问的是一个字符，像你说的。

317
00:20:55,000 --> 00:20:59,000
是的，这是听不见的字符的关键字，

318
00:20:59,000 --> 00:21:04,000
所以它的数量，因为你只沿着看到的字母

319
00:21:04,000 --> 00:21:06,000
关键字，一旦你已经看到了这封信，

320
00:21:06,000 --> 00:21:10,000
因此，要有效地跳过空格之类的东西。

321
00:21:10,000 --> 00:21:12,000
是的，没错。

322
00:21:12,000 --> 00:21:16,000
然后，一旦你已经看到了你刚模的关键字空白，所以你搬回左右。

323
00:21:16,000 --> 00:21:18,000
没错。这是一个完美的解释。

324
00:21:18,000 --> 00:21:23,000
凯文说的是，我们要索引关键字。

325
00:21:23,000 --> 00:21:28,000
我们希望得到字符的num_letters_seen，如果你愿意，

326
00:21:28,000 --> 00:21:32,000
，但如果num_letters_seen超过关键字的长度，

327
00:21:32,000 --> 00:21:37,000
到适当的范围内，我们得到的是我们用mod运算符

328
00:21:37,000 --> 00:21:40,000
有效地环绕。

329
00:21:40,000 --> 00:21:43,000
例如，如在短期内，我们的关键词是腊肉，

330
00:21:43,000 --> 00:21:46,000
和它的5个字母长。

331
00:21:46,000 --> 00:21:50,000
但在这一点上，我们已经看到了6个字母在我们的纯文本

332
00:21:50,000 --> 00:21:52,000
和加密。

333
00:21:52,000 --> 00:21:57,000
我们最终将访问num_letters_seen，

334
00:21:57,000 --> 00:22:00,000
这是模的长度的关键字，5，6，

335
00:22:00,000 --> 00:22:04,000
，所以我们会得到1，而我们要做的是，我们将

336
00:22:04,000 --> 00:22:14,000
在这一点上，我们的关键字内部访问的第一个字符。

337
00:22:14,000 --> 00:22:21,000
>> 所有的权利，任何上维琼内尔的问题

338
00:22:21,000 --> 00:22:26,000
在我们继续之前吗？

339
00:22:26,000 --> 00:22:31,000
你们感觉还不错，对这个吗？

340
00:22:31,000 --> 00:22:35,000
酷，太棒了。

341
00:22:35,000 --> 00:22:38,000
我想，以确保你们有机会看到代码

342
00:22:38,000 --> 00:22:48,000
我们认为看起来不错，有机会向它学习。

343
00:22:48,000 --> 00:22:53,000
这将是最后一次，我们将使用空间的时间是，

344
00:22:53,000 --> 00:22:59,000
我们要转变目前，，我去cs50.net/lectures的

345
00:22:59,000 --> 00:23:06,000
所以我们可以做一点点的测验审查。

346
00:23:06,000 --> 00:23:10,000
我认为最好的方式，开始做测验复习

347
00:23:10,000 --> 00:23:15,000
是来此讲座页，cs50.net/lectures

348
00:23:15,000 --> 00:23:20,000
下一周的标题，所以，如果我在这里看在第0周，

349
00:23:20,000 --> 00:23:27,000
我看到我们有一个列表的主题，我们讨论了在0周。

350
00:23:27,000 --> 00:23:31,000
>> 如果任何这些主题似乎你不熟悉的

351
00:23:31,000 --> 00:23:34,000
你一定要回去和冲刷的讲义，并可能

352
00:23:34,000 --> 00:23:39,000
即使撇去通过讲座，观看他们，如果你想要的

353
00:23:39,000 --> 00:23:44,000
这是怎么回事每个主题的的感觉。

354
00:23:44,000 --> 00:23:49,000
另外，我会说今年的一个很酷的资源，我们已经得到了

355
00:23:49,000 --> 00:23:55,000
是，我们已经创建了这些短裤，如果你看一下在第0周，

356
00:23:55,000 --> 00:24:00,000
我们并没有覆盖所有的主题，但我们已经有了相当多的，

357
00:24:00,000 --> 00:24:03,000
一些棘手的，所以再次看着这些短裤

358
00:24:03,000 --> 00:24:08,000
是一个很好的办法让你加快速度。

359
00:24:08,000 --> 00:24:15,000
特别是，我要在一个插件为3的底部，因为我做了那些。

360
00:24:15,000 --> 00:24:20,000
但是，如果你挣扎二进制位，十六进制，这样的东西，

361
00:24:20,000 --> 00:24:22,000
二进制是一个伟大的地方开始。

362
00:24:22,000 --> 00:24:25,000
ASCII是另外一个，这是很好的查看过。

363
00:24:25,000 --> 00:24:31,000
你甚至可以看我在1.5倍的速度太慢了，如果我要去。

364
00:24:31,000 --> 00:24:35,000
由于它的检讨，觉得要做到这一点。

365
00:24:35,000 --> 00:24:40,000
>> 刚开始真的很快，我们要通过一对夫妇的这些测验的问题

366
00:24:40,000 --> 00:24:44,000
只是通过这些流失。

367
00:24:44,000 --> 00:24:50,000
例如，让我们来看看，我有问题16在黑板上。

368
00:24:50,000 --> 00:24:54,000
我们有以下计算以二进制，

369
00:24:54,000 --> 00:24:56,000
我们想要显示的任何工作。

370
00:24:56,000 --> 00:24:59,000
好吧，我想给这一个镜头。

371
00:24:59,000 --> 00:25:01,000
你们应该跟随纸，

372
00:25:01,000 --> 00:25:04,000
我们会做到这一点真的很快。

373
00:25:04,000 --> 00:25:06,000
我们要的二进制执行下列计算。

374
00:25:06,000 --> 00:25:16,000
我有00110010。

375
00:25:16,000 --> 00:25:27,000
我要添加它00110010。

376
00:25:27,000 --> 00:25:30,000
对于数学天才，在家里，

377
00:25:30,000 --> 00:25:35,000
这是有效地乘以2。

378
00:25:35,000 --> 00:25:37,000
让我们开始。

379
00:25:37,000 --> 00:25:39,000
我们要遵循相同的加法运算，我们做

380
00:25:39,000 --> 00:25:43,000
当我们添加的十进制数。

381
00:25:43,000 --> 00:25:46,000
真的是这里唯一的区别是，我们回圈周围

382
00:25:46,000 --> 00:25:51,000
一旦我们拥有了1 + 1，而不是一旦我们得到10个。

383
00:25:51,000 --> 00:25:53,000
>> 如果我们从右边开始，真的很快，第一个数字吗？

384
00:25:53,000 --> 00:25:55,000
[学生]：0。>> [内特H.] 0。

385
00:25:55,000 --> 00:25:58,000
大，第二个数字吗？

386
00:25:58,000 --> 00:26:00,000
[学生]：1。

387
00:26:00,000 --> 00:26:02,000
[内特H.]它是一个1？ 1 + 1是什么？

388
00:26:02,000 --> 00:26:04,000
[学生]：10。

389
00:26:04,000 --> 00:26:08,000
[内特H.]没错，那么什么是数字，我写的正下方加在一起呢？

390
00:26:08,000 --> 00:26:11,000
[学生] 1，0，0，然后再进行1。

391
00:26:11,000 --> 00:26:15,000
[内特H.] 0和1，携带完全。

392
00:26:15,000 --> 00:26:18,000
接下来一起来，罗勒，该你了。

393
00:26:18,000 --> 00:26:20,000
什么是第三个呢？>> [罗勒] 1。

394
00:26:20,000 --> 00:26:23,000
内特H.] 1，完善。凯文？

395
00:26:23,000 --> 00:26:27,000
[凯文] 0。>> [内特H.] 0，夏洛特？

396
00:26:27,000 --> 00:26:30,000
[山猫] 0。>> [内特H.]是啊，我该怎么办？

397
00:26:30,000 --> 00:26:32,000
[学生]：1。

398
00:26:32,000 --> 00:26:34,000
[内特H.]我该怎么办？然后，我携带1。

399
00:26:34,000 --> 00:26:36,000
完美，Sahb >> [Sahb]现在你有1个。

400
00:26:36,000 --> 00:26:40,000
[内特H.]我在这里做什么？

401
00:26:40,000 --> 00:26:43,000
[Sahb]，然后在你下一次有1个，因为你结转1。

402
00:26:43,000 --> 00:26:49,000
内特H.大，所以在这里我们就可以完成了。

403
00:26:49,000 --> 00:26:51,000
酷。

404
00:26:51,000 --> 00:26:54,000
[学生]：0 + 0 = 0？

405
00:26:54,000 --> 00:26:56,000
0 + 0 = 0。

406
00:26:56,000 --> 00:27:01,000
1 + 1，像你说的，是10个或1，0，而。

407
00:27:01,000 --> 00:27:07,000
10是用词不当，因为我的10是指10号，

408
00:27:07,000 --> 00:27:12,000
这是我们如何代表它时，我们正在编写的怪癖。

409
00:27:12,000 --> 00:27:20,000
我们代表数字2，1，0，和10号是略有不同的。

410
00:27:20,000 --> 00:27:23,000
>> 是一种不错的关于二进制是什么，真的没有那么多的

411
00:27:23,000 --> 00:27:25,000
情况下，你需要学习。

412
00:27:25,000 --> 00:27:30,000
有0 + 0 = 0，0 + 1 = 1，

413
00:27:30,000 --> 00:27:34,000
1 + 1为0，然后再进行1，

414
00:27:34,000 --> 00:27:37,000
然后你可以在这里看到第三列从右边

415
00:27:37,000 --> 00:27:40,000
我们有这个1，1，和1。

416
00:27:40,000 --> 00:27:43,000
和1 + 1 + 1是1，则

417
00:27:43,000 --> 00:27:45,000
携带其他1。

418
00:27:45,000 --> 00:27:48,000
当你做二进制加法，很简单。

419
00:27:48,000 --> 00:27:51,000
完整性检查自己，我做了这些夫妇更

420
00:27:51,000 --> 00:27:54,000
在你走之前，因为这是

421
00:27:54,000 --> 00:28:00,000
或许我们会看到的测验。

422
00:28:00,000 --> 00:28:03,000
现在，让我们做下一个。

423
00:28:03,000 --> 00:28:06,000
让我们做的问题17。

424
00:28:06,000 --> 00:28:12,000
我们将以下二进制数转换为十进制。

425
00:28:12,000 --> 00:28:28,000
我有10100111001。

426
00:28:28,000 --> 00:28:33,000
请记住，在我做的二进制视频

427
00:28:33,000 --> 00:28:36,000
我走过一对夫妇的例子，我展示了如何

428
00:28:36,000 --> 00:28:41,000
一切正常，当你这样做是在十进制。

429
00:28:41,000 --> 00:28:45,000
当你在工作中的十进制表示，我认为，我们

430
00:28:45,000 --> 00:28:48,000
这一点在我们的生活中，流利的

431
00:28:48,000 --> 00:28:53,000
这是很容易掩饰它是如何工作的机制。

432
00:28:53,000 --> 00:28:59,000
>> 但是，要做到快速回顾一下，如果我有137

433
00:28:59,000 --> 00:29:06,000
这实际上意味着再次，这是在十进制表示

434
00:29:06,000 --> 00:29:19,000
十进制的137，我有1×100 + 3×10 + 7×1。

435
00:29:19,000 --> 00:29:22,000
这一切都停留在屏幕上。

436
00:29:22,000 --> 00:29:29,000
然后，如果你看看这些数字就在这里，

437
00:29:29,000 --> 00:29:34,000
100，10，1，你看，它们实际上是一切权力的10。

438
00:29:34,000 --> 00:29:43,000
我有10 2，10 1，和10到零。

439
00:29:43,000 --> 00:29:48,000
我们有一个相类似的事情在二进制，

440
00:29:48,000 --> 00:29:55,000
除了我们的基地，我们把它称为是2，而不是10。

441
00:29:55,000 --> 00:29:58,000
这些10秒，我在这里写下的底部，

442
00:29:58,000 --> 00:30:02,000
这10 2，10 1，10到零，10是我们的基地，

443
00:30:02,000 --> 00:30:08,000
和指数，0，1，或2，

444
00:30:08,000 --> 00:30:14,000
是隐含的数量，我们写的数字的位置。

445
00:30:14,000 --> 00:30:21,000
1，如果我们看一下吧，这是在第二的位置。

446
00:30:21,000 --> 00:30:27,000
图3是在第一位置，和图7是在第0个位置。

447
00:30:27,000 --> 00:30:35,000
这就是我们得到的各种指数，以下为我们的基地。

448
00:30:35,000 --> 00:30:40,000
>> 在此我们将实际，你知道吗？

449
00:30:40,000 --> 00:30:43,000
我们会尽我撤消“按钮去了？

450
00:30:43,000 --> 00:30:45,000
就这样吧。

451
00:30:45,000 --> 00:30:47,000
我喜欢这撤消事情。

452
00:30:47,000 --> 00:30:51,000
在此，我认为至少对我来说

453
00:30:51,000 --> 00:30:54,000
最简单的方法开始将二进制数转换

454
00:30:54,000 --> 00:30:57,000
或十六进制数，其中的碱是16

455
00:30:57,000 --> 00:31:02,000
而不是10或2继续前进，写出来的

456
00:31:02,000 --> 00:31:09,000
我在上面的二进制数中的数字的基准和指数。

457
00:31:09,000 --> 00:31:14,000
如果我们开始从左至右再次，

458
00:31:14,000 --> 00:31:17,000
这是一种违反直觉的，

459
00:31:17,000 --> 00:31:23,000
我会重新变回黑色在这里，我们有2至第0个位置，

460
00:31:23,000 --> 00:31:27,000
然后我们有2 1，2 2，

461
00:31:27,000 --> 00:31:33,000
然后2 3，2 4，2 5，6，

462
00:31:33,000 --> 00:31:39,000
7，8，9和10。

463
00:31:39,000 --> 00:31:41,000
我已经写了这些数字是所有的指数。

464
00:31:41,000 --> 00:31:48,000
我只写了基地在第3的空间。

465
00:31:48,000 --> 00:31:50,000
>> 在这一点上，我要继续前进，我要删除

466
00:31:50,000 --> 00:31:53,000
的东西，我们在小数，如果那也没关系。

467
00:31:53,000 --> 00:31:57,000
你都明白了。

468
00:31:57,000 --> 00:32:05,000
你看网上我敢肯定，将能够倒带我，如果你想。

469
00:32:05,000 --> 00:32:07,000
切换回笔。

470
00:32:07,000 --> 00:32:12,000
现在，我们可以做的，如果你们不完全取决于你的权力，以加快2，

471
00:32:12,000 --> 00:32:15,000
这是很酷。

472
00:32:15,000 --> 00:32:18,000
它发生。我明白了。

473
00:32:18,000 --> 00:32:23,000
我曾经有一个面试时，有人告诉我，我应该知道的一切权力2

474
00:32:23,000 --> 00:32:26,000
通过2的30。

475
00:32:26,000 --> 00:32:29,000
这不是我的工作。

476
00:32:29,000 --> 00:32:32,000
总之，你们可以继续在这里做数学题，

477
00:32:32,000 --> 00:32:35,000
但与二进制文件，它不是真正意义的，

478
00:32:35,000 --> 00:32:38,000
它也不有意义的十进制或十六进制，

479
00:32:38,000 --> 00:32:43,000
做数学题，你在哪里有零。

480
00:32:43,000 --> 00:32:49,000
你可以看到我有0在这里，这里的0，0在这里，在这里，在这里，在这里。

481
00:32:49,000 --> 00:32:52,000
为什么它可能没有任何意义，做实际的数学

482
00:32:52,000 --> 00:32:56,000
该位置计算出相应的功率为2？

483
00:32:56,000 --> 00:32:59,000
没错，像夏洛特说，这将是0。

484
00:32:59,000 --> 00:33:05,000
还不如节省自己的时间，如果计算2的幂是不是你的强项。

485
00:33:05,000 --> 00:33:10,000
在这种情况下，我们只需要计算它的0-2？

486
00:33:10,000 --> 00:33:12,000
[学生]：1。

487
00:33:12,000 --> 00:33:14,000
[内特H.] 1，2到3是-？

488
00:33:14,000 --> 00:33:16,000
[学生] >> [内特H.] 8。

489
00:33:16,000 --> 00:33:18,000
2到4？

490
00:33:18,000 --> 00:33:21,000
[学生]：2。对不起，1。

491
00:33:21,000 --> 00:33:26,000
[内特H.] 2至4是16的，没错。

492
00:33:26,000 --> 00:33:28,000
2到5，凯文？>> 32。

493
00:33:28,000 --> 00:33:32,000
[内特H.] 32，2到8？

494
00:33:32,000 --> 00:33:38,000
[学生]：32×8，256。

495
00:33:38,000 --> 00:33:41,000
[内特H.]完美。

496
00:33:41,000 --> 00:33:43,000
和2至10吗？

497
00:33:43,000 --> 00:33:45,000
[学生] 1024。

498
00:33:45,000 --> 00:33:49,000
[内特H.]是啊，1024。

499
00:33:49,000 --> 00:33:57,000
>> 一旦我们得到这些数字，我们可以总结他们所有。

500
00:33:57,000 --> 00:34:01,000
这是它做的几件事情是非常重要的。

501
00:34:01,000 --> 00:34:07,000
一个缓慢，并检查您的工作。

502
00:34:07,000 --> 00:34:10,000
在年底这个数字，你可以告诉大家有一个1，

503
00:34:10,000 --> 00:34:15,000
我的结果，所以我一定要得到一个奇数，

504
00:34:15,000 --> 00:34:18,000
因为所有其他的人都将是偶数

505
00:34:18,000 --> 00:34:21,000
因为，这是一个二进制数。

506
00:34:21,000 --> 00:34:24,000
其他的事情是，如果你得到这一点在测试

507
00:34:24,000 --> 00:34:27,000
你写的这一步

508
00:34:27,000 --> 00:34:30,000
和你的时间不多了

509
00:34:30,000 --> 00:34:33,000
看的点的数量，此问题是值得的。

510
00:34:33,000 --> 00:34:40,000
这个问题，你可以看到，如果我迅速翻转回我的笔记本电脑真的，

511
00:34:40,000 --> 00:34:44,000
这个问题是值得2分，所以这不是那种此外

512
00:34:44,000 --> 00:34:47,000
你应当经历的，如果你真的时间紧迫。

513
00:34:47,000 --> 00:34:52,000
但我们会切换到iPad上，我们将通过它真的很快。

514
00:34:52,000 --> 00:34:54,000
>> 我喜欢做的小数字第一

515
00:34:54,000 --> 00:34:56,000
因为我发现，更容易。

516
00:34:56,000 --> 00:35:00,000
我喜欢32和8，因为他们走在一起很容易，我们得到50。

517
00:35:00,000 --> 00:35:03,000
16和1得到17。

518
00:35:03,000 --> 00:35:05,000
在那里，我们得到57，

519
00:35:05,000 --> 00:35:14,000
然后，我们可以做的其余部分，所以我们可以做的57，156。

520
00:35:14,000 --> 00:35:16,000
来吧。

521
00:35:16,000 --> 00:35:19,000
人，好了，让我们来看看。

522
00:35:19,000 --> 00:35:27,000
我们有57，256和1024。

523
00:35:27,000 --> 00:35:31,000
在这一点上，我宁愿去。

524
00:35:31,000 --> 00:35:35,000
我不知道。我清楚地读了。

525
00:35:35,000 --> 00:35:40,000
7，6，和4中，您可以在17。

526
00:35:40,000 --> 00:35:42,000
1，5，5，2，13。

527
00:35:42,000 --> 00:35:45,000
然后，我们得到了3，然后我们得到1。

528
00:35:45,000 --> 00:35:52,000
1337年。

529
00:35:52,000 --> 00:35:55,000
复活节彩蛋，任何人？

530
00:35:55,000 --> 00:35:59,000
任何人都承认这个数字吗？

531
00:35:59,000 --> 00:36:02,000
克里斯识别数字。是什么意思，克里斯？

532
00:36:02,000 --> 00:36:04,000
[克里斯] LEET。

533
00:36:04,000 --> 00:36:11,000
LEET，所以如果你看看这个，它看起来像利特。

534
00:36:11,000 --> 00:36:15,000
黑客的东西。注意在期中考试或测验，而这样的东西。

535
00:36:15,000 --> 00:36:19,000
如果你看到这样的东西，你想知道“咦”

536
00:36:19,000 --> 00:36:22,000
这可能意味着什么。

537
00:36:22,000 --> 00:36:24,000
我不知道。大卫喜欢它。

538
00:36:24,000 --> 00:36:26,000
这是一个好办法，完整性检查。

539
00:36:26,000 --> 00:36:30,000
像好吧，我可以看看会发生什么。

540
00:36:30,000 --> 00:36:34,000
>> 这是周0/Week东西。

541
00:36:34,000 --> 00:36:39,000
如果我们切换到我们的笔记本电脑，现在，

542
00:36:39,000 --> 00:36:46,000
缩小，和一些其他的事情。

543
00:36:46,000 --> 00:36:50,000
有ASCII，这是我们已经做了很多的问题集。

544
00:36:50,000 --> 00:36:55,000
A.资本这个概念什么是真的吗？

545
00:36:55,000 --> 00:36:57,000
知道它的十进制整数。

546
00:36:57,000 --> 00:37:00,000
65是它被映射到ASCII表中，

547
00:37:00,000 --> 00:37:03,000
因此，这是电脑如何写，

548
00:37:03,000 --> 00:37:06,000
这就是我们已经越来越远，其实写

549
00:37:06,000 --> 00:37:09,000
字符大写字母A和字符小写的a

550
00:37:09,000 --> 00:37:14,000
在一些你一直在做的这些解决方案和习题集。

551
00:37:14,000 --> 00:37:16,000
一对夫妇的其他东西。

552
00:37:16,000 --> 00:37:25,000
我们有报表，布尔表达式，条件，循环，变量和线程。

553
00:37:25,000 --> 00:37:29,000
>> 这些都似乎最有意义吗？

554
00:37:29,000 --> 00:37:35,000
这个术语有时是有点时髦的。

555
00:37:35,000 --> 00:37:46,000
我喜欢的一份声明中认为，大部分的东西，以一个分号结束。

556
00:37:46,000 --> 00:37:51,000
报表如x = 7，设置一个变量，

557
00:37:51,000 --> 00:37:54,000
想必称为x = 7。

558
00:37:54,000 --> 00:38:01,000
据推测x是一个类型，可以存储数字7，

559
00:38:01,000 --> 00:38:05,000
因此它可能是一个int或float或短或一个字符，

560
00:38:05,000 --> 00:38:07,000
类似的东西。

561
00:38:07,000 --> 00:38:12,000
布尔表达式是使用这些双等号

562
00:38:12,000 --> 00:38:17,000
爆炸等于或不等于，小于，大于，

563
00:38:17,000 --> 00:38:22,000
小于或等于，所有这样的东西。

564
00:38:22,000 --> 00:38:28,000
条件是if else语句。

565
00:38:28,000 --> 00:38:32,000
我会记住，你不能有别的没有相应的如果。

566
00:38:32,000 --> 00:38:37,000
同样，你可以没有其他，如果没有相应的如果。

567
00:38:37,000 --> 00:38:40,000
循环，召回的3种循环已经被锤打成

568
00:38:40,000 --> 00:38:43,000
特别是最近几个部分和习题集。

569
00:38:43,000 --> 00:38:46,000
使用，而当你获取用户输入，

570
00:38:46,000 --> 00:38:51,000
使用whil​​e循环，直到特定的条件是真实的，

571
00:38:51,000 --> 00:38:56,000
然后利用这些循环，如果你需要的

572
00:38:56,000 --> 00:39:01,000
你知道循环迭代目前是我想想。

573
00:39:01,000 --> 00:39:07,000
或者，如果你做了我想要做的事情在一个字符串中的每个字符，

574
00:39:07,000 --> 00:39:15,000
我想要做的事，该元素在数组中的每个元素。

575
00:39:15,000 --> 00:39:18,000
>> 线程和事件。

576
00:39:18,000 --> 00:39:21,000
这些我们还没有涉及到明确在C中，

577
00:39:21,000 --> 00:39:23,000
但是请记住这个从头开始。

578
00:39:23,000 --> 00:39:26,000
这是概念具有不同的脚本。

579
00:39:26,000 --> 00:39:32,000
广播事件，这也是这个概念。

580
00:39:32,000 --> 00:39:37,000
有些人不使用广播最初在自己的项目，

581
00:39:37,000 --> 00:39:40,000
这是很酷的，

582
00:39:40,000 --> 00:39:46,000
但这些都被称为并发两种不同的方式处理这个更大的问题，

583
00:39:46,000 --> 00:39:49,000
这是你如何让程序执行

584
00:39:49,000 --> 00:39:54,000
或看似同时执行？

585
00:39:54,000 --> 00:39:59,000
不同的任务运行，而其他任务同时运行。

586
00:39:59,000 --> 00:40:01,000
这是你的操作系统是如何工作的。

587
00:40:01,000 --> 00:40:04,000
这就是为什么，即使，例如，

588
00:40:04,000 --> 00:40:10,000
我有我的浏览器中运行，我也可以将Spotify的，播放一首歌曲。

589
00:40:10,000 --> 00:40:14,000
这是一个概念性的东西了解。

590
00:40:14,000 --> 00:40:17,000
我想看一看线程的短

591
00:40:17,000 --> 00:40:21,000
如果您想了解更多关于。

592
00:40:21,000 --> 00:40:26,000
>> 让我们来看看，我认为有可能是

593
00:40:26,000 --> 00:40:31,000
其中的一个一个问题，在这个问题上。

594
00:40:31,000 --> 00:40:35,000
同样，我认为是不是线程和事件，我们将介绍在C

595
00:40:35,000 --> 00:40:41,000
只是因为它的显着更多的困难比在Scratch。

596
00:40:41,000 --> 00:40:44,000
你不应该担心它有，但绝对明白的概念，

597
00:40:44,000 --> 00:40:47,000
明白发生了什么事情。

598
00:40:47,000 --> 00:40:52,000
在我们继续之前，任何问题上0周材料？

599
00:40:52,000 --> 00:40:55,000
每个人都感觉还不错呢？

600
00:40:55,000 --> 00:41:03,000
了解变量，什么是变量？

601
00:41:03,000 --> 00:41:08,000
>> 移动。每周1次。

602
00:41:08,000 --> 00:41:12,000
一对夫妇的事情，在这里，没有覆盖

603
00:41:12,000 --> 00:41:21,000
在测验审查必要的，也有更多的概念性的东西，去思考。

604
00:41:21,000 --> 00:41:30,000
首先是这个概念的源代码，编译代码和目标代码是什么。

605
00:41:30,000 --> 00:41:32,000
任何人？罗勒。

606
00:41:32,000 --> 00:41:37,000
是对象的代码，我的意思是源代码是什么，你把铛，

607
00:41:37,000 --> 00:41:42,000
代码和目标代码是什么铛放出来，让您的计算机可以读取的程序。

608
00:41:42,000 --> 00:41:44,000
没错。

609
00:41:44,000 --> 00:41:47,000
源代码是C代码，您输入。

610
00:41:47,000 --> 00:41:50,000
目标代码是你得到了什么铛。

611
00:41:50,000 --> 00:41:54,000
这是“0”和“1，二进制格式。

612
00:41:54,000 --> 00:41:59,000
那会发生什么情况是，当你有一大堆的目标文件，

613
00:41:59,000 --> 00:42:04,000
说你要编译一个项目或程序使用多个源代码文件，

614
00:42:04,000 --> 00:42:09,000
按照惯例给定的文件扩展名。

615
00:42:09,000 --> 00:42:13,000
那为什么我们caesar.c，vigenère.c。

616
00:42:13,000 --> 00:42:18,000
如果你正在编写Java程序，你给他们的。java扩展名。

617
00:42:18,000 --> 00:42:24,000
Python程序。py扩展名通常。

618
00:42:24,000 --> 00:42:26,000
>> 一旦你有多个c文件，编译它们。

619
00:42:26,000 --> 00:42:29,000
铛吐出了这一切二进制垃圾。

620
00:42:29,000 --> 00:42:33,000
然后，因为你只需要1个程序

621
00:42:33,000 --> 00:42:37,000
你有链接器链接所有这些对象文件一起

622
00:42:37,000 --> 00:42:40,000
为1可执行文件。

623
00:42:40,000 --> 00:42:45,000
这也是发生了什么，当你使用的CS50库，例如。

624
00:42:45,000 --> 00:42:50,000
CS50库既h头文件。

625
00:42:50,000 --> 00:42:53,000
您阅读，＃includecs50.h。

626
00:42:53,000 --> 00:42:58,000
那么它也是一个特殊的二进制库文件

627
00:42:58,000 --> 00:43:02,000
被编译的，是“0”和“1，

628
00:43:02,000 --> 00:43:08,000
和-L标志，因此，如果我们回到我们的空间，我们期待真的很快

629
00:43:08,000 --> 00:43:11,000
在这里发生了什么事情，当我们看我们的铛命令，

630
00:43:11,000 --> 00:43:15,000
我们得到的是在这里，这是我们的源代码文件。

631
00:43:15,000 --> 00:43:18,000
这是一群编译器的标志。

632
00:43:18,000 --> 00:43:22,000
然后在最后，这些在-l标志链接

633
00:43:22,000 --> 00:43:30,000
实际的二进制文件，这2个库，的CS50库，然后数学库。

634
00:43:30,000 --> 00:43:35,000
>> 了解每种类型的文件的目的

635
00:43:35,000 --> 00:43:38,000
在编译过程中，你要的东西能够

636
00:43:38,000 --> 00:43:43,000
至少给一个高层次的概述。

637
00:43:43,000 --> 00:43:46,000
源代码的原因。目标代码出来。

638
00:43:46,000 --> 00:43:53,000
目标代码文件链接在一起，你会得到一个美丽的，可执行文件。

639
00:43:53,000 --> 00:43:55,000
酷。

640
00:43:55,000 --> 00:43:58,000
这也是在那里你可以得到的错误在多点

641
00:43:58,000 --> 00:44:00,000
在编译过程中。

642
00:44:00,000 --> 00:44:04,000
这是在哪里，例如，如果你把这个连接的标志，

643
00:44:04,000 --> 00:44:10,000
CS50标志，你忽略它在空间，或当你运行你的代码，

644
00:44:10,000 --> 00:44:13,000
这是在那里你会得到一个错误的链接阶段，

645
00:44:13,000 --> 00:44:18,000
和链接器会说：“嘿，你调用一个函数的GetString

646
00:44:18,000 --> 00:44:20,000
这是在的CS50库。“

647
00:44:20,000 --> 00:44:25,000
“你告诉我是在CS50库，我无法找到它的代码。”

648
00:44:25,000 --> 00:44:28,000
这就是你有链接，这就是独立的

649
00:44:28,000 --> 00:44:33,000
从一个编译错误，因为编译器的语法和诸如此类的东西。

650
00:44:33,000 --> 00:44:38,000
知道发生了什么事情的时候，这是很好的。

651
00:44:38,000 --> 00:44:42,000
>> 其他的事情了解。

652
00:44:42,000 --> 00:44:49,000
我会说，你一定要来看看短的类型转换通过约旦

653
00:44:49,000 --> 00:44:55,000
了解整数是什么引擎盖下，

654
00:44:55,000 --> 00:44:58,000
引擎盖下的是什么字符。

655
00:44:58,000 --> 00:45:02,000
当我们谈论的ASCII和我们其实看的ASCII表，

656
00:45:02,000 --> 00:45:07,000
什么做的是给了我们一个引擎盖下的样子

657
00:45:07,000 --> 00:45:13,000
如何在计算机实际上代表了资本和数字7

658
00:45:13,000 --> 00:45:17,000
一个逗号和问号。

659
00:45:17,000 --> 00:45:20,000
电脑还具有特殊的方式来表示

660
00:45:20,000 --> 00:45:23,000
为一个整数的数目7。

661
00:45:23,000 --> 00:45:27,000
它有一个特殊的方式来表示一个浮点数7号，

662
00:45:27,000 --> 00:45:29,000
有很大的不同。

663
00:45:29,000 --> 00:45:32,000
类型转换是如何告诉计算机“嘿，我想你转换

664
00:45:32,000 --> 00:45:37,000
从一个表示的另一种表示。“

665
00:45:37,000 --> 00:45:40,000
我们为什么不来看看在那。

666
00:45:40,000 --> 00:45:44,000
>> 我也来看看在短库和短期的编译器上。

667
00:45:44,000 --> 00:45:47,000
那些谈论编译的过程中，

668
00:45:47,000 --> 00:45:53,000
图书馆是什么，并去了其中的一些问题，你可能会问。

669
00:45:53,000 --> 00:45:55,000
上一周1材料？

670
00:45:55,000 --> 00:46:03,000
在这里，令人望而生畏你想覆盖的任何话题？

671
00:46:03,000 --> 00:46:07,000
我企图炸毁通过这些早期的主题，因此，我们可以得到

672
00:46:07,000 --> 00:46:13,000
指针和做一点点的递归。

673
00:46:13,000 --> 00:46:15,000
思考？

674
00:46:15,000 --> 00:46:19,000
凡是有哪些？

675
00:46:19,000 --> 00:46:21,000
一些巧克力可能的时间？

676
00:46:21,000 --> 00:46:23,000
你们正在通过它。

677
00:46:23,000 --> 00:46:26,000
我要在我的咖啡喝着。

678
00:46:26,000 --> 00:46:31,000
第2周。

679
00:46:31,000 --> 00:46:34,000
良好的通话，良好的通话。

680
00:46:34,000 --> 00:46:38,000
在第2周，我们谈了一点点更多的功能。

681
00:46:38,000 --> 00:46:43,000
>> 在最初的几个问题集，我们并没有真正写在所有的任何功能

682
00:46:43,000 --> 00:46:45,000
以外的功能吗？

683
00:46:45,000 --> 00:46:47,000
[学生]主。>>主，准确。

684
00:46:47,000 --> 00:46:51,000
所以，我们看到了不同的服饰，主要穿。

685
00:46:51,000 --> 00:46:54,000
它不带任何参数，

686
00:46:54,000 --> 00:46:58,000
我们只说在括号之间的空白，

687
00:46:58,000 --> 00:47:01,000
然后有另外一个我们要采取命令行参数，

688
00:47:01,000 --> 00:47:08,000
正如我们所看到的，这就是你有int argc和字符串argv数组

689
00:47:08,000 --> 00:47:13,000
现在我们实际上已经暴露字符串的char *，它是

690
00:47:13,000 --> 00:47:20,000
我们要开始写为char * argv和括号。

691
00:47:20,000 --> 00:47:22,000
习题集3，你们看到了一堆的功能，

692
00:47:22,000 --> 00:47:27,000
实施了一堆的功能，画画，看后，争夺战。

693
00:47:27,000 --> 00:47:31,000
的原型都写在你身边。

694
00:47:31,000 --> 00:47:33,000
>> 我想在这里谈论与功能真的很快

695
00:47:33,000 --> 00:47:38,000
有3个部分，只要你写一个函数。

696
00:47:38,000 --> 00:47:43,000
你必须指定返回类型的函数。

697
00:47:43,000 --> 00:47:46,000
你必须指定一个函数名称，然后你必须指定

698
00:47:46,000 --> 00:47:51,000
参数列表参数列表。

699
00:47:51,000 --> 00:47:57,000
例如，如果我写一个函数来汇总了一堆的整数

700
00:47:57,000 --> 00:48:03,000
然后回到我这里来的总和，这将是我的返回类型

701
00:48:03,000 --> 00:48:06,000
如果我想总结的整数，然后返回的总和吗？

702
00:48:06,000 --> 00:48:12,000
然后的函数名。

703
00:48:12,000 --> 00:48:27,000
如果我继续写在绿色，这部分是返回类型。

704
00:48:27,000 --> 00:48:34,000
这部分的名称。

705
00:48:34,000 --> 00:48:40,000
然后在括号之间的

706
00:48:40,000 --> 00:48:46,000
是我给的参数，

707
00:48:46,000 --> 00:48:56,000
通常缩写为args，有时也被称为参数的参数的。

708
00:48:56,000 --> 00:49:00,000
如果你有一个，您只需指定一个。

709
00:49:00,000 --> 00:49:06,000
如果您有多个，用逗号分开，每一个。

710
00:49:06,000 --> 00:49:13,000
为每一个参数，你给它两件事情是凯文？

711
00:49:13,000 --> 00:49:18,000
[凯文]你有给类型及名称。

712
00:49:18,000 --> 00:49:21,000
然后的名称的名称是您要使用的名称

713
00:49:21,000 --> 00:49:25,000
的金额范围内功能是指这样的说法，

714
00:49:25,000 --> 00:49:27,000
在函数内，您目前正在编写的。

715
00:49:27,000 --> 00:49:32,000
>> 您不必例如，如果我要总结，

716
00:49:32,000 --> 00:49:41,000
也就是说，一个数组的整数 - 我们将做的int数组，

717
00:49:41,000 --> 00:49:46,000
我给自己一些花括号

718
00:49:46,000 --> 00:49:51,000
然后，当我传递一个数组的总和功能

719
00:49:51,000 --> 00:49:55,000
我把它的参数列表中的第一个位置。

720
00:49:55,000 --> 00:49:59,000
但传递的数组，我不必有名字改编。

721
00:49:59,000 --> 00:50:07,000
到达将是我指的是身体内的功能，参数。

722
00:50:07,000 --> 00:50:10,000
其他的事情，我们需要考虑到，

723
00:50:10,000 --> 00:50:14,000
，这是从功能略有不同，但我认为这是一个很重要的一点，

724
00:50:14,000 --> 00:50:20,000
是，在C，当我在写一个这样的函数

725
00:50:20,000 --> 00:50:29,000
我怎么知道这个数组有多少元素？

726
00:50:29,000 --> 00:50:31,000
这是有点一个棘手的问题。

727
00:50:31,000 --> 00:50:35,000
我们谈到这一点在上周的部分。

728
00:50:35,000 --> 00:50:40,000
我怎么知道在C数组里面的元素的数量？

729
00:50:40,000 --> 00:50:44,000
有没有办法呢？

730
00:50:44,000 --> 00:50:49,000
>> 事实证明，有没有办法知道。

731
00:50:49,000 --> 00:50:52,000
你必须通过它分别。

732
00:50:52,000 --> 00:50:55,000
有一个技巧，你可以做

733
00:50:55,000 --> 00:51:00,000
如果你在相同的阵列功能，其中已申报，

734
00:51:00,000 --> 00:51:04,000
你正在使用的堆栈阵列。

735
00:51:04,000 --> 00:51:06,000
但是，这只是工作，如果你在相同的功能。

736
00:51:06,000 --> 00:51:09,000
一旦你将数组传递给另一个函数，或者，如果你已经声明数组

737
00:51:09,000 --> 00:51:12,000
你把该数组在堆上，你使用的malloc

738
00:51:12,000 --> 00:51:15,000
 和这样的东西，那么所有的赌注都关闭。

739
00:51:15,000 --> 00:51:18,000
然后，你必须通过左右

740
00:51:18,000 --> 00:51:21,000
一个特殊的参数或其他参数

741
00:51:21,000 --> 00:51:23,000
告诉你有多大的数组。

742
00:51:23,000 --> 00:51:28,000
在这种情况下，对不起，这是怎么回事了屏幕在这里，我想使用一个逗号，我

743
00:51:28,000 --> 00:51:32,000
我会通过另一种说法

744
00:51:32,000 --> 00:51:40,000
 ，诠释莱恩的长度。

745
00:51:40,000 --> 00:51:44,000
>> 有一件事可能遇到的测验

746
00:51:44,000 --> 00:51:49,000
要求你写或执行特定的功能叫什么。

747
00:51:49,000 --> 00:51:54,000
如果我们不给你的原型，所以这整个事情在这里，

748
00:51:54,000 --> 00:51:58,000
这全乱了调用该函数的声明或函数原型，

749
00:51:58,000 --> 00:52:01,000
这是一个的第一件事情，你会想要确定下来，如果它不给

750
00:52:01,000 --> 00:52:03,000
你马上测验。

751
00:52:03,000 --> 00:52:06,000
我已经学会的技巧是：

752
00:52:06,000 --> 00:52:11,000
说，我们给你一个函数的原型，和我们说，“嘿，你得把它写。”

753
00:52:11,000 --> 00:52:16,000
在大括号中，你必须在测验

754
00:52:16,000 --> 00:52:20,000
如果您发现有一个返回类型，你注意到的返回类型

755
00:52:20,000 --> 00:52:25,000
是无效，这意味着该函数不返回任何东西以外的东西，

756
00:52:25,000 --> 00:52:28,000
然后一件事，你一定要做到的是写

757
00:52:28,000 --> 00:52:33,000
某种类型的return语句在最后的功能。

758
00:52:33,000 --> 00:52:40,000
返回，在这种情况下，我们会把一个空白，因为我们要填补的空白。

759
00:52:40,000 --> 00:52:44,000
但是，这可以让你想以正确的方式，我要如何解决这个问题呢？

760
00:52:44,000 --> 00:52:49,000
它提醒你，你要返回一个值

761
00:52:49,000 --> 00:52:51,000
该函数的调用者。

762
00:52:51,000 --> 00:52:54,000
>> 是啊。>> [学生]：风格当我们编写代码的测验？

763
00:52:54,000 --> 00:52:58,000
如缩进和这样的东西吗？>> [学生]：是的。

764
00:52:58,000 --> 00:53:00,000
不，没有那么多。

765
00:53:00,000 --> 00:53:09,000
我想了很多，这是我们的日子会澄清的测验，

766
00:53:09,000 --> 00:53:15,000
但通常担心的＃include，这样的东西，它是一种外。

767
00:53:15,000 --> 00:53:17,000
[学生]：你需要回应你的手写代码？

768
00:53:17,000 --> 00:53:19,000
你需要回应你的手写代码吗？

769
00:53:19,000 --> 00:53:24,000
谈到始终是一件好事，如果你担心部分信贷

770
00:53:24,000 --> 00:53:29,000
或者你想传达你的意图，平地机。

771
00:53:29,000 --> 00:53:33,000
但是，我再次将澄清的测验和测验的一天，

772
00:53:33,000 --> 00:53:39,000
但我不相信你会被要求写评论，没有。

773
00:53:39,000 --> 00:53:42,000
通常不会，但它绝对是诸如此类的事情，

774
00:53:42,000 --> 00:53:45,000
你可以传达你的意图，想：“嘿，这是我要去的地方用它。”

775
00:53:45,000 --> 00:53:49,000
有时，可以帮助部分信贷。

776
00:53:49,000 --> 00:53:51,000
酷。

777
00:53:51,000 --> 00:53:53,000
>> 罗勒。

778
00:53:53,000 --> 00:53:56,000
[罗勒]声明说，INT郎之间的区别是什么

779
00:53:56,000 --> 00:54:03,000
在与声明一个变量，在函数中的参数或参数？

780
00:54:03,000 --> 00:54:05,000
哇，咖啡去了气管。

781
00:54:05,000 --> 00:54:07,000
[罗勒]喜欢的事情，我们希望把在参数。

782
00:54:07,000 --> 00:54:09,000
是啊，这是一个很大的问题。

783
00:54:09,000 --> 00:54:11,000
你会选择什么样的事情，你要投入的参数

784
00:54:11,000 --> 00:54:17,000
对你应该做的事里面的功能是什么？

785
00:54:17,000 --> 00:54:24,000
在这种情况下，我们这两个参数

786
00:54:24,000 --> 00:54:29,000
因为他们的东西，不管是谁去使用SUM函数

787
00:54:29,000 --> 00:54:32,000
需要指定这些事情。

788
00:54:32,000 --> 00:54:35,000
>> 和功能，像我们谈到了，有没有办法知道

789
00:54:35,000 --> 00:54:40,000
有多大的数组是得到它的调用者或任何人使用SUM函数。

790
00:54:40,000 --> 00:54:44,000
它没有办法知道这个数组有多大。

791
00:54:44,000 --> 00:54:48,000
我们之所以在这里通过这个长度作为参数

792
00:54:48,000 --> 00:54:51,000
是因为在这个时候，我们基本上是告诉来电者的功能，

793
00:54:51,000 --> 00:54:55,000
谁是将要使用SUM函数，“嘿，不仅你得给我们一个数组

794
00:54:55,000 --> 00:54:59,000
整数，你也必须告诉我们有多大的数组，你已经给了我们。“

795
00:54:59,000 --> 00:55:03,000
[罗勒这些都将是命令行参数？

796
00:55:03,000 --> 00:55:06,000
没有，这些都是实实在在的，你会传递给函数的参数。

797
00:55:06,000 --> 00:55:10,000
>> 让我在这里做了新的一页。

798
00:55:10,000 --> 00:55:13,000
[罗勒]喜欢的名字将传递

799
00:55:13,000 --> 00:55:24,000
[内特H.]如果我有诠释的主要（无效），

800
00:55:24,000 --> 00:55:27,000
我要把我返回0，在这里的底部，

801
00:55:27,000 --> 00:55:31,000
并说我要打电话功能的总和。

802
00:55:31,000 --> 00:55:42,000
我想说的诠释x = SUM（）;

803
00:55:42,000 --> 00:55:46,000
使用SUM函数，我想总结的，我必须要通过在阵列

804
00:55:46,000 --> 00:55:51,000
和阵列的长度，所以这是

805
00:55:51,000 --> 00:55:54,000
假设我有一个整型数组，

806
00:55:54,000 --> 00:56:12,000
说我有numbaz [] = 1，2，3，

807
00:56:12,000 --> 00:56:16,000
种使用砍死语法正确，

808
00:56:16,000 --> 00:56:21,000
然后我会做什么，总之，我希望通过

809
00:56:21,000 --> 00:56:27,000
两个numbaz和3号

810
00:56:27,000 --> 00:56:30,000
告诉SUM函数“好了，在这里我要你总结的阵列。”

811
00:56:30,000 --> 00:56:34,000
“这是它的大小。”

812
00:56:34,000 --> 00:56:39,000
这是否有意义吗？回答你的问题吗？

813
00:56:39,000 --> 00:56:42,000
>> 在许多方面，它平行的就是我们正在做的主要

814
00:56:42,000 --> 00:56:44,000
当我们有命令行参数。

815
00:56:44,000 --> 00:56:47,000
像恺撒密码的程序，例如，需要

816
00:56:47,000 --> 00:56:53,000
命令行参数将无法做任何事情。

817
00:56:53,000 --> 00:56:57,000
不知道如何进行加密，如果你没有告诉它使用什​​么键

818
00:56:57,000 --> 00:57:03,000
或者，如果你没有告诉它你想加密的字符串。

819
00:57:03,000 --> 00:57:08,000
提示输入，这是我们已经有2个不同的机制

820
00:57:08,000 --> 00:57:14,000
用于输入来自用户的，在来自用户的信息采取。

821
00:57:14,000 --> 00:57:19,000
对于问题1，我们看到这个调用getInt，GetString的，GetFloat的方式

822
00:57:19,000 --> 00:57:26,000
提示输入，这就是所谓的使用标准输入流。

823
00:57:26,000 --> 00:57:28,000
这是稍有不同。

824
00:57:28,000 --> 00:57:31,000
这件事情，你可以做一次，而不是

825
00:57:31,000 --> 00:57:35,000
当你调用程序，当您启动程序的运行。

826
00:57:35,000 --> 00:57:41,000
所有的命令行参数指定当您启动程序运行。

827
00:57:41,000 --> 00:57:47,000
我们已经将两个。

828
00:57:47,000 --> 00:57:52,000
当我们使用参数的函数，这是非常类似的命令行参数主要。

829
00:57:52,000 --> 00:57:56,000
这是当你调用这个函数，你需要告诉它

830
00:57:56,000 --> 00:58:05,000
它究竟是什么的需要，以执行其任务。

831
00:58:05,000 --> 00:58:08,000
另一个好处看，我就让你看看它在你的空余时间，

832
00:58:08,000 --> 00:58:11,000
它覆盖在测验是这个概念的范围

833
00:58:11,000 --> 00:58:15,000
与全局变量和局部变量。

834
00:58:15,000 --> 00:58:18,000
千万要注意。

835
00:58:18,000 --> 00:58:23,000
>> 现在，我们要对这个其他的东西，

836
00:58:23,000 --> 00:58:27,000
第3周，我们开始谈到的搜索和排序。

837
00:58:27,000 --> 00:58:32,000
检索和排序，CS50，至少在

838
00:58:32,000 --> 00:58:39,000
非常多介绍一些计算机科学的理论部分。

839
00:58:39,000 --> 00:58:42,000
的问题的搜索，排序的问题

840
00:58:42,000 --> 00:58:46,000
是大的，规范的问题。

841
00:58:46,000 --> 00:58:52,000
你怎么找到的数十亿美元的整数数组中的一个特定的数字吗？

842
00:58:52,000 --> 00:58:55,000
你如何找到一个特别的名字里面的电话簿

843
00:58:55,000 --> 00:58:59,000
是存储在您的笔记本电脑吗？

844
00:58:59,000 --> 00:59:04,000
因此，我们提出这个概念的渐近运行时间

845
00:59:04,000 --> 00:59:11,000
要真正量化多久，这些问题是如何努力，

846
00:59:11,000 --> 00:59:14,000
他们需要多长时间来解决。

847
00:59:14,000 --> 00:59:20,000
我相信，在2011年的测验有一个问题，我认为这是值得的

848
00:59:20,000 --> 00:59:27,000
覆盖速度非常快，这是一个问题12。

849
00:59:27,000 --> 00:59:32,000
哦，不，这是欧米茄。

850
00:59:32,000 --> 00:59:41,000
>> 在这里，我们谈论以最快的速度运行时

851
00:59:41,000 --> 00:59:46,000
对于一个特定的算法，然后最慢的可能的运行时间。

852
00:59:46,000 --> 00:59:52,000
欧米茄（Omega）和O这是真的只是快捷方式。

853
00:59:52,000 --> 00:59:55,000
他们的符号的快捷键说

854
00:59:55,000 --> 00:59:59,000
如何快速在最好的情况下，我们的算法来看，

855
00:59:59,000 --> 01:00:06,000
如何在最坏的情况下缓慢将我们的算法运行？

856
01:00:06,000 --> 01:00:10,000
让我们做一对夫妇这些，而这些，也包括了

857
01:00:10,000 --> 01:00:13,000
在短期渐近符号，这是我极力推荐的。

858
01:00:13,000 --> 01:00:17,000
杰克逊做了很好的工作。

859
01:00:17,000 --> 01:00:23,000
二进制搜索，我们谈论二进制搜索算法，

860
01:00:23,000 --> 01:00:28,000
我们通常谈论它，其大澳

861
01:00:28,000 --> 01:00:30,000
大O是什么？

862
01:00:30,000 --> 01:00:34,000
什么是运行时的二进制搜索速度最慢的可能吗？

863
01:00:34,000 --> 01:00:36,000
[学生] N²？

864
01:00:36,000 --> 01:00:41,000
关闭，我想类似的。

865
01:00:41,000 --> 01:00:43,000
这是快了很多。

866
01:00:43,000 --> 01:00:45,000
[学生]：二进制吗？是的，二进制搜索。

867
01:00:45,000 --> 01:00:47,000
[学生]：这是日志n。

868
01:00:47,000 --> 01:00:49,000
登录n，所以日志N意味着什么？

869
01:00:49,000 --> 01:00:51,000
它一半在每次迭代。

870
01:00:51,000 --> 01:00:56,000
没错，所以在最慢的情况下，

871
01:00:56,000 --> 01:01:00,000
说，如果你有一个排序的数组

872
01:01:00,000 --> 01:01:08,000
你正在寻找一百万整数，

873
01:01:08,000 --> 01:01:14,000
是第一个元素的数组或数组中的最后一个元素。

874
01:01:14,000 --> 01:01:18,000
请记住，二进制搜索算法的工作原理是在中间的元素，

875
01:01:18,000 --> 01:01:21,000
如果是这样的比赛，你要寻找的。

876
01:01:21,000 --> 01:01:23,000
如果是，那么伟大，你发现了它。

877
01:01:23,000 --> 01:01:27,000
>> 在最好的情况下，二进制搜索运行的速度有多快？

878
01:01:27,000 --> 01:01:29,000
[学生] 1。

879
01:01:29,000 --> 01:01:32,000
1，这是恒定的时间，大O 1。是啊。

880
01:01:32,000 --> 01:01:36,000
[学生]：我有一个问题。当你说的n登录，您的意思是与基地2，对不对？

881
01:01:36,000 --> 01:01:40,000
是的，所以其他的事情。

882
01:01:40,000 --> 01:01:44,000
我们说为log N，我想，当我在高中

883
01:01:44,000 --> 01:01:48,000
我一直认为日志基数为10。

884
01:01:48,000 --> 01:01:57,000
是啊，这样的话，2为底通常我们使用的是什么。

885
01:01:57,000 --> 01:02:02,000
再次，要回二进制搜索，如果你正在寻找无论是

886
01:02:02,000 --> 01:02:05,000
在最后元素或元素在开始的时候，

887
01:02:05,000 --> 01:02:08,000
因为你开始在中间，然后丢弃

888
01:02:08,000 --> 01:02:13,000
取其一半不符合标准，你要寻找的，

889
01:02:13,000 --> 01:02:15,000
你去下一半，下一半，下半。

890
01:02:15,000 --> 01:02:19,000
如果我在寻找万整数数组中的最大元素

891
01:02:19,000 --> 01:02:25,000
在100万次的日志，我要减半

892
01:02:25,000 --> 01:02:28,000
之前，我终于测试，看看，我要找的元素

893
01:02:28,000 --> 01:02:33,000
是在最大或指数最高的阵列中，

894
01:02:33,000 --> 01:02:38,000
将日志的n，记录的100万次。

895
01:02:38,000 --> 01:02:40,000
>> 冒泡排序。

896
01:02:40,000 --> 01:02:43,000
你们是否还记得冒泡排序算法？

897
01:02:43,000 --> 01:02:47,000
凯文，你能不能给我一个快速回顾中，冒泡排序算法发生了什么事吗？

898
01:02:47,000 --> 01:02:50,000
[凯文]，基本上它通过在列表中的一切。

899
01:02:50,000 --> 01:02:52,000
它着眼于前两个。

900
01:02:52,000 --> 01:02:55,000
如果第一个比第二个它掉期将是更大的。

901
01:02:55,000 --> 01:02:58,000
然后比较第二和第三，同样的事情，掉期，

902
01:02:58,000 --> 01:03:00,000
第三和第四，一路下跌。

903
01:03:00,000 --> 01:03:03,000
更大的数字会跟进的。

904
01:03:03,000 --> 01:03:07,000
然而，许多循环后，你就大功告成了。

905
01:03:07,000 --> 01:03:11,000
没错，凯文说的是，我们会看更大的数字

906
01:03:11,000 --> 01:03:15,000
泡沫结束的数组。

907
01:03:15,000 --> 01:03:19,000
例如，你不介意走我们通过这个例子，如果这是我们的数组？

908
01:03:19,000 --> 01:03:21,000
[凯文]你会需要2个和3个。

909
01:03:21,000 --> 01:03:23,000
3大于2，所以你换。

910
01:03:23,000 --> 01:03:29,000
内特H.]右，所以我们交换这些，和这样我们就得到2，3，6，4，和9。

911
01:03:29,000 --> 01:03:31,000
[凯文]那么你就比较3和6。

912
01:03:31,000 --> 01:03:33,000
3小于6，所以你离开他们，

913
01:03:33,000 --> 01:03:37,000
6和4，你会交换他们，因为4小于6。

914
01:03:37,000 --> 01:03:42,000
[内特H.]对，所以我得到2，3，4，6，9。

915
01:03:42,000 --> 01:03:46,000
[凯文]和9大于6，所以你离开它。

916
01:03:46,000 --> 01:03:48,000
你通过它回去了。

917
01:03:48,000 --> 01:03:50,000
>> [内特H.]在这一点上我做了吗？凯文号

918
01:03:50,000 --> 01:03:52,000
我为什么要在这一点上没有这样做呢？

919
01:03:52,000 --> 01:03:54,000
因为它看起来像我的数组进行排序。我看着它。

920
01:03:54,000 --> 01:03:57,000
[凯文]再经历一遍，确保没有更多的掉期

921
01:03:57,000 --> 01:04:00,000
才可以完全停止。

922
01:04:00,000 --> 01:04:04,000
没错，所以你仍然需要继续通过并确保不存在交换

923
01:04:04,000 --> 01:04:06,000
在这一点上，你可以使。

924
01:04:06,000 --> 01:04:08,000
这真的只是幸运，就像你说的，我们结束了

925
01:04:08,000 --> 01:04:12,000
只有1通过我们排序。

926
01:04:12,000 --> 01:04:16,000
但要做到这在一般情况下，我们实际上要做到这一点，一遍又一遍。

927
01:04:16,000 --> 01:04:20,000
而事实上，这是一个可能的情况下最好的例子，

928
01:04:20,000 --> 01:04:24,000
像我们所看到的问题。

929
01:04:24,000 --> 01:04:28,000
我们看到，最好的可能的情况下为N。

930
01:04:28,000 --> 01:04:32,000
我们经历了阵列1次。

931
01:04:32,000 --> 01:04:35,000
最坏的情况下，该算法是什么？

932
01:04:35,000 --> 01:04:37,000
[凯文] N“。

933
01:04:37,000 --> 01:04:41,000
而且，看起来像什么？数组的样子，取n²时间吗？

934
01:04:41,000 --> 01:04:43,000
[凯文] [听不清]排序。

935
01:04:43,000 --> 01:04:51,000
没错，所以如果我有数组9，7，6，5，2，

936
01:04:51,000 --> 01:04:54,000
第9泡沫一路。

937
01:04:54,000 --> 01:04:59,000
1次迭代后，我们就会有7，6，5，2，9。

938
01:04:59,000 --> 01:05:07,000
7将泡涨，6，5，2，7，9，等等等等。

939
01:05:07,000 --> 01:05:13,000
>> 我们不得不去整个数组n次，

940
01:05:13,000 --> 01:05:16,000
实际上，你可以得到比这更精确的

941
01:05:16,000 --> 01:05:23,000
因为一旦我们已经提出9一路到最后可能的位置

942
01:05:23,000 --> 01:05:26,000
我们知道，我们永远都不会拥有再次反对该元素比较。

943
01:05:26,000 --> 01:05:29,000
一旦我们开始冒泡7

944
01:05:29,000 --> 01:05:35,000
我们知道，我们可以停止后，7是正确的前9

945
01:05:35,000 --> 01:05:37,000
因为我们已经比较9。

946
01:05:37,000 --> 01:05:46,000
如果你这样做一个聪明的方式，它并不是真正的，我想，那么多的时间。

947
01:05:46,000 --> 01:05:49,000
你不是要比较所有可能的[听不清]组合

948
01:05:49,000 --> 01:05:55,000
每一次你通过每一次迭代。

949
01:05:55,000 --> 01:05:59,000
但尽管如此，当我们谈论这个上限，我们说，

950
01:05:59,000 --> 01:06:04,000
您正在寻找在n²通过比较所有方式。

951
01:06:04,000 --> 01:06:12,000
>> 让我们回去了，因为我们已经开始得到一点点的时间短

952
01:06:12,000 --> 01:06:15,000
我会说，你一定要通过此表，其余的，

953
01:06:15,000 --> 01:06:17,000
填补了这一切。

954
01:06:17,000 --> 01:06:20,000
想想例子。想想具体的例子。

955
01:06:20,000 --> 01:06:22,000
这是非常方便的和做的。

956
01:06:22,000 --> 01:06:25,000
画出来。

957
01:06:25,000 --> 01:06:28,000
这是排序的表，当你通过在计算机科学

958
01:06:28,000 --> 01:06:32,000
你应该开始知道这些由心。

959
01:06:32,000 --> 01:06:34,000
这是你在​​接受采访时的各种问题。

960
01:06:34,000 --> 01:06:36,000
这些都是各种各样的东西，是很好的了解，

961
01:06:36,000 --> 01:06:41,000
想想那些边缘的情况下，真正搞清楚如何思考

962
01:06:41,000 --> 01:06:45,000
知道冒泡排序可能出现的最坏的阵列的

963
01:06:45,000 --> 01:06:52,000
进行排序的，是一个以相反的顺序。

964
01:06:52,000 --> 01:06:58,000
>> 指针。让我们来谈谈关于指针一点点。

965
01:06:58,000 --> 01:07:03,000
在过去的几年时间里，我们这里有

966
01:07:03,000 --> 01:07:11,000
我知道这是与文件I / O，是相当新的东西。

967
01:07:11,000 --> 01:07:19,000
当我们谈论指针的原因，我们要谈论的指针

968
01:07:19,000 --> 01:07:24,000
是因为，当我们工作在C

969
01:07:24,000 --> 01:07:33,000
我们真的是在一个相当低的水平相比，大多数现代编程语言。

970
01:07:33,000 --> 01:07:38,000
我们实际上能够操纵内存中的变量，

971
01:07:38,000 --> 01:07:43,000
他们实际上是在我们的RAM。

972
01:07:43,000 --> 01:07:46,000
一旦你到了操作系统类，你会看到

973
01:07:46,000 --> 01:07:48,000
，，，种一个抽象的概念。

974
01:07:48,000 --> 01:07:50,000
这是事实并非如此。

975
01:07:50,000 --> 01:07:52,000
我们的隐藏这些细节，我们已经得到了虚拟内存。

976
01:07:52,000 --> 01:07:58,000
>> 但现在，你可以假设你有一个程序时，

977
01:07:58,000 --> 01:08:02,000
例如，当您开始您的恺撒密码程序

978
01:08:02,000 --> 01:08:06,000
我会切换回我的iPad真的很快

979
01:08:06,000 --> 01:08:12,000
在一开始你的程序，如果你有，说，

980
01:08:12,000 --> 01:08:15,000
4 GB的RAM您的笔记本电脑，

981
01:08:15,000 --> 01:08:21,000
你得到抛开这一块，我们把它称为RAM。

982
01:08:21,000 --> 01:08:25,000
在一个地方，我们要调用0开始，

983
01:08:25,000 --> 01:08:30,000
它结束的地方，我们会打电话给4千兆字节。

984
01:08:30,000 --> 01:08:37,000
我真的可以不写。人，被黑客攻击。

985
01:08:37,000 --> 01:08:40,000
当你的程序执行

986
01:08:40,000 --> 01:08:44,000
操作系统瓜分RAM，

987
01:08:44,000 --> 01:08:51,000
它规定了不同的细分为不同的部分，你的程序的居住环境。

988
01:08:51,000 --> 01:08:58,000
到这里，这方面是怎么样的无人区。

989
01:08:58,000 --> 01:09:02,000
当你去了稍远一点这里

990
01:09:02,000 --> 01:09:05,000
你有实际的地方

991
01:09:05,000 --> 01:09:09,000
你的程序的代码生活。

992
01:09:09,000 --> 01:09:13,000
实际的二进制代码，可执行文件实际上被加载到内存中

993
01:09:13,000 --> 01:09:17,000
当你运行一个程序，它住在代码段。

994
01:09:17,000 --> 01:09:22,000
你的程序执行的处理器看起来在这个代码段

995
01:09:22,000 --> 01:09:24,000
要弄清楚什么是下一个指令？

996
01:09:24,000 --> 01:09:27,000
我需要执行的下一行代码是什么？

997
01:09:27,000 --> 01:09:31,000
>> 还有一个数据段，这是这些字符串常量

998
01:09:31,000 --> 01:09:34,000
获取存储，你一直在使用。

999
01:09:34,000 --> 01:09:42,000
再远些了这个地方称为堆。

1000
01:09:42,000 --> 01:09:46,000
我们在那里存取记忆体使用malloc，

1001
01:09:46,000 --> 01:09:49,000
然后向你的程序的最顶端

1002
01:09:49,000 --> 01:09:52,000
有堆栈，

1003
01:09:52,000 --> 01:09:57,000
而这也正是我们一直在玩的最开始。

1004
01:09:57,000 --> 01:09:59,000
这是没有规模或任何东西。

1005
01:09:59,000 --> 01:10:03,000
这是很多非常依赖于机器，

1006
01:10:03,000 --> 01:10:10,000
依赖于操作系统，但是这是比较如何得到分块。

1007
01:10:10,000 --> 01:10:17,000
当你运行一个程序，你声明一个变量名为x-

1008
01:10:17,000 --> 01:10:27,000
我要画一个框下方，这将是RAM以及。

1009
01:10:27,000 --> 01:10:29,000
我去看看。

1010
01:10:29,000 --> 01:10:34,000
我们将绘制锯齿线来表示，这仅仅是一小部分的RAM

1011
01:10:34,000 --> 01:10:38,000
不是所有的为我们绘制在上面。

1012
01:10:38,000 --> 01:10:43,000
>> 如果我声明了一个整数变量x，

1013
01:10:43,000 --> 01:10:49,000
其实我得到的是一个映射

1014
01:10:49,000 --> 01:10:54,000
我的程序被存储在符号表中的

1015
01:10:54,000 --> 01:11:00,000
连接这个区域的记忆，我画的名字x

1016
01:11:00,000 --> 01:11:03,000
在这里之间的竖线。

1017
01:11:03,000 --> 01:11:08,000
如果我有一个在我的计划，说X = 7的代码行

1018
01:11:08,000 --> 01:11:15,000
处理器知道“哦，好吧，我知道在这个位置在内存中的x生活。”

1019
01:11:15,000 --> 01:11:25,000
“我要继续前进，并写了7。”

1020
01:11:25,000 --> 01:11:28,000
它是如何知道什么位置，这是在内存中吗？

1021
01:11:28,000 --> 01:11:30,000
那么，这一切都在编译时完成。

1022
01:11:30,000 --> 01:11:34,000
编译器负责分配中的每一个变量都去

1023
01:11:34,000 --> 01:11:40,000
创建一个特殊的映射，或者更确切地说，点与点之间

1024
01:11:40,000 --> 01:11:43,000
一个符号，到哪里去，一个变量的名称

1025
01:11:43,000 --> 01:11:46,000
到哪里去住在内存中。

1026
01:11:46,000 --> 01:11:50,000
但事实证明，我们实际上可以访问它在我们的程序中。

1027
01:11:50,000 --> 01:11:55,000
这得到重要的，当我们开始谈论一些数据结构，

1028
01:11:55,000 --> 01:11:58,000
这是一个概念，我们将在后面介绍。

1029
01:11:58,000 --> 01:12:09,000
>> 但是现在，你可以知道的是，我可以创造一个指针，指向这个位置，X。

1030
01:12:09,000 --> 01:12:12,000
例如，我可以创建一个指针变量。

1031
01:12:12,000 --> 01:12:16,000
当我们创建一个指针变量，我们使用星符号。

1032
01:12:16,000 --> 01:12:21,000
在这种情况下，说，我要创建一个指向整数的指针。

1033
01:12:21,000 --> 01:12:24,000
这是一个类型，就像任何其他。

1034
01:12:24,000 --> 01:12:27,000
我们给它一个变量，如Y，

1035
01:12:27,000 --> 01:12:32,000
然后，我们将它的地址，地址。

1036
01:12:32,000 --> 01:12:38,000
在这种情况下，我们可以设置y以指向到x

1037
01:12:38,000 --> 01:12:43,000
通过x的地址，这是我们做这个符号，

1038
01:12:43,000 --> 01:12:55,000
然后我们设置y来指向它。

1039
01:12:55,000 --> 01:12:59,000
这基本上是不是，如果我们看一下我们的RAM

1040
01:12:59,000 --> 01:13:02,000
这将创建一个独立的变量。

1041
01:13:02,000 --> 01:13:04,000
这将调用它的Ÿ，

1042
01:13:04,000 --> 01:13:06,000
而当这行代码执行

1043
01:13:06,000 --> 01:13:13,000
它实际上是要创建一个小的指针，我们通常画一个箭头，

1044
01:13:13,000 --> 01:13:15,000
点为x和y置。

1045
01:13:15,000 --> 01:13:17,000
是。

1046
01:13:17,000 --> 01:13:19,000
[学生]：如果x是一个指针，你会做

1047
01:13:19,000 --> 01:13:22,000
诠释* Y = X代替的符号？

1048
01:13:22,000 --> 01:13:24,000
是。

1049
01:13:24,000 --> 01:13:27,000
如果x是一个指针，然后就可以设置两个指针彼此相等，

1050
01:13:27,000 --> 01:13:30,000
在这种情况下，y的设置将不会为x，

1051
01:13:30,000 --> 01:13:34,000
但它会指向到任何x被指向。

1052
01:13:34,000 --> 01:13:37,000
不幸的是，我们没有时间了。

1053
01:13:37,000 --> 01:13:44,000
>> 我想说在这一点上，我们可以谈论这个脱机，

1054
01:13:44,000 --> 01:13:49,000
但我要说的开始工作，通过这个问题，＃14。

1055
01:13:49,000 --> 01:13:53,000
你可以看到已经有一点点充满在你这里。

1056
01:13:53,000 --> 01:13:57,000
您可以看到，当我们声明了两个指针，* X * Y，

1057
01:13:57,000 --> 01:14:01,000
注意，指向的变量*的东西，是去年。

1058
01:14:01,000 --> 01:14:05,000
原来，这是类似的，以我们正在做的这一年。

1059
01:14:05,000 --> 01:14:11,000
不要紧，你写的*当你声明的指针。

1060
01:14:11,000 --> 01:14:17,000
但是，我们已经写了旁边的类型*

1061
01:14:17,000 --> 01:14:24,000
因为这使得它很清楚，你声明一个指针变量。

1062
01:14:24,000 --> 01:14:27,000
你可以看到，申报2个三分球，为我们提供了2盒。

1063
01:14:27,000 --> 01:14:31,000
在这里，当我们设置x等于对malloc

1064
01:14:31,000 --> 01:14:34,000
这是什么说的预留内存在堆中。

1065
01:14:34,000 --> 01:14:41,000
这个小盒子在这里，这个圈子里，位于堆。

1066
01:14:41,000 --> 01:14:43,000
X是指向它。

1067
01:14:43,000 --> 01:14:46,000
需要注意的是Y还没有指向任何东西。

1068
01:14:46,000 --> 01:14:50,000
要获得内存来存储数字42到x

1069
01:14:50,000 --> 01:14:55,000
我们将使用什么样的符号？

1070
01:14:55,000 --> 01:14:59,000
[学生] * X = 42。

1071
01:14:59,000 --> 01:15:01,000
没错，* X = 42。

1072
01:15:01,000 --> 01:15:06,000
这意味着按照箭头，并在那里罚42。

1073
01:15:06,000 --> 01:15:09,000
在这里我们设置y和x有y指向为x。

1074
01:15:09,000 --> 01:15:13,000
同样，这就像凯文说什么，我们设y等于x。

1075
01:15:13,000 --> 01:15:15,000
Y不指向为x。

1076
01:15:15,000 --> 01:15:19,000
相反，它指向x是指向以及。

1077
01:15:19,000 --> 01:15:24,000
>> 然后终于在这最后一箱有2种可能，我们可以做的事情。

1078
01:15:24,000 --> 01:15:28,000
其中之一是，我们可以说X = 13。

1079
01:15:28,000 --> 01:15:33,000
另一件事是，我们可以说，亚历克斯，你知道，我们可以在这里做什么？

1080
01:15:33,000 --> 01:15:37,000
你可以说* X = 13

1081
01:15:37,000 --> 01:15:41,000
[学生]：你可以说诠释什么。

1082
01:15:41,000 --> 01:15:45,000
内特H.]如果这被称为一个int变量，我们能做到这一点。

1083
01:15:45,000 --> 01:15:49,000
我们还可以说* Y = 13，因为它们都指向同一个地方，

1084
01:15:49,000 --> 01:15:51,000
这样我们就可以使用任一变量到那里。

1085
01:15:51,000 --> 01:15:56,000
是啊。>> [学生]：会是什么样子，如果我们只说INT x是13吗？

1086
01:15:56,000 --> 01:16:00,000
这将宣告一个新的变量x，它是行不通的。

1087
01:16:00,000 --> 01:16:04,000
我们希望有一个碰撞，因为我们声明x是一个指针。

1088
01:16:04,000 --> 01:16:10,000
[学生]：如果我们只是有这样的声明本身会是什么样子的圆吗？

1089
01:16:10,000 --> 01:16:14,000
如果我们有X = 13，那么我们就会有一个盒子，而不是箭头

1090
01:16:14,000 --> 01:16:16,000
开箱即用的，我们得出它只是一个13。

1091
01:16:16,000 --> 01:16:19,000
[学生]：在“名称”框中。好吧。

1092
01:16:19,000 --> 01:16:24,000
>> 感谢您的收看，祝你好运测验0。

1093
01:16:24,000 --> 01:16:28,000
[CS50.TV]