1
00:00:07,420 --> 00:00:08,160
[Powered by Google Translate] DAVID J.马兰所有权利。

2
00:00:08,160 --> 00:00:11,170
这是CS50，这是结束2周。

3
00:00:11,170 --> 00:00:14,650
如果您希望明天的这个时候周围是饿了，知道我们要去

4
00:00:14,650 --> 00:00:18,920
召开会议，明天一小群，周四，1:15 PM。

5
00:00:18,920 --> 00:00:21,460
这个URL，在这里，如果你想回覆。

6
00:00:21,460 --> 00:00:25,270
空间是有限的，所以请原谅，如果表单的时候，填补了你

7
00:00:25,270 --> 00:00:26,680
填写。

8
00:00:26,680 --> 00:00:29,400
虽然可能感兴趣的另一个URL是这样的。

9
00:00:29,400 --> 00:00:32,409
>> 因此，在，只是大约一个月的时间，当然是要提供

10
00:00:32,409 --> 00:00:36,090
所有通过EDX，通过更广泛的人在互联网上

11
00:00:36,090 --> 00:00:39,580
能够跟着，从事的过程中，其实相当积极。

12
00:00:39,580 --> 00:00:43,070
他们将使用CS50电器和CS50讨论的，大部分的

13
00:00:43,070 --> 00:00:45,840
各种软件工具，我们已经一直在使用这个学期。

14
00:00:45,840 --> 00:00:49,030
而其中一项措施，我们希望作为一个实验，今年

15
00:00:49,030 --> 00:00:53,120
我们可以看到多少内容翻译成其他说

16
00:00:53,120 --> 00:00:54,110
书面语言。

17
00:00:54,110 --> 00:00:58,000
所以，如果你可能有兴趣参与该项目，

18
00:00:58,000 --> 00:01:02,090
我们将提供英语课程的成绩单及字幕

19
00:01:02,090 --> 00:01:05,190
讲座和短裤，研讨会及部分和 - 

20
00:01:05,190 --> 00:01:08,700
如果你会讲一口流利的或写流利一些其他的语言，我们会

21
00:01:08,700 --> 00:01:12,240
爱，让你在这个项目，让你承担一个或更多的

22
00:01:12,240 --> 00:01:15,340
视频，将其转化为一个语言，你知道得很好。

23
00:01:15,340 --> 00:01:19,050
为了让你的界面感，还有这个基于Web的用户界面

24
00:01:19,050 --> 00:01:22,330
我们将使用，将创建基本上是这样的一个UI。

25
00:01:22,330 --> 00:01:24,520
这是我教一些万圣节前。

26
00:01:24,520 --> 00:01:27,710
和右手侧有黑色旁边这些时间戳，

27
00:01:27,710 --> 00:01:31,300
你会看到不同的东西，我的嘴里说出来的那一天。

28
00:01:31,300 --> 00:01:34,660
然后在它下面，你会翻译成一些其他的语言。

29
00:01:34,660 --> 00:01:37,840
究竟是什么之间的映射是，在这种情况下，英语

30
00:01:37,840 --> 00:01:38,660
并说，西班牙。

31
00:01:38,660 --> 00:01:40,480
因此，它实际上是一个非常用户友好的工具。

32
00:01:40,480 --> 00:01:43,690
您可以倒带，快进，很容易与键盘快捷键。

33
00:01:43,690 --> 00:01:46,710
所以，如果你想参加这个实验，你的话

34
00:01:46,710 --> 00:01:50,730
有可能有成千上万的人看到和阅读的，请不要感到

35
00:01:50,730 --> 00:01:51,960
免费参加。

36
00:01:51,960 --> 00:01:56,940
>> 现在，一个字约从周一小猫，免得我们已将过于

37
00:01:56,940 --> 00:01:58,120
可怕的消息。

38
00:01:58,120 --> 00:02:02,130
一定要明白，，办公时间建议和段的建议，

39
00:02:02,130 --> 00:02:05,110
课程的设计是非常有学生的协作和

40
00:02:05,110 --> 00:02:09,250
说一起工作，通过习题集和问题。

41
00:02:09,250 --> 00:02:13,630
真正的行归结到了，你的工作，最终

42
00:02:13,630 --> 00:02:16,420
应提交的应该是你自己。

43
00:02:16,420 --> 00:02:19,080
所以，坦白地说 - 在办公时间，这是完全正常的 - 

44
00:02:19,080 --> 00:02:21,560
它完全可以预期的，甚至 - 有一些聊天

45
00:02:21,560 --> 00:02:22,370
你旁边的朋友。

46
00:02:22,370 --> 00:02:25,240
如果他或她挣扎着一些话题，和你一样，哦，好让

47
00:02:25,240 --> 00:02:27,750
我给你看到，我写了一些代码行。

48
00:02:27,750 --> 00:02:28,290
这很好。

49
00:02:28,290 --> 00:02:28,700
出现这种情况。

50
00:02:28,700 --> 00:02:31,580
这是非常有利的，我认为，学习的过程中。

51
00:02:31,580 --> 00:02:35,270
在哪里就行了，再次被越过时，头是有点歪了

52
00:02:35,270 --> 00:02:38,800
这里真的有太多秒或分钟，只

53
00:02:38,800 --> 00:02:41,250
无障碍给你的朋友的机会。

54
00:02:41,250 --> 00:02:43,870
当然，当事情变得交换通过电子邮件和Dropbox

55
00:02:43,870 --> 00:02:45,350
等，也有是行。

56
00:02:45,350 --> 00:02:48,940
因此，通过各种手段，手感舒适，感到鼓舞与朋友聊天

57
00:02:48,940 --> 00:02:51,270
和同学约pset和更多。

58
00:02:51,270 --> 00:02:54,680
而就认识到，真的是你最终提交

59
00:02:54,680 --> 00:02:57,780
你的创造，而不是别人的产品的。

60
00:02:57,780 --> 00:03:01,010
>> 因此，在同样的可爱的动物，你可能会

61
00:03:01,010 --> 00:03:02,820
知道这家伙在这里。

62
00:03:02,820 --> 00:03:06,180
因此，从几年前的电影，这是惊人的俗气。

63
00:03:06,180 --> 00:03:08,680
在这里的任何人都看到“太空炮弹”？

64
00:03:08,680 --> 00:03:09,120
好的。

65
00:03:09,120 --> 00:03:10,220
因此，一个好的号码。

66
00:03:10,220 --> 00:03:13,840
因此，这是我们今天介绍的最后美妙的学术方式

67
00:03:13,840 --> 00:03:15,130
密码学的概念。

68
00:03:15,130 --> 00:03:19,010
因此，pset的，这将前来领域特定问题

69
00:03:19,010 --> 00:03:22,770
明天晚上到很晚，是潜入密码学的世界，

70
00:03:22,770 --> 00:03:26,380
信息的加密和扰码是一门艺术。

71
00:03:26,380 --> 00:03:30,160
而这最终涉及到世界的安全。

72
00:03:30,160 --> 00:03:34,440
>> 立即安全对于大多数我们的形式相当平凡的机制。

73
00:03:34,440 --> 00:03:36,920
我们所有的用户名和密码。

74
00:03:36,920 --> 00:03:41,350
我们所有的人都非常糟糕的用户名​​和密码，最有可能的。

75
00:03:41,350 --> 00:03:45,250
如果您在多个网站上的密码是相同的，这可能是不

76
00:03:45,250 --> 00:03:47,920
最好的主意，我们将讨论对学期结束。

77
00:03:47,920 --> 00:03:51,680
如果您的密码是写在一个便签 - 可不是闹着玩的 - 你的

78
00:03:51,680 --> 00:03:55,130
显示器，这也并不一定是最好的设计，而是一个相当普遍的

79
00:03:55,130 --> 00:03:56,140
的现象。

80
00:03:56,140 --> 00:04:00,420
而且，如果你不使用加密技术来加密您的密码，它们是

81
00:04:00,420 --> 00:04:01,610
特别脆弱。

82
00:04:01,610 --> 00:04:04,670
所以，如果你认为你是超级聪明有一个隐藏的字

83
00:04:04,670 --> 00:04:07,740
在您的硬盘驱动器上有你所有的密码，但记录的地方

84
00:04:07,740 --> 00:04:10,550
它是在一个文件夹，没有人会看，这也不是一个很

85
00:04:10,550 --> 00:04:11,540
安全机制。

86
00:04:11,540 --> 00:04:15,100
还等什么的pset将介绍这是密码学艺术的，

87
00:04:15,100 --> 00:04:18,300
扰码信息，如密码，这样的事情是

88
00:04:18,300 --> 00:04:19,500
更安全。

89
00:04:19,500 --> 00:04:24,500
所以这个非常现实世界中的问题，以激励与非现实世界的

90
00:04:24,500 --> 00:04:28,740
的情况下，让我给你介绍我们最喜欢的片段之一，从这个

91
00:04:28,740 --> 00:04:29,895
电影，“太空炮弹”。

92
00:04:29,895 --> 00:04:30,565
>> [视频回放]

93
00:04:30,565 --> 00:04:32,995
头盔，你的恶魔，什么是怎么回事？

94
00:04:32,995 --> 00:04:34,730
你在做什么我的女儿吗？

95
00:04:34,730 --> 00:04:38,960
请允许我介绍年轻的整形外科医生，菲利普博士

96
00:04:38,960 --> 00:04:43,290
Schlotkin，最大的隆鼻的人在整个

97
00:04:43,290 --> 00:04:45,526
宇宙和比佛利山庄。

98
00:04:45,526 --> 00:04:46,450
殿下。

99
00:04:46,450 --> 00:04:47,380
鼻的工作吗？

100
00:04:47,380 --> 00:04:48,035
我听不懂。

101
00:04:48,035 --> 00:04:49,480
她已经有鼻子工作。

102
00:04:49,480 --> 00:04:51,490
这是一个甜蜜的16个目前。

103
00:04:51,490 --> 00:04:53,090
不，这不是你的想法。

104
00:04:53,090 --> 00:04:55,150
这是非常，非常糟糕。

105
00:04:55,150 --> 00:04:59,860
如果你不给我组合的空气盾，博士Schlotkin会

106
00:04:59,860 --> 00:05:04,135
给你女儿回到她的老鼻子了。

107
00:05:04,135 --> 00:05:05,385
 - 不！

108
00:05:08,202 --> 00:05:10,186
你从哪儿弄来的？

109
00:05:10,186 --> 00:05:11,178
 - 所有权利。

110
00:05:11,178 --> 00:05:11,674
我会告诉。

111
00:05:11,674 --> 00:05:12,666
我会告诉。

112
00:05:12,666 --> 00:05:14,154
不，爸爸，没有。

113
00:05:14,154 --> 00:05:15,150
你别这样。

114
00:05:15,150 --> 00:05:16,460
 - 你说得对，我亲爱的。

115
00:05:16,460 --> 00:05:18,450
我会想念你的新鼻子。

116
00:05:18,450 --> 00:05:21,550
但我不会告诉他们的组合不管是什么。

117
00:05:21,550 --> 00:05:23,100
 - 好极了。

118
00:05:23,100 --> 00:05:25,510
Schlotkin博士，做最坏的。

119
00:05:25,510 --> 00:05:26,760
是我的荣幸。

120
00:05:30,560 --> 00:05:31,180
 - 不！

121
00:05:31,180 --> 00:05:33,450
等等，等等。

122
00:05:33,450 --> 00:05:34,770
我会告诉。

123
00:05:34,770 --> 00:05:36,400
我会告诉。

124
00:05:36,400 --> 00:05:38,630
我知道它的工作。

125
00:05:38,630 --> 00:05:42,040
好吧，把它给我。

126
00:05:42,040 --> 00:05:46,890
该组合是其中之一。

127
00:05:46,890 --> 00:05:47,290
一。

128
00:05:47,290 --> 00:05:48,183
一。

129
00:05:48,183 --> 00:05:48,950
二。

130
00:05:48,950 --> 00:05:49,370
二。

131
00:05:49,370 --> 00:05:50,450
二。

132
00:05:50,450 --> 00:05:50,715
 - 三

133
00:05:50,715 --> 00:05:51,380
三。

134
00:05:51,380 --> 00:05:52,390
三。

135
00:05:52,390 --> 00:05:53,200
四。

136
00:05:53,200 --> 00:05:53,720
四。

137
00:05:53,720 --> 00:05:55,830
四。

138
00:05:55,830 --> 00:05:56,580
五

139
00:05:56,580 --> 00:05:57,120
五。

140
00:05:57,120 --> 00:05:58,560
五。

141
00:05:58,560 --> 00:06:03,770
所以组合是一个，两个，三个，四个，五个。

142
00:06:03,770 --> 00:06:06,745
这是我所听到过的最愚蠢的组合在我的生活中。

143
00:06:06,745 --> 00:06:09,290
那是白痴才会有这样的事情在他的行李。

144
00:06:09,290 --> 00:06:11,540
谢谢你，你的高度。

145
00:06:11,540 --> 00:06:12,940
你做了什么？

146
00:06:12,940 --> 00:06:14,230
我关掉了墙上。

147
00:06:14,230 --> 00:06:14,630
不，你没有。

148
00:06:14,630 --> 00:06:15,430
您关闭了整部影片。

149
00:06:15,430 --> 00:06:16,722
我一定按错了按钮。

150
00:06:16,722 --> 00:06:18,078
好了，把它放回去。

151
00:06:18,078 --> 00:06:18,805
把电影。

152
00:06:18,805 --> 00:06:19,080
是的，先生。

153
00:06:19,080 --> 00:06:19,270
是的，先生。

154
00:06:19,270 --> 00:06:19,830
让我们去，爱尔纳。

155
00:06:19,830 --> 00:06:20,270
来吧，格雷琴。

156
00:06:20,270 --> 00:06:22,850
当然，你知道，我还是会向您。

157
00:06:27,400 --> 00:06:28,325
好了，没有工作？

158
00:06:28,325 --> 00:06:29,550
门在哪里？

159
00:06:29,550 --> 00:06:29,910
它的工作，先生。

160
00:06:29,910 --> 00:06:30,770
我们的组合。

161
00:06:30,770 --> 00:06:31,390
 - 太好了。

162
00:06:31,390 --> 00:06:35,630
现在，我们可以从地球Druidia每一个呼吸新鲜的空气。

163
00:06:35,630 --> 00:06:36,550
什么组合？

164
00:06:36,550 --> 00:06:38,805
一，二，三，四，五。

165
00:06:38,805 --> 00:06:40,610
一，二，三，四，五？

166
00:06:40,610 --> 00:06:41,070
是的。

167
00:06:41,070 --> 00:06:41,760
这是惊人的。

168
00:06:41,760 --> 00:06:45,200
在我的行李，我已经得到了相同的组合。

169
00:06:45,200 --> 00:06:47,800
准备空间球1立即离开。

170
00:06:47,800 --> 00:06:48,536
是的，先生。

171
00:06:48,536 --> 00:06:52,350
和变更的组合在我的行李。

172
00:06:52,350 --> 00:06:53,250
 - 噢！

173
00:06:53,250 --> 00:06:55,020
[END视频播放]

174
00:06:55,020 --> 00:06:57,470
>> DAVID J.马兰：你现在应该看到一个惊人的电影。

175
00:07:00,600 --> 00:07:06,540
因此，这里的语境是不安全的数据来的机会

176
00:07:06,540 --> 00:07:07,790
加密和争夺它。

177
00:07:07,790 --> 00:07:11,060
等，例如，是一个加密的消息的一个例子。

178
00:07:11,060 --> 00:07:12,980
这实际上是说英语的东西。

179
00:07:12,980 --> 00:07:14,750
但它显然不是完全明显。

180
00:07:14,750 --> 00:07:17,360
我们将兜了一圈，今天捉弄除了这是什么秘密

181
00:07:17,360 --> 00:07:18,380
这里的信息是。

182
00:07:18,380 --> 00:07:22,370
但在现实世界中的电脑，事情并不甚至看起来会

183
00:07:22,370 --> 00:07:23,440
是的英语句子。

184
00:07:23,440 --> 00:07:27,500
例如，这是你可能会发现在一个标准的Linux或Mac或

185
00:07:27,500 --> 00:07:32,080
Unix计算机中的文件，是很久很久以前被称为密码文件。

186
00:07:32,080 --> 00:07:34,170
如今，它被转移到其他地方。

187
00:07:34,170 --> 00:07:38,660
但是，如果你的系统上，在正确的地方，你会看到不仅是你的

188
00:07:38,660 --> 00:07:41,430
用户名或系统上的其他人，但你会看到一个

189
00:07:41,430 --> 00:07:43,410
他们的密码的加密版本。

190
00:07:43,410 --> 00:07:47,800
事实上，这个词地下室有以下的东西是加密的。

191
00:07:47,800 --> 00:07:52,030
而这一系列看似随机的字母和字符和数字，

192
00:07:52,030 --> 00:07:56,370
等等，都可以被解密仅由一般知道的一些秘密 - 

193
00:07:56,370 --> 00:07:58,600
一个秘密的话，一个秘密数字。

194
00:07:58,600 --> 00:08:02,760
事实上，艺术的加密技术最终都归结到信任的一些

195
00:08:02,760 --> 00:08:05,700
排序和别人不知道的东西。

196
00:08:05,700 --> 00:08:10,010
我们将探讨这方面更详细一点今天在pset中来。

197
00:08:10,010 --> 00:08:11,860
>> 而现在通过/失败的一个词。

198
00:08:11,860 --> 00:08:15,250
特别是一些潜入的pset，家电，和

199
00:08:15,250 --> 00:08:18,390
一个很新的世界为自己，认识到挫折和

200
00:08:18,390 --> 00:08:21,340
混乱和技术困难是可以预期的。

201
00:08:21,340 --> 00:08:24,410
特别是随着第一的pset，那里有这么多新的，刚开

202
00:08:24,410 --> 00:08:28,830
熟悉的ls和cd，所有这些神秘的命令在一个新的环境。

203
00:08:28,830 --> 00:08:32,679
这是从实际材料和编程本身分开。

204
00:08:32,679 --> 00:08:35,960
因此，实现，也有一定存在的办公时间

205
00:08:35,960 --> 00:08:36,770
支承结构上。

206
00:08:36,770 --> 00:08:38,620
节本星期日开始。

207
00:08:38,620 --> 00:08:41,990
但是，最重要的是，如果你只是感觉这是不

208
00:08:41,990 --> 00:08:44,420
你的世界，实现它确实只是需要时间。

209
00:08:44,420 --> 00:08:47,520
，它不给我这个机会，几年前对我来说，一类

210
00:08:47,520 --> 00:08:50,840
通过/失败，说实话，我永远不会甚至踏上在教室里。

211
00:08:50,840 --> 00:08:53,520
你可以改变这件事，直到说，第五次周一的课程。

212
00:08:53,520 --> 00:08:57,110
所以，如果你对现在的边缘，而不是头，实现了一些其他

213
00:08:57,110 --> 00:09:01,000
完全水域，肯定会考虑转变为通过/失败。

214
00:09:01,000 --> 00:09:03,750
同样，有没有真的这种文化在哈佛考虑的事情

215
00:09:03,750 --> 00:09:08,080
通过/失败，因为每个人都希望实现或超额完成。

216
00:09:08,080 --> 00:09:11,470
但坦率地说，这是一个美妙的方式尝试了，可能不

217
00:09:11,470 --> 00:09:13,110
很熟悉的。

218
00:09:13,110 --> 00:09:17,090
你会做在大多数情况下，相当精致，也许

219
00:09:17,090 --> 00:09:18,040
多给您惊喜。

220
00:09:18,040 --> 00:09:20,850
更具体的，我觉得通过/失败一般不，

221
00:09:20,850 --> 00:09:23,350
尤其是当你可能经历过的pset 0，如果你已经把

222
00:09:23,350 --> 00:09:27,200
在10小时，15小时，25小时到一些pset中 - 和你只是撞

223
00:09:27,200 --> 00:09:28,180
你的头靠在墙上，

224
00:09:28,180 --> 00:09:29,850
它的超级深夜，

225
00:09:29,850 --> 00:09:31,880
但你在pset的方式，如90％，

226
00:09:31,880 --> 00:09:33,780
你知道你只是无法弄清楚一件事 - 

227
00:09:33,780 --> 00:09:36,830
通过/失败的真正的边缘，这样的一类，在这里你可以排序

228
00:09:36,830 --> 00:09:39,150
高兴地说好了，我知道它并不是完美的。

229
00:09:39,150 --> 00:09:40,470
但我的工作我的屁股上。

230
00:09:40,470 --> 00:09:42,410
我很高兴就结束了。

231
00:09:42,410 --> 00:09:44,780
将满足期望通过/失败。

232
00:09:44,780 --> 00:09:46,850
所以千万记住这一点。

233
00:09:46,850 --> 00:09:47,140
>> 好的。

234
00:09:47,140 --> 00:09:50,980
因此，那些你们谁一直在努力使用哈佛大学的Wi-Fi知道

235
00:09:50,980 --> 00:09:54,780
该有一CS50 SSID的，通过Wi-Fi连接周围，漂浮

236
00:09:54,780 --> 00:09:56,520
可能有更好的运气。

237
00:09:56,520 --> 00:09:59,430
这是一个有点讽刺的密码 - 如果你想尝试一下

238
00:09:59,430 --> 00:10:03,080
更好的速度和连接到该让我们知道，如果没有更好的 - 

239
00:10:03,080 --> 00:10:09,240
是一，二，三，四，五，一路攀升到8，因为8是

240
00:10:09,240 --> 00:10:10,270
更安全比五。

241
00:10:10,270 --> 00:10:15,520
所以，如果你需要的Wi-Fi密码，无线连接到CS50这里。

242
00:10:15,520 --> 00:10:16,950
一，二，三，四，五，六，七，八。

243
00:10:16,950 --> 00:10:20,440
CS50后上讨论，如果你仍然有间歇性的连接问题，

244
00:10:20,440 --> 00:10:24,880
我们将让权力知道这个空间。

245
00:10:24,880 --> 00:10:25,180
>> 好的。

246
00:10:25,180 --> 00:10:30,350
所以简单的玩笑话，尤其是对于那些你们谁是风扇的男孩或女孩

247
00:10:30,350 --> 00:10:31,900
所有苹果。

248
00:10:31,900 --> 00:10:37,566
我从几年前挖了这个文件，ilock.c，只是为了

249
00:10:37,566 --> 00:10:40,930
种更具体，更复杂一些更基本的C

250
00:10:40,930 --> 00:10:42,350
我们一直都在写程序。

251
00:10:42,350 --> 00:10:44,360
于是，我打开了这个文件，ilock.c。

252
00:10:44,360 --> 00:10:46,830
这是今天的讲座页。

253
00:10:46,830 --> 00:10:49,470
在左侧，你会看到一个长长的清单功能。

254
00:10:49,470 --> 00:10:51,860
因此，研究员，这是谁写的写了很多的功能，

255
00:10:51,860 --> 00:10:53,290
以上只是主。

256
00:10:53,290 --> 00:10:55,490
在这里，他用一大堆的库。

257
00:10:55,490 --> 00:11:00,450
如果我们开始滚动，这实际上是非常

258
00:11:00,450 --> 00:11:04,670
第一，我认为，原来的iPhone破解。

259
00:11:04,670 --> 00:11:08,000
当你想原来的iPhone越狱，这意味着untether

260
00:11:08,000 --> 00:11:11,800
从AT＆T和实际安装特殊的软件就可以了，做的事情

261
00:11:11,800 --> 00:11:13,510
苹果没有人做 - 

262
00:11:13,510 --> 00:11:17,020
好了，有人花时间来弄清楚他们是如何利用

263
00:11:17,020 --> 00:11:20,880
软件缺陷，错误，错误，在苹果公司的软件。

264
00:11:20,880 --> 00:11:22,650
从而诞生了ilock.c。

265
00:11:22,650 --> 00:11:26,670
如果你的计算机上编译它和它的iPhone上安装

266
00:11:26,670 --> 00:11:29,810
说，通过USB电缆连接到您的计算机，这将给你

267
00:11:29,810 --> 00:11:33,360
行政或root用户权限在您的iPhone，让你做很多

268
00:11:33,360 --> 00:11:34,170
任何你想要的。

269
00:11:34,170 --> 00:11:36,740
>> 所以这个迷人的猫捉老鼠的游戏和苹果之间的

270
00:11:36,740 --> 00:11:39,920
特别是他们在世界各地的很多企业一样，试图锁定

271
00:11:39,920 --> 00:11:43,220
他们的东西，所以，你只能用它做什么，他们打算。

272
00:11:43,220 --> 00:11:46,620
但由于这样的人，他们的低层次的认识

273
00:11:46,620 --> 00:11:50,580
的细节，并在这种情况下，C编程和熟悉的结构的特定

274
00:11:50,580 --> 00:11:54,630
我们已经开始玩，你能够真正利用

275
00:11:54,630 --> 00:11:59,050
硬件的方式，您认为合适的，而不一定是一些企业实体。

276
00:11:59,050 --> 00:12:01,360
因此，举例来说，我不知道这是做。

277
00:12:01,360 --> 00:12:03,220
但是，GetVersion听起来很简单。

278
00:12:03,220 --> 00:12:05,480
看起来这是一个函数，这个人写的。

279
00:12:05,480 --> 00:12:09,240
以某种整数作为参数，不返回任何东西，但

280
00:12:09,240 --> 00:12:13,080
一个for循环和循环条件，如果条件下，如果

281
00:12:13,080 --> 00:12:15,620
突破，并以某种方式涉及到的版本号。

282
00:12:15,620 --> 00:12:16,700
如果我们向下滚动 - 

283
00:12:16,700 --> 00:12:19,570
尽管很多这些关键字将是新的，并有一个

284
00:12:19,570 --> 00:12:22,590
一大堆的功能在这里，我们从来没有见过，可能不会看到超过

285
00:12:22,590 --> 00:12:23,830
本学期的过程中 - 

286
00:12:23,830 --> 00:12:27,150
在一天结束的时候，它遵循相同的规则和逻辑，我们已经

287
00:12:27,150 --> 00:12:28,760
玩迄今。

288
00:12:28,760 --> 00:12:34,220
因此，这是破解你的iPhone 4S或3S或很快5S，这几天太旧，

289
00:12:34,220 --> 00:12:37,320
但要知道，这一切都非常来源于这个世界，我们已经看到

290
00:12:37,320 --> 00:12:38,430
潜入。

291
00:12:38,430 --> 00:12:41,900
>> 因此，让我们来看看一个更简单一点的例子。

292
00:12:41,900 --> 00:12:46,100
这其中，只是为了获得回暖的一些语法，也有一些其他的数据

293
00:12:46,100 --> 00:12:49,240
类型，我们已经谈到了，但还没有真正出现在C.因此，这是一个

294
00:12:49,240 --> 00:12:51,680
文件名为​​positive1.c。

295
00:12:51,680 --> 00:12:55,120
每在上面的评论，这只是要求用户提供一个

296
00:12:55,120 --> 00:12:55,960
正数。

297
00:12:55,960 --> 00:12:59,530
所以这是一个例子，一个do-whil​​e循环，这是很好的用户交互

298
00:12:59,530 --> 00:13:01,980
程序，你需要告诉用户做一些事情。

299
00:13:01,980 --> 00:13:05,190
，如果他们不配合，你骂他们，或拒绝他们的意见。

300
00:13:05,190 --> 00:13:11,610
典型的例子，我该怎么办第19行到24这么久的用户

301
00:13:11,610 --> 00:13:14,310
没有给我一个正数。

302
00:13:14,310 --> 00:13:20,400
现在，这个细节在这里的第18行，为什么我宣布这整个Ñ以上

303
00:13:20,400 --> 00:13:24,490
循环结构，而不是右线22我

304
00:13:24,490 --> 00:13:26,880
真正关心得到n？

305
00:13:26,880 --> 00:13:27,330
是吗？

306
00:13:27,330 --> 00:13:27,780
[听不清]

307
00:13:27,780 --> 00:13:29,040
>> DAVID J.马兰：是啊，所以这个问题的范围。

308
00:13:29,040 --> 00:13:30,850
在外行人的术语，什么范围是指什么？

309
00:13:34,690 --> 00:13:36,610
是吗？

310
00:13:36,610 --> 00:13:37,860
[听不清]

311
00:13:40,040 --> 00:13:41,105
DAVID J.马兰：你能不能说大声一点好吗？

312
00:13:41,105 --> 00:13:43,450
主讲人1：在这里你可以访问一个特定的变量。

313
00:13:43,450 --> 00:13:45,170
DAVID J.马兰：完美的。

314
00:13:45,170 --> 00:13:47,360
在这里你可以访问一个特定的变量。

315
00:13:47,360 --> 00:13:50,400
而且一般的经验法则迄今为止一直认为，一些人的范围

316
00:13:50,400 --> 00:13:55,860
变量的定义是，你已经看到最近的花括号。

317
00:13:55,860 --> 00:14:02,010
因此，在这种情况下，如果我犯了个错误n在第22行声明，

318
00:14:02,010 --> 00:14:03,010
该行会的工作。

319
00:14:03,010 --> 00:14:10,990
我会得到一个int，我希望把它变成第22行中的变量n。

320
00:14:10,990 --> 00:14:16,900
但是，这行代码将不知道我说的是什么呢？

321
00:14:16,900 --> 00:14:22,650
所以，25，事实证明，24为好，因为在这种情况下，它不属于

322
00:14:22,650 --> 00:14:23,610
大括号。

323
00:14:23,610 --> 00:14:27,280
因此，只要一点点的滋扰，但很容易解决，只需声明

324
00:14:27,280 --> 00:14:30,140
变量以外的函数本身。

325
00:14:30,140 --> 00:14:32,600
>> 现在，我们可以看到以后的今天，你可以走了一步。

326
00:14:32,600 --> 00:14:34,860
你甚至可以得到一个有点懒惰 - 

327
00:14:34,860 --> 00:14:37,320
，这是不被推荐的，在一般情况 - 

328
00:14:37,320 --> 00:14:42,260
但你甚至可以偷懒，把一个全局变量，可以这么说，不

329
00:14:42,260 --> 00:14:46,670
内的一个函数，而不是一个循环的内部，但在文件本身，外

330
00:14:46,670 --> 00:14:49,600
所有的功能，你已经写了，因为我在这里的第15行。

331
00:14:49,600 --> 00:14:51,160
但是，这一般是不可取的。

332
00:14:51,160 --> 00:14:55,680
但是，认识到这一点是有时其他问题的解决方案，我们将

333
00:14:55,680 --> 00:14:56,620
最终看到的。

334
00:14:56,620 --> 00:14:58,130
因此，就目前而言，我们将保持这样的。

335
00:14:58,130 --> 00:15:01,030
但是，让我们看看我们是否能改写这只是开始表达自己在一所房子里

336
00:15:01,030 --> 00:15:01,990
略有不同。

337
00:15:01,990 --> 00:15:05,330
>> 因此这个方案，仅仅是明确的，是阳性。

338
00:15:05,330 --> 00:15:11,810
让我继续在这里，在我的终端窗口阳性，回车。

339
00:15:11,810 --> 00:15:12,740
编译，没问题。

340
00:15:12,740 --> 00:15:14,910
我要去，运行positive1，按下回车键。

341
00:15:14,910 --> 00:15:16,820
我要求你给我一个正整数。

342
00:15:16,820 --> 00:15:18,260
我会说：-1。

343
00:15:18,260 --> 00:15:18,910
没有工作。

344
00:15:18,910 --> 00:15:22,150
0，99，这似乎是工作。

345
00:15:22,150 --> 00:15:23,570
也许不是最严格的测试。

346
00:15:23,570 --> 00:15:26,480
但至少这是一个不错的完整性检查，我们正在正确的轨道上。

347
00:15:26,480 --> 00:15:29,240
所以，现在让我继续前进，打开这两个版本。

348
00:15:29,240 --> 00:15:32,500
有什么不同了吗？

349
00:15:32,500 --> 00:15:35,140
它实现了同样的事情。

350
00:15:35,140 --> 00:15:40,660
但是，什么是跳出为明显不同时间？

351
00:15:40,660 --> 00:15:42,560
是啊，所以这个布尔绿色。

352
00:15:42,560 --> 00:15:45,980
gedit有绿色高亮显示该关键字被称为布尔，

353
00:15:45,980 --> 00:15:47,000
这是一个数据类型。

354
00:15:47,000 --> 00:15:51,080
它不内置于所有版本的C.你需要包含一个

355
00:15:51,080 --> 00:15:52,010
具体的库。

356
00:15:52,010 --> 00:15:54,770
在我们的例子中，我的CS50库，使我们

357
00:15:54,770 --> 00:15:56,460
有机会为bool。

358
00:15:56,460 --> 00:15:59,810
但在第18行，我们似乎有一个布尔值，这里所谓的感谢。

359
00:15:59,810 --> 00:16:01,040
所以，我可以把这种现象称之为什么。

360
00:16:01,040 --> 00:16:04,500
但我把它叫做感激只是一种传达一些语义上的意义。

361
00:16:04,500 --> 00:16:07,930
因此，最初的第18行，我显然不是感谢，因为

362
00:16:07,930 --> 00:16:12,150
布尔值，感谢在第18行初始化为false。

363
00:16:12,150 --> 00:16:16,890
然后，它似乎是我在这里做了21行〜23是我刚刚

364
00:16:16,890 --> 00:16:18,610
种重写我的逻辑。

365
00:16:18,610 --> 00:16:21,020
所以没有功能不同的。

366
00:16:21,020 --> 00:16:26,940
但在第22行，我现在检查，如果int用户提供了大于

367
00:16:26,940 --> 00:16:31,120
0，那么我只需更改感谢真正的价值。

368
00:16:31,120 --> 00:16:32,290
我为什么这样做呢？

369
00:16:32,290 --> 00:16:35,600
因为在第25行，很显然，我要检查的条件。

370
00:16:35,600 --> 00:16:39,380
做这个循环，同时感谢是假的。

371
00:16:39,380 --> 00:16:43,610
>> 因此，我建议这是一个版本的替代品，因为它至少一个

372
00:16:43,610 --> 00:16:45,130
更直观一点，也许吧。

373
00:16:45,130 --> 00:16:46,900
这是一个有点植根于英语。

374
00:16:46,900 --> 00:16:51,710
因此，请执行以下操作，而你不感谢，同时感谢是假的。

375
00:16:51,710 --> 00:16:55,890
而这个时候，我显然不关心记住用户输入的是什么

376
00:16:55,890 --> 00:16:57,730
因为通知中没有任何变量n。

377
00:16:57,730 --> 00:16:58,650
因此，实际上，I  - 

378
00:16:58,650 --> 00:17:00,080
一个善意的谎言。

379
00:17:00,080 --> 00:17:02,770
在功能上，该方案是一个有点不同的，一旦我们得到的底部

380
00:17:02,770 --> 00:17:04,819
它，因为我不记得n是什么。

381
00:17:04,819 --> 00:17:09,579
但我想在这里展示我们已经看到过，即使调用getInt和

382
00:17:09,579 --> 00:17:13,920
正在使用的右手侧的一个等号的GetString迄今，使得

383
00:17:13,920 --> 00:17:17,160
我们记住它们的价值，从技术上讲，这不是绝对必要的。

384
00:17:17,160 --> 00:17:20,950
如果由于某种原因，你只是不小心保存的价值，你只是想

385
00:17:20,950 --> 00:17:25,710
检查该值，请注意，我们可以简单的写调用getInt开放

386
00:17:25,710 --> 00:17:27,000
括号，关闭括号。

387
00:17:27,000 --> 00:17:30,460
该函数会返回一个值，因为我们一直在说。

388
00:17:30,460 --> 00:17:32,010
这将会给你一个int。

389
00:17:32,010 --> 00:17:36,450
所以，如果你在精神上认为这种情况发生，当我输入99，调用getInt

390
00:17:36,450 --> 00:17:38,160
返回数字99。

391
00:17:38,160 --> 00:17:41,330
因此，从理论上讲，这是因为虽然我的代码，其实这。

392
00:17:41,330 --> 00:17:45,880
因此，如果99的确是大于0，然后感谢变为真。

393
00:17:45,880 --> 00:17:50,420
第25行实现哦，我们正在做的，因为我现在感谢。

394
00:17:50,420 --> 00:17:54,590
而在第26行，我们简单地说，感谢为正整数，不管它

395
00:17:54,590 --> 00:17:55,710
碰巧。

396
00:17:55,710 --> 00:17:58,900
>> 现在，让我们在这里做轻微的语法糖，可以这么说。

397
00:17:58,900 --> 00:18:02,990
让我们来看看，如果我们可以清理这条线，这第三个和最后的25方差

398
00:18:02,990 --> 00:18:04,640
在positive3。

399
00:18:04,640 --> 00:18:08,250
因此，注意到现在唯一的区别是哪一行代码？

400
00:18:11,930 --> 00:18:13,260
是啊，所以25。

401
00:18:13,260 --> 00:18:15,520
我们还没有真正看到这一招只是还没有。

402
00:18:15,520 --> 00:18:19,510
但是，我们也看到周一的感叹号，这表示什么？

403
00:18:19,510 --> 00:18:20,970
因此，没有或否定。

404
00:18:20,970 --> 00:18:23,460
因此，需要一个布尔值，，并翻转它的价值。

405
00:18:23,460 --> 00:18:24,390
真亦假。

406
00:18:24,390 --> 00:18:25,500
假变为真。

407
00:18:25,500 --> 00:18:28,910
所以，我建议，即使是一点点的一种方式，更直观

408
00:18:28,910 --> 00:18:32,200
编写的代码，因为我仍然会初始化为false感谢。

409
00:18:32,200 --> 00:18:33,530
我还是做到以下几点。

410
00:18:33,530 --> 00:18:35,700
我感谢设置为true，在时机成熟时。

411
00:18:35,700 --> 00:18:40,690
但现在你可以真的只是翻译代码口头左到右，

412
00:18:40,690 --> 00:18:42,550
同时感谢。

413
00:18:42,550 --> 00:18:46,170
由于爆炸，或惊叹号，表示不的概念，因此，虽然

414
00:18:46,170 --> 00:18:47,010
不心存感激。

415
00:18:47,010 --> 00:18:49,740
>> 所以，再一次，我们没有引入任何新的概念本身。

416
00:18:49,740 --> 00:18:53,230
我们已经讨论了布尔值，当我们从头打了。

417
00:18:53,230 --> 00:18:55,690
但现在认识到，我们就可以开始写我们的代码

418
00:18:55,690 --> 00:18:56,550
许多不同的方式。

419
00:18:56,550 --> 00:19:00,010
因此，特别是在pset1移动，如果你有几分努力找出的方式来

420
00:19:00,010 --> 00:19:03,400
请编写一些程序，你很幸运，因为有将是任何

421
00:19:03,400 --> 00:19:05,780
的解决方案，您可以发生在数。

422
00:19:05,780 --> 00:19:09,850
举例来说，即使是最简单的程序，这仅仅是3。

423
00:19:09,850 --> 00:19:10,180
好的。

424
00:19:10,180 --> 00:19:13,860
现在记得上周一，我们留在这有返回值的注意。

425
00:19:13,860 --> 00:19:18,280
因此，对于第一次，我们写了一个程序，不只是有主，

426
00:19:18,280 --> 00:19:22,240
它也有它自己的自定义函数，我写在这里。

427
00:19:22,240 --> 00:19:26,640
因此，在31〜34行，我已经实现了一个多维数据集函数。

428
00:19:26,640 --> 00:19:27,800
这并不复杂。

429
00:19:27,800 --> 00:19:29,830
这只是一个次次，在这种情况下。

430
00:19:29,830 --> 00:19:34,920
但重要的是它是我输入的形式

431
00:19:34,920 --> 00:19:38,910
我回输出的形式的时候，一个次。

432
00:19:38,910 --> 00:19:43,940
>> 所以，现在我有能力，就像我用printf单独使用，调用

433
00:19:43,940 --> 00:19:47,120
多维数据集函数调用这个函数。

434
00:19:47,120 --> 00:19:49,470
和多维数据集的功能需要一定的投入。

435
00:19:49,470 --> 00:19:52,030
和多维数据集函数返回一些输出。

436
00:19:52,030 --> 00:19:56,660
因此，相比之下，输出只是做了一些事情。

437
00:19:56,660 --> 00:19:59,490
它没有返回任何东西，我们关心的 - 即使作为一个

438
00:19:59,490 --> 00:20:00,820
一旁，它返回一个值。

439
00:20:00,820 --> 00:20:02,650
您通常会忽略它。

440
00:20:02,650 --> 00:20:04,000
的printf只是做了一些事情。

441
00:20:04,000 --> 00:20:06,220
它有打印到屏幕上的副作用。

442
00:20:06,220 --> 00:20:09,480
反差，在这里，我们有多维数据集的功能，这

443
00:20:09,480 --> 00:20:11,400
实际上返回的东西。

444
00:20:11,400 --> 00:20:12,960
>> 因此，这是一般 - 

445
00:20:12,960 --> 00:20:15,260
对于那些熟悉，这是一个非常简单的想法。

446
00:20:15,260 --> 00:20:18,460
但是，对于那些不太熟悉这个想法传递输入和

447
00:20:18,460 --> 00:20:21,700
背面输出，让我们尝试只是超级简单的东西。

448
00:20:21,700 --> 00:20:25,180
是任何人都舒服了舞台上简单吗？

449
00:20:25,180 --> 00:20:27,460
你必须是舒适的与你的相机，以及。

450
00:20:27,460 --> 00:20:27,640
是啊。

451
00:20:27,640 --> 00:20:28,610
好了，你叫什么名字？

452
00:20:28,610 --> 00:20:29,020
KEN：肯。

453
00:20:29,020 --> 00:20:29,420
DAVID J.马兰：肯。

454
00:20:29,420 --> 00:20:29,810
所有权利，肯。

455
00:20:29,810 --> 00:20:31,060
上来吧。

456
00:20:31,060 --> 00:20:34,660
所以，肯将是各种各样的功能，在这里。

457
00:20:34,660 --> 00:20:35,760
让我们继续做到这一点。

458
00:20:35,760 --> 00:20:38,790
让我们一点点花哨。

459
00:20:38,790 --> 00:20:39,770
认识你很高兴。

460
00:20:39,770 --> 00:20:41,010
欢迎来到舞台中央。

461
00:20:41,010 --> 00:20:41,980
好的。

462
00:20:41,980 --> 00:20:45,590
让打这个按钮，在这里。

463
00:20:45,590 --> 00:20:46,420
好的。

464
00:20:46,420 --> 00:20:49,490
所以，在这里你有一个现代化的黑板上。

465
00:20:49,490 --> 00:20:53,050
我的主要功能是，例如。

466
00:20:53,050 --> 00:20:55,990
我没有一台iPad拿在手中。

467
00:20:55,990 --> 00:20:59,000
我真的不记得怎么样 - 好了，其实，不能说。

468
00:20:59,000 --> 00:21:02,200
我真的没有很好的笔迹。

469
00:21:02,200 --> 00:21:05,260
所以，我希望你能在屏幕上打印的东西对我来说。

470
00:21:05,260 --> 00:21:07,470
>> 所以我的主要程序。

471
00:21:07,470 --> 00:21:15,060
我要你说，这写在我的鸡从头开始，

472
00:21:15,060 --> 00:21:16,600
然后将你的输入。

473
00:21:16,600 --> 00:21:20,000
因此，尽管这项工作是愚蠢的，函数的概念，并调用

474
00:21:20,000 --> 00:21:22,260
功能，并返回一个函数真的归结到这。

475
00:21:22,260 --> 00:21:23,120
我主要的。

476
00:21:23,120 --> 00:21:26,270
我刚才写在屏幕上输出（“东西”）。

477
00:21:26,270 --> 00:21:27,470
我运行这个程序。

478
00:21:27,470 --> 00:21:30,900
如printf被调用，它需要一个参数 - 或一个参数，

479
00:21:30,900 --> 00:21:31,660
有时 - 

480
00:21:31,660 --> 00:21:32,780
双引号之间。

481
00:21:32,780 --> 00:21:33,960
这里有这样的说法。

482
00:21:33,960 --> 00:21:35,740
我把它传递给肯。

483
00:21:35,740 --> 00:21:39,390
现在，他写了一些数年前，显然是一个黑盒子

484
00:21:39,390 --> 00:21:41,070
只有知道如何打印在屏幕上的东西。

485
00:21:41,070 --> 00:21:42,320
>> 所以，执行。

486
00:21:48,842 --> 00:21:49,900
这是不坏的。

487
00:21:49,900 --> 00:21:50,890
所以，很不错。

488
00:21:50,890 --> 00:21:52,900
所以，现在肯执行。

489
00:21:52,900 --> 00:21:55,810
他递给我任何东西吗？

490
00:21:55,810 --> 00:21:57,240
因此，到目前为止，我们已经看到的。

491
00:21:57,240 --> 00:21:59,230
同样，printf并返回一个数字。

492
00:21:59,230 --> 00:22:01,640
但是，我们要忽略的是现在，因为我们从来没有用过它。

493
00:22:01,640 --> 00:22:03,400
所以这是它为肯。

494
00:22:03,400 --> 00:22:06,650
因此，现在主要来执行 - 

495
00:22:06,650 --> 00:22:09,630
主要接管程序的控制，因为这行代码，

496
00:22:09,630 --> 00:22:11,010
printf中进行执行。

497
00:22:11,010 --> 00:22:13,890
我们去了解我们的方式执行的任何其他线路有。

498
00:22:13,890 --> 00:22:14,130
>> 好的。

499
00:22:14,130 --> 00:22:17,080
现在让我们尝试一个稍微不同的例子。

500
00:22:17,080 --> 00:22:22,430
这一次，在这里，让我们先来清除屏幕。

501
00:22:22,430 --> 00:22:24,670
而这个时候，我们会做的魔方功能。

502
00:22:24,670 --> 00:22:27,350
但是这一次，我期望的输出值。

503
00:22:27,350 --> 00:22:28,630
因此，让我们继续前进，并做到这一点。

504
00:22:28,630 --> 00:22:35,680
所以，现在我有一个行代码，说X =立方体（X）。

505
00:22:35,680 --> 00:22:36,930
因此，实际上let's  - 

506
00:22:41,450 --> 00:22:43,940
行的代码，召回，看起来是这样的。

507
00:22:43,940 --> 00:22:45,960
X =立方体（X）。

508
00:22:45,960 --> 00:22:48,100
所以，这是怎么去上班？

509
00:22:48,100 --> 00:22:50,820
因此，让我们继续前进，并给你一个白色的屏幕。

510
00:22:50,820 --> 00:22:55,000
我要现在写下来的x的值，在这一刻

511
00:22:55,000 --> 00:23:01,080
时间发生，让我们说，2，保持它的简单。

512
00:23:01,080 --> 00:23:04,890
因此，我已写在一张纸的价值2，

513
00:23:04,890 --> 00:23:06,100
这是我的x值。

514
00:23:06,100 --> 00:23:08,250
我把它肯。

515
00:23:08,250 --> 00:23:09,200
KEN：我只写答案是什么？

516
00:23:09,200 --> 00:23:12,660
DAVID J.马兰：是啊，让我们只写答案。

517
00:23:12,660 --> 00:23:13,030
好吧。

518
00:23:13,030 --> 00:23:16,280
现在他已经回到我的东西。

519
00:23:16,280 --> 00:23:17,560
所以 - 

520
00:23:17,560 --> 00:23:18,170
完美的。

521
00:23:18,170 --> 00:23:18,840
尼斯SEGUE。

522
00:23:18,840 --> 00:23:21,970
>> 所以，现在他递给我回值8，在这种情况下。

523
00:23:21,970 --> 00:23:23,220
我该怎么办呢？

524
00:23:23,220 --> 00:23:26,130
嗯，其实，让我们来看看。

525
00:23:26,130 --> 00:23:26,640
得到这个权利。

526
00:23:26,640 --> 00:23:27,880
我会用它做什么呢？

527
00:23:27,880 --> 00:23:31,900
现在，我将这个值和实际存储在这些

528
00:23:31,900 --> 00:23:33,400
在存储器中的相同比特。

529
00:23:33,400 --> 00:23:35,030
但是，请注意，我是那种挣扎在这里。

530
00:23:35,030 --> 00:23:38,280
我有点困惑，因为我在哪里写x的值吗？

531
00:23:38,280 --> 00:23:41,840
因为我刚刚做的是需要亲自肯一张纸

532
00:23:41,840 --> 00:23:44,400
的值是2，这为x。

533
00:23:44,400 --> 00:23:46,300
事实上，这恰恰会发生什么。

534
00:23:46,300 --> 00:23:50,100
因此，原来，当你调用一个函数，并传递参数

535
00:23:50,100 --> 00:23:54,130
喜欢的“Hello World”，或者你传递一个参数，如2，一般，你

536
00:23:54,130 --> 00:23:56,720
通过在副本这样的说法。

537
00:23:56,720 --> 00:24:01,020
所以，正如我写下的2号这里，并把它交给肯;

538
00:24:01,020 --> 00:24:04,760
意思是，我仍然有一份价值2的地方。

539
00:24:04,760 --> 00:24:08,140
因为事实上，现在我已经得到了值8，我需要回去

540
00:24:08,140 --> 00:24:12,010
RAM写下我曾经有过的数字2。

541
00:24:12,010 --> 00:24:15,720
>> 所以，直观地记住这个概念在字面上通过

542
00:24:15,720 --> 00:24:16,730
值的副本。

543
00:24:16,730 --> 00:24:19,570
肯做他的事，交给我的东西 - 在这种情况下，

544
00:24:19,570 --> 00:24:20,820
这样的值8。

545
00:24:20,820 --> 00:24:22,660
然后，我与价值的东西，如果我

546
00:24:22,660 --> 00:24:24,880
要保持它的周围。

547
00:24:24,880 --> 00:24:29,470
因此，所有这一切都将是所有太熟悉了不久。

548
00:24:29,470 --> 00:24:33,082
非常感谢你在这里演示，肯。

549
00:24:33,082 --> 00:24:34,820
好的。

550
00:24:34,820 --> 00:24:36,720
非常好。

551
00:24:36,720 --> 00:24:40,610
因此，让我们来看看如何，最终涉及到的一些功能

552
00:24:40,610 --> 00:24:42,270
调用，我们一直在这里做什么。

553
00:24:42,270 --> 00:24:47,610
因此，让我继续前进，把我们带回了魔方的例子在这里。

554
00:24:47,610 --> 00:24:53,080
注意到，如果我们要真正开始采取进一步，我们将

555
00:24:53,080 --> 00:24:57,050
必须注意的一个事实，即数x被传递

556
00:24:57,050 --> 00:25:01,390
这里实际上被传递到函数是不同的。

557
00:25:01,390 --> 00:25:03,940
所以，再一次，通过复制将变得相当

558
00:25:03,940 --> 00:25:05,620
锗在短短的时刻。

559
00:25:05,620 --> 00:25:09,320
>> 所以，让我们来看看在一些不相当的工作。

560
00:25:09,320 --> 00:25:11,790
我会继续前进，打开第三个马车例如，

561
00:25:11,790 --> 00:25:13,560
是有缺陷的性质。

562
00:25:13,560 --> 00:25:18,070
它被称为buggy3，和它实现了一个交换的功能。

563
00:25:18,070 --> 00:25:23,500
所以，在这里，我们有一个主函数，x和y的任意初始化为

564
00:25:23,500 --> 00:25:24,720
分别为1和2，。

565
00:25:24,720 --> 00:25:27,590
我们可以使用调用getInt，但我们只需要一个简单的练习。

566
00:25:27,590 --> 00:25:29,680
因此，它是硬编码为1和2。

567
00:25:29,680 --> 00:25:35,330
在第21行和22行，我们似乎打印出x和y，每行一个。

568
00:25:35,330 --> 00:25:39,620
然后，在第23行，我要求我交换这些值，点，点，点。

569
00:25:39,620 --> 00:25:43,030
显然，我在第24行调用一个函数，称为交换

570
00:25:43,030 --> 00:25:44,000
，它有两个参数。

571
00:25:44,000 --> 00:25:46,430
这是完全合法的，采取两个参数的函数。

572
00:25:46,430 --> 00:25:48,220
我们已经看到输出已经做到这一点了。

573
00:25:48,220 --> 00:25:50,370
所以交换显然x和y。

574
00:25:50,370 --> 00:25:53,010
正如它的名字所暗示的，我希望这是怎么回事

575
00:25:53,010 --> 00:25:54,320
交换这两个值。

576
00:25:54,320 --> 00:25:57,560
因此，我要求在第25行，交换。

577
00:25:57,560 --> 00:26:01,570
我转载的假设下，x和y

578
00:26:01,570 --> 00:26:02,830
我的确被换。

579
00:26:02,830 --> 00:26:04,370
但是，如果我运行这个程序 - 

580
00:26:04,370 --> 00:26:06,060
让我打开一个终端窗口。

581
00:26:06,060 --> 00:26:07,750
让我做buggy3。

582
00:26:07,750 --> 00:26:09,970
正如它的名字所暗示的，这是没有好下场的。

583
00:26:09,970 --> 00:26:14,690
因为当我按下Enter键，注意x是1。

584
00:26:14,690 --> 00:26:15,720
y为2。

585
00:26:15,720 --> 00:26:19,160
但在程序结束时，他们仍，其实，是一样的。

586
00:26:19,160 --> 00:26:22,760
>> 因此，根据示范与肯，刚才到底发生了什么？

587
00:26:22,760 --> 00:26:24,660
好吧，让我们深入到这个交换功能。

588
00:26:24,660 --> 00:26:25,800
它的超级短。

589
00:26:25,800 --> 00:26:28,020
这是只有几行代码长。

590
00:26:28,020 --> 00:26:32,810
但是，什么是最根本的问题的基础上简单的故事告诉

591
00:26:32,810 --> 00:26:34,270
在这里肯吗？

592
00:26:34,270 --> 00:26:36,115
交换为什么坏了？

593
00:26:36,115 --> 00:26:37,365
[听不清]

594
00:26:39,840 --> 00:26:40,460
没错。

595
00:26:40,460 --> 00:26:43,610
因此，我们要存储的副本，而不是变量本身。

596
00:26:43,610 --> 00:26:46,810
换句话说，交换显然有两个参数，一个int。

597
00:26:46,810 --> 00:26:49,370
它的任意称为A和B。

598
00:26:49,370 --> 00:26:54,430
这里，我已经通过在x和y，分别是1和2。

599
00:26:54,430 --> 00:26:56,580
但我不是真的通过在x。

600
00:26:56,580 --> 00:26:58,410
我不是真的在y传递。

601
00:26:58,410 --> 00:27:01,230
我是通过x和y的副本的副本。

602
00:27:01,230 --> 00:27:05,180
这就像几乎就像交换的值复制和粘贴

603
00:27:05,180 --> 00:27:07,440
你希望它是实际操作。

604
00:27:07,440 --> 00:27:11,970
所以，如果是这样的话，当我的程序，开始执行

605
00:27:11,970 --> 00:27:14,140
线35，然后36  - 

606
00:27:14,140 --> 00:27:17,740
当我到37行，在这一点上的故事，是什么值呢？

607
00:27:20,740 --> 00:27:24,850
在这一点上的故事，37号线，在这一点上的价值是什么？

608
00:27:24,850 --> 00:27:25,980
因此，它应该是1。

609
00:27:25,980 --> 00:27:26,170
对吗？

610
00:27:26,170 --> 00:27:29,100
因为x的第一个参数中传递。

611
00:27:29,100 --> 00:27:33,150
而这个函数只是任意调用它的第一个参数，一个。

612
00:27:33,150 --> 00:27:35,130
同样，第二个参数为y。

613
00:27:35,130 --> 00:27:37,930
它只是随意调用的第二个参数b。

614
00:27:37,930 --> 00:27:40,510
>> 现在这种两分法其实是相当简单的解释。

615
00:27:40,510 --> 00:27:40,880
想想吧。

616
00:27:40,880 --> 00:27:42,980
我们没有见过的人谁写输出。

617
00:27:42,980 --> 00:27:49,880
因此，毫无疑问，他或她不知道30年后，我们的变量将

618
00:27:49,880 --> 00:27:50,710
被调用。

619
00:27:50,710 --> 00:27:55,110
所以，必须有区分你调用中的变量

620
00:27:55,110 --> 00:27:59,960
功能，你写的，你在你的函数调用变量

621
00:27:59,960 --> 00:28:01,770
打电话或使用。

622
00:28:01,770 --> 00:28:05,120
所以，换句话说，我写了我的变量x和y。

623
00:28:05,120 --> 00:28:08,060
但是，如果别人已经写了交换功能，他或她肯定

624
00:28:08,060 --> 00:28:10,480
不知道我的变量来调用。

625
00:28:10,480 --> 00:28:13,850
所以认识到，这就是为什么你有这种二元性的名称。

626
00:28:13,850 --> 00:28:16,800
从技术上讲，我可以做到这一点巧合。

627
00:28:16,800 --> 00:28:19,750
但他们仍然会通过为副本。

628
00:28:19,750 --> 00:28:22,940
这仅仅是一个纯粹的巧合美观，如果那个人是谁写的

629
00:28:22,940 --> 00:28:25,590
交换使用相同的名称。

630
00:28:25,590 --> 00:28:25,930
>> 好的。

631
00:28:25,930 --> 00:28:29,010
所以在这一点上故事中的第37行，一个是1。

632
00:28:29,010 --> 00:28:30,410
b是2。

633
00:28:30,410 --> 00:28:32,040
现在我进行交换。

634
00:28:32,040 --> 00:28:34,730
首先，让我真正做到这一点简单得多。

635
00:28:34,730 --> 00:28:36,500
我不知道这三行代码做什么。

636
00:28:36,500 --> 00:28:37,370
让我做到这一点。

637
00:28:37,370 --> 00:28:38,850
b得到。

638
00:28:38,850 --> 00:28:40,170
一个得到b。

639
00:28:40,170 --> 00:28:41,450
完成。

640
00:28:41,450 --> 00:28:43,540
为什么是这个破碎的，逻辑上吗？

641
00:28:46,980 --> 00:28:48,590
这是一种直观的东西，对不对？

642
00:28:48,590 --> 00:28:50,640
因此，一个变成了​​B。

643
00:28:50,640 --> 00:28:52,450
B变成A。

644
00:28:52,450 --> 00:28:55,410
但问题是，尽快执行第37行，有什么

645
00:28:55,410 --> 00:28:58,170
a和b的值？

646
00:28:58,170 --> 00:28:59,070
相同的是，1。

647
00:28:59,070 --> 00:29:03,460
因为你打一顿，可以这么说，你已经改变了b为一个。

648
00:29:03,460 --> 00:29:06,000
所以，第37行执行，这是伟大的。

649
00:29:06,000 --> 00:29:09,940
你现在有此功能的号码1内部的两个副本。

650
00:29:09,940 --> 00:29:14,720
那么，当你说在第38行，得到b，好了，你种拧紧。

651
00:29:14,720 --> 00:29:17,370
因为你只是分配1比1。

652
00:29:17,370 --> 00:29:20,400
你失去了你关心的价值。

653
00:29:20,400 --> 00:29:22,910
>> 因此，在原始版本，请注意，我就是这样做的。

654
00:29:22,910 --> 00:29:26,620
我不是有三分之一的代码看起来是这样的。

655
00:29:26,620 --> 00:29:29,910
我声明了一个临时变量 -  tmp是一个很常见的名字

656
00:29:29,910 --> 00:29:31,240
一个临时变量。

657
00:29:31,240 --> 00:29:34,280
它是一个int，因为它符合我要的副本。

658
00:29:34,280 --> 00:29:39,720
存储副本的tmp目录内的。因此，一旦线路37条的执行，

659
00:29:39,720 --> 00:29:41,390
a的值是 - 

660
00:29:41,390 --> 00:29:42,970
快速完整性检查 - 

661
00:29:42,970 --> 00:29:43,460
1。

662
00:29:43,460 --> 00:29:45,780
b的值是2。

663
00:29:45,780 --> 00:29:48,470
TMP的价值也是1。

664
00:29:48,470 --> 00:29:51,470
所以，现在我执行第38行。

665
00:29:51,470 --> 00:29:57,180
因此，一旦执行第38行，一个需要的b的值。

666
00:29:57,180 --> 00:29:58,510
和B是2。

667
00:29:58,510 --> 00:30:00,500
因此，一个现在是2。

668
00:30:00,500 --> 00:30:03,110
所以在这一点上的故事，一个是2，b为2，

669
00:30:03,110 --> 00:30:05,130
tmp是1。

670
00:30:05,130 --> 00:30:09,330
所以，现在从逻辑上讲，我们只是扑通TMP到b的值。

671
00:30:09,330 --> 00:30:10,690
我们就大功告成了。

672
00:30:10,690 --> 00:30:12,170
>> 因此，我们已经解决了这个问题。

673
00:30:12,170 --> 00:30:16,040
不幸的是，当我运行这个程序，在这种形式，它并不实际交换

674
00:30:16,040 --> 00:30:17,700
任何值。

675
00:30:17,700 --> 00:30:18,950
但要清楚，为什么呢？

676
00:30:23,420 --> 00:30:26,310
我刚才固定的逻辑问题。

677
00:30:26,310 --> 00:30:31,150
但同样，如果我运行这个程序，X和Y保持不变，年底

678
00:30:31,150 --> 00:30:33,834
该计划的执行。

679
00:30:33,834 --> 00:30:34,760
[听不清]

680
00:30:34,760 --> 00:30:36,030
DAVID J.马兰，因此，我们不返回任何东西。

681
00:30:36,030 --> 00:30:36,960
所以，这是事实。

682
00:30:36,960 --> 00:30:39,880
但事实证明，这里有一个有点问题，因为到目前为止，

683
00:30:39,880 --> 00:30:42,460
，我们已经能够返回的唯一的一件事。

684
00:30:42,460 --> 00:30:46,540
这是一个限制，您可以只返回一个真正的价值，

685
00:30:46,540 --> 00:30:48,970
在这种情况下，我被堵到了这里

686
00:30:48,970 --> 00:30:51,805
因为我可以返回新的x值，否则我可能会返回

687
00:30:51,805 --> 00:30:53,160
新y的值。

688
00:30:53,160 --> 00:30:54,330
不过，我既要回来了。

689
00:30:54,330 --> 00:30:58,010
于是久违这里没有简单的解决方案。

690
00:30:58,010 --> 00:30:59,770
但问题的根本是为什么呢？

691
00:30:59,770 --> 00:31:03,270
我们有什么实际交换？

692
00:31:03,270 --> 00:31:04,010
a和b。

693
00:31:04,010 --> 00:31:07,670
但是，a和b的副本的x和y，这意味着我们只是做了这一切

694
00:31:07,670 --> 00:31:10,080
 - 我们只花了像三分钟谈交换

695
00:31:10,080 --> 00:31:11,680
功能和所有这三个变量。

696
00:31:11,680 --> 00:31:15,090
这是伟大的，完全正确的，孤立的。

697
00:31:15,090 --> 00:31:20,230
但是，A和B的范围不仅是在这些行。

698
00:31:20,230 --> 00:31:24,130
因此，就像一个for循环，如果你声明一个整数i在for

699
00:31:24,130 --> 00:31:27,400
环 - 同样，如果你声明a和b里面的功能，

700
00:31:27,400 --> 00:31:30,550
你写的，他们是该函数的唯一有效的内部。

701
00:31:30,550 --> 00:31:35,020
这意味着只要交换是执行，我们从线24条，

702
00:31:35,020 --> 00:31:38,380
线25，x和y没有被改变。

703
00:31:38,380 --> 00:31:42,580
你只是浪费了大量的时间交换的变量的副本。

704
00:31:42,580 --> 00:31:46,490
>> 所以，事实证明，要解决这个实际上是不很明显。

705
00:31:46,490 --> 00:31:49,210
这不是很充足的返回值，因为我们可以

706
00:31:49,210 --> 00:31:50,320
只返回一个值。

707
00:31:50,320 --> 00:31:53,370
我真的想交换x和y都在相同的时间。

708
00:31:53,370 --> 00:31:55,020
因此，我们要回到这个。

709
00:31:55,020 --> 00:31:58,770
不过，现在认识到这个问题从根本上源于一个事实

710
00:31:58,770 --> 00:32:00,660
a和b的副本。

711
00:32:00,660 --> 00:32:03,450
他们是在自己的范围内。

712
00:32:03,450 --> 00:32:04,980
好吧，让我们以某种方式设法解决这个。

713
00:32:04,980 --> 00:32:09,200
让我真正滚动回到这里，开拓，让我们说，第四个变种

714
00:32:09,200 --> 00:32:11,170
此，buggy4。

715
00:32:11,170 --> 00:32:13,230
又是怎么回事吗？

716
00:32:13,230 --> 00:32:16,690
这是一个类似，但更简单的看问题之前，我们采取一捅

717
00:32:16,690 --> 00:32:17,530
解决它。

718
00:32:17,530 --> 00:32:19,440
这项计划被称为增量。

719
00:32:19,440 --> 00:32:24,320
它显然初始化的x为1的整数，在第18行中。

720
00:32:24,320 --> 00:32:25,950
然后，我x是1。

721
00:32:25,950 --> 00:32:28,020
然后，我声称递增，点，点，点。

722
00:32:28,020 --> 00:32:29,460
然后我打电话增量。

723
00:32:29,460 --> 00:32:33,480
但随后在22日和23线，我要求它已经增加。

724
00:32:33,480 --> 00:32:37,780
我要求x是现在不管它是什么，大概是2。

725
00:32:37,780 --> 00:32:39,770
>> 但这种方案是不稳定的。

726
00:32:39,770 --> 00:32:41,020
有什么问题吗？

727
00:32:43,450 --> 00:32:44,418
是吗？

728
00:32:44,418 --> 00:32:45,668
[听不清]

729
00:32:49,260 --> 00:32:49,850
DAVID J.马兰：没错。

730
00:32:49,850 --> 00:32:52,430
所以X显然已宣布的第18行。

731
00:32:52,430 --> 00:32:54,410
这是内主要的大括号中。

732
00:32:54,410 --> 00:32:58,470
所以，简单的答案是，在这里，x存在。

733
00:32:58,470 --> 00:33:01,510
它不存在于线32。

734
00:33:01,510 --> 00:33:03,710
因此，这个程序实际上不会编译。

735
00:33:03,710 --> 00:33:07,910
编译器，当我尝试编译这段代码时，会骂我

736
00:33:07,910 --> 00:33:13,190
一些未声明的标识符或东西的效果。

737
00:33:13,190 --> 00:33:13,870
事实上，让我们尝试。

738
00:33:13,870 --> 00:33:15,235
这是使buggy4。

739
00:33:17,780 --> 00:33:18,190
在那里，它是。

740
00:33:18,190 --> 00:33:22,030
使用未声明的标识符x线32。

741
00:33:22,030 --> 00:33:25,700
而实际上，让我们更加明确，今天在这里，这是非常有用的

742
00:33:25,700 --> 00:33:27,140
办公时间和在家里。

743
00:33:27,140 --> 00:33:29,000
请注意，这是一个有点神秘的书面。

744
00:33:29,000 --> 00:33:31,560
但事实上，铿锵有对我们大吼大叫，说

745
00:33:31,560 --> 00:33:36,970
buggy4.c：32:5，实际上是有用的。

746
00:33:36,970 --> 00:33:41,970
这意味着，该错误是在字符位置5的线32上。

747
00:33:41,970 --> 00:33:44,670
因此，一，二，三，四，五。

748
00:33:44,670 --> 00:33:46,640
这是，事实上，问题出在哪里。

749
00:33:46,640 --> 00:33:49,710
同时要记住，在办公时间，在家里，我很幸运在这里。

750
00:33:49,710 --> 00:33:50,740
我有一个错误。

751
00:33:50,740 --> 00:33:52,660
这将是比较容易解决的。

752
00:33:52,660 --> 00:33:56,220
但是，如果你获得压倒性的错误消息，再次充满整个​​画面，

753
00:33:56,220 --> 00:33:59,240
实现最底层的人可能只是对症

754
00:33:59,240 --> 00:34:00,320
最顶层的。

755
00:34:00,320 --> 00:34:03,560
因此，总是追逐你的错误，从上而下。

756
00:34:03,560 --> 00:34:06,720
因为有可能只是一个菊花链的效果，建议你

757
00:34:06,720 --> 00:34:09,030
有比你实际做的方式更多的问题。

758
00:34:09,030 --> 00:34:14,989
>> 那么，我们怎么能解决这个问题，如果我的目标是增加x？

759
00:34:14,989 --> 00:34:15,370
那是什么？

760
00:34:15,370 --> 00:34:15,620
好吧。

761
00:34:15,620 --> 00:34:16,679
因此，我们可以使X全球。

762
00:34:16,679 --> 00:34:18,860
让我们走捷径，我警告早期。

763
00:34:18,860 --> 00:34:20,550
不过，赫克说，我们只需要一个快速解决。

764
00:34:20,550 --> 00:34:23,949
因此，让我们在这里说诠释x。

765
00:34:23,949 --> 00:34:25,600
这使得X全球。

766
00:34:25,600 --> 00:34:28,460
所以，现在主要有访问它。

767
00:34:28,460 --> 00:34:31,780
而增加的访问。

768
00:34:31,780 --> 00:34:33,860
因此，让我继续前进，现在编译这个。

769
00:34:33,860 --> 00:34:36,330
，输入使buggy4。

770
00:34:36,330 --> 00:34:37,440
似乎现在编译。

771
00:34:37,440 --> 00:34:40,949
让我们来运行buggy4，它似乎实际工作。

772
00:34:40,949 --> 00:34:42,780
现在，这是这些东西之一 - 

773
00:34:42,780 --> 00:34:45,870
听我的话，还不如我呢，我刚刚在这里完成。

774
00:34:45,870 --> 00:34:49,239
因为整体来说，我们的计划将变得更加有趣，

775
00:34:49,239 --> 00:34:50,440
比这更长的时间。

776
00:34:50,440 --> 00:34:53,199
如果您解决生活中的问题是啊，把所有的

777
00:34:53,199 --> 00:34:57,550
在文件的开头的变量，很快就做节目得到

778
00:34:57,550 --> 00:34:59,700
惊人，难以管理。

779
00:34:59,700 --> 00:35:02,050
它变得很难想出新的变量名。

780
00:35:02,050 --> 00:35:05,240
它会更难理解变量是做什么的。

781
00:35:05,240 --> 00:35:08,250
>> ，因此，在一般的，这是不是一个好的解决方案。

782
00:35:08,250 --> 00:35:09,780
因此，让我们做到这一点。

783
00:35:09,780 --> 00:35:11,920
我们不想在这里使用一个全局变量。

784
00:35:11,920 --> 00:35:14,050
我想增加x。

785
00:35:14,050 --> 00:35:16,050
所以，我可以很明显 - 

786
00:35:16,050 --> 00:35:18,450
在一天结束的时候，这是一个愚蠢的故事，因为我们只要做到这一点。

787
00:35:18,450 --> 00:35:22,050
但是，如果我不知道，运营商，或我没有被允许到

788
00:35:22,050 --> 00:35:27,700
改变它在主本身，怎么可能我实现了肯在这里，这

789
00:35:27,700 --> 00:35:31,450
时间到多维数据集，但增加？

790
00:35:31,450 --> 00:35:32,700
我该如何改变这件事情吗？

791
00:35:32,700 --> 00:35:33,025
是啊。

792
00:35:33,025 --> 00:35:34,275
[听不清]

793
00:35:37,430 --> 00:35:38,000
DAVID J.马兰：好，好。

794
00:35:38,000 --> 00:35:40,490
那么，为什么不让我通过在x？

795
00:35:40,490 --> 00:35:44,390
然后，而不是返回它，为什么不，我只是做回X + 1？

796
00:35:44,390 --> 00:35:46,370
现在，一对夫妇更多的东西必须改变。

797
00:35:46,370 --> 00:35:47,530
我在正确的轨道上。

798
00:35:47,530 --> 00:35:48,910
还有什么我需要调整吗？

799
00:35:48,910 --> 00:35:49,470
别人。

800
00:35:49,470 --> 00:35:49,882
是吗？

801
00:35:49,882 --> 00:35:51,530
[听不清]

802
00:35:51,530 --> 00:35:53,520
DAVID J.马兰：我需要改变的返回类型增加

803
00:35:53,520 --> 00:35:54,590
因为它并非无效。

804
00:35:54,590 --> 00:35:56,650
虚空意味着什么也没有返回。

805
00:35:56,650 --> 00:35:57,600
但显然，现在是。

806
00:35:57,600 --> 00:36:01,280
因此，这需要改变int以符合任何

807
00:36:01,280 --> 00:36:02,580
实际上，我回来了。

808
00:36:02,580 --> 00:36:04,580
>> 现在别的东西，是大声喧哗。

809
00:36:04,580 --> 00:36:04,982
是吗？

810
00:36:04,982 --> 00:36:06,590
[听不清]

811
00:36:06,590 --> 00:36:07,630
DAVID J.马兰：所以我需要增加x？

812
00:36:07,630 --> 00:36:10,336
[听不清]

813
00:36:10,336 --> 00:36:11,880
DAVID J.马兰：啊，所以我需要传递X。

814
00:36:11,880 --> 00:36:13,300
所以我需要在这里做到这一点。

815
00:36:17,590 --> 00:36:19,690
因此，原型，我必须要改变这个在这里。

816
00:36:19,690 --> 00:36:21,290
因此，这成为一个int。

817
00:36:21,290 --> 00:36:22,820
这成为 - 

818
00:36:22,820 --> 00:36:23,670
嗯。

819
00:36:23,670 --> 00:36:24,710
其实，我这里有一个错误。

820
00:36:24,710 --> 00:36:25,780
让我们来解决这个问题第一次。

821
00:36:25,780 --> 00:36:27,990
应该是什么内容究竟是什么？

822
00:36:27,990 --> 00:36:29,330
因此，它必须是一个int的东西。

823
00:36:29,330 --> 00:36:30,340
它可以是x。

824
00:36:30,340 --> 00:36:33,120
但是坦率地说，如果你开始调用所有的变量x，它会得到

825
00:36:33,120 --> 00:36:35,250
越来越不清晰哪个是哪个。

826
00:36:35,250 --> 00:36:38,210
因此，让我们任意选择一个不同的命名约定为我的

827
00:36:38,210 --> 00:36:40,220
辅助函数，我写的功能。

828
00:36:40,220 --> 00:36:41,100
我们将调用它。

829
00:36:41,100 --> 00:36:44,500
或者，我们可以把它称为 - 我们姑且称之为，它even_number更明确。

830
00:36:44,500 --> 00:36:47,610
于是我返回任何数加1。

831
00:36:47,610 --> 00:36:49,720
现在，我必须要改变一个其他的东西在这里，一个

832
00:36:49,720 --> 00:36:50,700
其他的东西在这里。

833
00:36:50,700 --> 00:36:54,150
我有什么改变第21行第一次吗？

834
00:36:54,150 --> 00:36:55,390
我有把它分配给x。

835
00:36:55,390 --> 00:36:57,480
这样我就可以不叫增量x。

836
00:36:57,480 --> 00:37:01,000
通过改变x的值，我需要记住的答案

837
00:37:01,000 --> 00:37:02,020
左手侧。

838
00:37:02,020 --> 00:37:04,930
即使x是现在的左，右，这是完全正常的，因为

839
00:37:04,930 --> 00:37:08,370
首先被执行的右手侧，然后被扑通进入左

840
00:37:08,370 --> 00:37:10,240
手的事情，x在这种情况下。

841
00:37:10,240 --> 00:37:11,900
最后，这是一个简单的办法。

842
00:37:11,900 --> 00:37:15,080
这应该匹配什么是向下。

843
00:37:15,080 --> 00:37:17,120
诠释号。

844
00:37:17,120 --> 00:37:17,320
>> 好的。

845
00:37:17,320 --> 00:37:20,290
那么一大堆的一个非常愚蠢的功能的变化。

846
00:37:20,290 --> 00:37:24,250
但代表，我们将越来越多地想要做的事情。

847
00:37:24,250 --> 00:37:25,490
因此，请buggy4。

848
00:37:25,490 --> 00:37:26,485
我搞砸了的地方。

849
00:37:26,485 --> 00:37:27,520
哦，我的上帝。

850
00:37:27,520 --> 00:37:29,660
五个错误一样，一个六行的计划。

851
00:37:29,660 --> 00:37:36,500
那么，什么是错的第18行，字符？

852
00:37:36,500 --> 00:37:36,970
好的。

853
00:37:36,970 --> 00:37:39,330
所以，我要声明这个中断。

854
00:37:39,330 --> 00:37:39,630
好的。

855
00:37:39,630 --> 00:37:41,790
所以，让我们来看看，一大堆其他错误。

856
00:37:41,790 --> 00:37:42,230
噢，我的上帝。

857
00:37:42,230 --> 00:37:43,880
19，18，21。

858
00:37:43,880 --> 00:37:46,020
再次，让我们清除屏幕 - 

859
00:37:46,020 --> 00:37:48,660
控制L  - 并重新运行铛。

860
00:37:48,660 --> 00:37:51,340
因此，五个方面的问题是实际上只是一个。

861
00:37:51,340 --> 00:37:53,500
所以，现在让我们来运行buggy4，回车。

862
00:37:53,500 --> 00:37:54,150
哇！

863
00:37:54,150 --> 00:37:57,434
x已经被正确地递增。

864
00:37:57,434 --> 00:37:58,420
>> 好的。

865
00:37:58,420 --> 00:38:01,700
如何增加数字的任何问题？

866
00:38:01,700 --> 00:38:02,896
是吗？

867
00:38:02,896 --> 00:38:06,864
主讲人2：为什么是它，你可以只改变x的变量数

868
00:38:06,864 --> 00:38:08,860
命名，它会知道你是什么意思？

869
00:38:08,860 --> 00:38:09,600
DAVID J.马兰：好问题。

870
00:38:09,600 --> 00:38:13,130
它是如何，我可以只改变x的数量，程序将知道

871
00:38:13,130 --> 00:38:13,990
立即吗？

872
00:38:13,990 --> 00:38:16,120
所以，再一次，把它作为这个抽象。

873
00:38:16,120 --> 00:38:20,110
所以，如果我主要和Ken是渐进式的，坦率地说，我不关心

874
00:38:20,110 --> 00:38:21,540
什么肯称，他的iPad。

875
00:38:21,540 --> 00:38:25,350
我不在乎他所说的什么，做他的执行

876
00:38:25,350 --> 00:38:26,550
这个功能。

877
00:38:26,550 --> 00:38:32,130
所以这是一个实现细节，我，主，不

878
00:38:32,130 --> 00:38:33,010
有关心。

879
00:38:33,010 --> 00:38:37,440
因此，简单地改变它一贯里面的功能，号

880
00:38:37,440 --> 00:38:41,340
和数量，是需要很长时间，我重新编译。

881
00:38:41,340 --> 00:38:43,820
这是有点像，如果你认为的 - 很多人来说，你的驱动程序的

882
00:38:43,820 --> 00:38:46,590
许可所驱动，或者如果你即使在汽车驱动 - 

883
00:38:46,590 --> 00:38:50,710
我们大多数人不知道如何汽车引擎盖下的。

884
00:38:50,710 --> 00:38:54,710
从字面上看，如果你打开​​引擎盖，我们大多数人 - 包括我自己 - 

885
00:38:54,710 --> 00:38:56,580
不会真正了解我们正在寻找。

886
00:38:56,580 --> 00:38:58,850
有点像你可能会觉得现在的东西，如这项权利。

887
00:38:58,850 --> 00:39:01,380
但是，我们真的不关心汽车是如何工作的。

888
00:39:01,380 --> 00:39:05,000
我们不必关心所有内部的杆和活塞和电缆

889
00:39:05,000 --> 00:39:07,700
汽车实际上是在做什么。

890
00:39:07,700 --> 00:39:11,360
>> 所以像你所说的活塞无所谓

891
00:39:11,360 --> 00:39:11,920
这里在这种情况下。

892
00:39:11,920 --> 00:39:12,490
同样的想法。

893
00:39:12,490 --> 00:39:12,670
是吗？

894
00:39:12,670 --> 00:39:13,920
[听不清]

895
00:39:25,250 --> 00:39:29,530
DAVID J.马兰：如果有更多的用途的变量XA时刻前，

896
00:39:29,530 --> 00:39:32,220
作为程序员，你将不得不改变他们无处不在。

897
00:39:32,220 --> 00:39:35,230
或者你可以从字面上文件，菜单，然后查找/替换，

898
00:39:35,230 --> 00:39:36,270
类似的东西。

899
00:39:36,270 --> 00:39:40,110
但是你将不得不让自己的这些变化。

900
00:39:40,110 --> 00:39:41,200
你必须是一致的。

901
00:39:41,200 --> 00:39:42,450
[听不清]

902
00:39:47,200 --> 00:39:48,960
DAVID J.马兰特定的顺序：A喜欢这里吗？

903
00:39:48,960 --> 00:39:52,660
如果这是int的另一个电话号码吗？

904
00:39:52,660 --> 00:39:52,940
是啊。

905
00:39:52,940 --> 00:39:56,430
因此，为了重要的，当你调用该函数。

906
00:39:56,430 --> 00:40:00,350
所以，如果我在这里呼吁增加的东西逗号东西，

907
00:40:00,350 --> 00:40:01,400
有一个直接的映射。

908
00:40:01,400 --> 00:40:04,490
第一可变，无论它的名字，作出了第一个副本

909
00:40:04,490 --> 00:40:05,480
在这里的论点。

910
00:40:05,480 --> 00:40:07,280
对不起，这不应该是一个括号。

911
00:40:07,280 --> 00:40:09,300
第二个参数与第二个。

912
00:40:09,300 --> 00:40:11,220
>> ，是的，所以，为了事宜。

913
00:40:11,220 --> 00:40:11,490
好的。

914
00:40:11,490 --> 00:40:13,360
对不起，我花了很长的路到那里。

915
00:40:13,360 --> 00:40:14,610
其他问题吗？

916
00:40:16,460 --> 00:40:16,850
好的。

917
00:40:16,850 --> 00:40:20,300
因此，让我们来看看，如果我们不能画一幅画，实际上

918
00:40:20,300 --> 00:40:22,160
引擎盖下的，可以这么说。

919
00:40:22,160 --> 00:40:26,310
因此，这是一个矩形，可能代表你的计算机的内存。

920
00:40:26,310 --> 00:40:31,240
所以，即使你不知道如何记忆或RAM作品如何，至少

921
00:40:31,240 --> 00:40:33,590
假设你有束的这些天。

922
00:40:33,590 --> 00:40:34,740
你得到了它的兆字节。

923
00:40:34,740 --> 00:40:35,760
你有GB的。

924
00:40:35,760 --> 00:40:40,690
我们知道，从周零一个字节是什么？

925
00:40:40,690 --> 00:40:41,280
8位。

926
00:40:41,280 --> 00:40:42,730
对，所以8 0和1。

927
00:40:42,730 --> 00:40:46,300
所以，如果你的计算机有一个演出的RAM，2个演出的RAM这些日子里，你有一个

928
00:40:46,300 --> 00:40:54,450
亿或2亿字节的内存，或大约8亿美元或16亿美元

929
00:40:54,450 --> 00:40:56,560
位，您的计算机内。

930
00:40:56,560 --> 00:40:59,710
现在不像的小绵威利例如，它没有磁性粒子

931
00:40:59,710 --> 00:41:00,560
典型的了。

932
00:41:00,560 --> 00:41:04,470
越来越多的，至少在笔记本电脑，它的固态硬盘，固态硬盘，

933
00:41:04,470 --> 00:41:05,560
只是没有移动部件。

934
00:41:05,560 --> 00:41:06,710
这是所有的电子。

935
00:41:06,710 --> 00:41:08,070
这是所有的电力基础。

936
00:41:08,070 --> 00:41:12,360
因此认为，虽然，这个矩形代表一个或两个

937
00:41:12,360 --> 00:41:13,930
GB的记忆体，你有。

938
00:41:13,930 --> 00:41:15,500
>> 因此，它是一个内存块。

939
00:41:15,500 --> 00:41:20,460
现在世界上的计算机科学类的分区块

940
00:41:20,460 --> 00:41:22,570
内存做不同的事情。

941
00:41:22,570 --> 00:41:25,930
因此，举例来说，如果这是您的计算机的内存 - 所建议的

942
00:41:25,930 --> 00:41:30,400
矩形 - 原来，按照惯例，在您的RAM的顶部，所以

943
00:41:30,400 --> 00:41:33,170
说，一般是什么所谓的文本段。

944
00:41:33,170 --> 00:41:35,910
这些都是零和的，你已经编译。

945
00:41:35,910 --> 00:41:39,040
因此，当我们已经看到引擎盖下的a.out是什么，所有

946
00:41:39,040 --> 00:41:40,360
0和1  - 

947
00:41:40,360 --> 00:41:44,000
当你运行一个程序时，这些0和1，从您的硬盘装入

948
00:41:44,000 --> 00:41:46,290
到一些所谓的RAM驱动器。

949
00:41:46,290 --> 00:41:48,950
在RAM中，他们把在顶部。

950
00:41:48,950 --> 00:41:50,330
同时，你还有其他的事情。

951
00:41:50,330 --> 00:41:53,060
初始化数据，未初始化的数据。

952
00:41:53,060 --> 00:41:56,440
这两个大片的内存是指为全局变量，

953
00:41:56,440 --> 00:41:57,530
你不经常使用。

954
00:41:57,530 --> 00:42:00,630
但有时如果你这样做，他们结束了在那里为好。

955
00:42:00,630 --> 00:42:01,620
此外，还有一些其他的东西。

956
00:42:01,620 --> 00:42:04,130
环境变量，我们不会花太多的时间。

957
00:42:04,130 --> 00:42:06,120
但随后的两件重要的事情会回来整个

958
00:42:06,120 --> 00:42:08,130
学期，堆栈和堆。

959
00:42:08,130 --> 00:42:12,280
>> 因此，大多数您的计算机的内存中运行的程序时保留

960
00:42:12,280 --> 00:42:14,880
一些所谓的堆栈，称为堆的东西。

961
00:42:14,880 --> 00:42:16,940
我们不会谈论堆，但我们会

962
00:42:16,940 --> 00:42:18,180
谈论的堆栈。

963
00:42:18,180 --> 00:42:22,910
和堆栈是为了唤起了视觉像食堂

964
00:42:22,910 --> 00:42:26,120
餐托盘Mather中楼，或任何你碰巧是，这里的

965
00:42:26,120 --> 00:42:27,810
食堂的工作人员清理他们的每一天。

966
00:42:27,810 --> 00:42:30,180
它们堆叠起来，从地板上起来。

967
00:42:30,180 --> 00:42:33,800
同样在内存中，有这种想法，把一些在

968
00:42:33,800 --> 00:42:36,740
叠加，将在栈上的东西，把东西在栈上。

969
00:42:36,740 --> 00:42:38,000
是什么意思呢？

970
00:42:38,000 --> 00:42:41,430
好吧，让我们放大只是这张照片的下半部分，您的电脑

971
00:42:41,430 --> 00:42:43,990
RAM，提出以下建议。

972
00:42:43,990 --> 00:42:48,300
原来，当你运行一个程序，如a.out格式“或”你好，什么

973
00:42:48,300 --> 00:42:49,920
该程序是你写的，

974
00:42:49,920 --> 00:42:53,030
再次，从您的硬盘驱动器加载这些0和1  - 

975
00:42:53,030 --> 00:42:56,190
长期储存，在那里停留，即使你拔掉插头 - 

976
00:42:56,190 --> 00:42:57,220
加载到RAM中。

977
00:42:57,220 --> 00:42:59,020
RAM的速度比硬盘驱动器。

978
00:42:59,020 --> 00:43:00,700
这是小于硬盘驱动器。

979
00:43:00,700 --> 00:43:03,490
但它的节目直播，当你运行它们。

980
00:43:03,490 --> 00:43:06,380
>> 所以，你双击一个Mac或PC上的程序 - 它装载

981
00:43:06,380 --> 00:43:07,750
到RAM中的硬盘驱动器。

982
00:43:07,750 --> 00:43:11,760
只要它加载到内存中，0和1的方式上，

983
00:43:11,760 --> 00:43:13,130
所谓的文本段。

984
00:43:13,130 --> 00:43:17,040
但是，当你的程序启动运行，主要

985
00:43:17,040 --> 00:43:18,140
函数被调用。

986
00:43:18,140 --> 00:43:21,070
为主，正如我们已经看到的那样，经常有局部变量。

987
00:43:21,070 --> 00:43:24,560
它有整型和字符串和字符之类的。

988
00:43:24,560 --> 00:43:28,300
所以，如果你的程序，你写的程序，你有

989
00:43:28,300 --> 00:43:33,680
双击内主要使用的一些变量，他们最终在

990
00:43:33,680 --> 00:43:37,020
你的内存堆栈的底部，可以这么说。

991
00:43:37,020 --> 00:43:39,160
现在更具体地说，这是什么究竟是什么意思？

992
00:43:39,160 --> 00:43:44,080
这也就意味着，如果我们要怎样数算自己的事情 - 

993
00:43:44,080 --> 00:43:49,380
如果我们要在您的计算机数量的字节RAM，请注意，

994
00:43:49,380 --> 00:43:51,650
这可能是字节数为0。

995
00:43:51,650 --> 00:43:56,130
这可能是字节数一，二，三，四，五，六，所有

996
00:43:56,130 --> 00:43:57,290
喜欢 - 

997
00:43:57,290 --> 00:44:01,520
2亿美元将一路攀升，在顶部。

998
00:44:01,520 --> 00:44:05,960
所以，换句话说，当我们谈论RAM或内存中的字节，

999
00:44:05,960 --> 00:44:09,680
只是意味着有人已经决定号每

1000
00:44:09,680 --> 00:44:11,110
这些内存块。

1001
00:44:11,110 --> 00:44:16,950
>> 所以，当你需要32位的int，或者你需要一个字符的8位，其中

1002
00:44:16,950 --> 00:44:18,320
他们结束了在内存里？

1003
00:44:18,320 --> 00:44:20,650
那么从​​理论上讲，他们刚刚结束了在底部的

1004
00:44:20,650 --> 00:44:21,780
东西叫堆栈。

1005
00:44:21,780 --> 00:44:25,670
但现在有什么有趣的是，当主调用一个函数。

1006
00:44:25,670 --> 00:44:28,830
假设一个函数调用foo的，只是一个任意的名称。

1007
00:44:28,830 --> 00:44:32,480
会发生什么更主要的是在这个堆栈的底部的内存。

1008
00:44:32,480 --> 00:44:35,630
美孚现在被放置在顶部的主内存中。

1009
00:44:35,630 --> 00:44:40,020
因此，任何局部变量foo的最终排序的概念上以上

1010
00:44:40,020 --> 00:44:40,770
在主。

1011
00:44:40,770 --> 00:44:46,920
如果foo调用另一个函数调用酒吧，这些变量在这里结束。

1012
00:44:46,920 --> 00:44:49,790
如果酒吧调用别的东西，在这里，这里，这里。

1013
00:44:49,790 --> 00:44:53,900
那么，在运行了一个程序很有意思的是，当你调用函数，

1014
00:44:53,900 --> 00:44:57,720
那些函数调用的函数，这些函数调用功能，

1015
00:44:57,720 --> 00:45:00,980
你建立了这个堆栈在内存中的功能。

1016
00:45:00,980 --> 00:45:06,740
而只有一个函数返回后，你开始，内存。

1017
00:45:06,740 --> 00:45:11,190
因此耗尽内存在计算机程序中最简单的方法之一是

1018
00:45:11,190 --> 00:45:14,170
写函数从不返回。

1019
00:45:14,170 --> 00:45:16,650
>> 因此，举例来说，让尽可能多的展示与

1020
00:45:16,650 --> 00:45:18,460
故意错误的程序。

1021
00:45:18,460 --> 00:45:24,690
让我继续前进，不要＃包括<stdio.h>的，诠释的主要（无效）。

1022
00:45:24,690 --> 00:45:31,270
我该怎么办（2> 1），这可能将永远不会

1023
00:45:31,270 --> 00:45:33,370
改变我们。

1024
00:45:33,370 --> 00:45:37,720
让我继续做输出。

1025
00:45:37,720 --> 00:45:39,950
事实上，这将是在视觉有趣的。

1026
00:45:39,950 --> 00:45:40,460
让我们这样做。

1027
00:45:40,460 --> 00:45:44,840
为Int（i = 0; I> 0）。

1028
00:45:44,840 --> 00:45:49,740
让我们犯这样的错误，我+ +。

1029
00:45:49,740 --> 00:45:51,150
让我们在这里不是printf。

1030
00:45:51,150 --> 00:45:52,550
我们的做法是我的说教。

1031
00:45:52,550 --> 00:45:54,090
让我们在这里有一个方法。

1032
00:45:54,090 --> 00:46:00,860
虚空的合唱，我们会说INT I。

1033
00:46:00,860 --> 00:46:02,295
然后我会说，输出 - 

1034
00:46:04,871 --> 00:46:06,790
哦，让我们使这更有趣的。

1035
00:46:06,790 --> 00:46:08,350
让实际不打印任何东西，在所有。

1036
00:46:08,350 --> 00:46:10,530
我们只要做到这一点。

1037
00:46:10,530 --> 00:46:11,780
合唱团（I）。

1038
00:46:16,630 --> 00:46:17,000
>> 好的。

1039
00:46:17,000 --> 00:46:20,040
因此，这是越野车，因为为什么呢？

1040
00:46:20,040 --> 00:46:22,850
我正在做这件事，因为我去的，因为该计划实际上并没有做什么

1041
00:46:22,850 --> 00:46:23,420
的兴趣。

1042
00:46:23,420 --> 00:46:24,670
但是，这不是目标。

1043
00:46:24,670 --> 00:46:30,440
我们的目标是编写一个程序，做什么，显然，其主要功能？

1044
00:46:30,440 --> 00:46:31,370
调用自身。

1045
00:46:31,370 --> 00:46:32,600
实际上，我们并不需要循环。

1046
00:46:32,600 --> 00:46:36,070
让我们甚至简化这只是因此，不要忽视真正的

1047
00:46:36,070 --> 00:46:37,310
根本的问题。

1048
00:46:37,310 --> 00:46:39,200
主要调用合唱团唱一些合唱。

1049
00:46:39,200 --> 00:46:41,760
然后我做了一些愚蠢的事情，和我有合唱的呼叫合唱团，因为我假定

1050
00:46:41,760 --> 00:46:43,550
别人可能实现它。

1051
00:46:43,550 --> 00:46:45,960
现在，这是不会还来编译。

1052
00:46:45,960 --> 00:46:48,340
我需要做什么？

1053
00:46:48,340 --> 00:46:49,700
我需要的原型，记住了。

1054
00:46:49,700 --> 00:46:55,520
所以我需要在这里有无效合唱团（int i）的。

1055
00:46:55,520 --> 00:46:57,470
>> 所以，现在，如果我去这里 - 

1056
00:46:57,470 --> 00:46:59,030
其实，让我们用更大的窗口。

1057
00:46:59,030 --> 00:47:01,670
让我们继续前进，并合唱。

1058
00:47:01,670 --> 00:47:06,000
让我们继续前进，并合唱。

1059
00:47:06,000 --> 00:47:08,302
使用身份不明申报我。

1060
00:47:08,302 --> 00:47:09,860
哦，那是愚蠢的。

1061
00:47:09,860 --> 00:47:11,020
我们并不需要的参数。

1062
00:47:11,020 --> 00:47:13,680
我们只要做到这一点。

1063
00:47:13,680 --> 00:47:14,550
希望我们能有这样开始。

1064
00:47:14,550 --> 00:47:16,160
这本来是一个更简单的程序编写。

1065
00:47:16,160 --> 00:47:20,100
这样出现了。

1066
00:47:20,100 --> 00:47:23,870
现在，让我们去到我的终端窗口，再次运行铛。

1067
00:47:23,870 --> 00:47:26,900
在这里，我们走了。

1068
00:47:26,900 --> 00:47:28,020
这是真快。

1069
00:47:28,020 --> 00:47:30,690
究竟刚发生时，有关系吗？

1070
00:47:30,690 --> 00:47:33,430
好了，现在我将添加打印线，这样我们就可以看到。

1071
00:47:33,430 --> 00:47:41,330
因此，让我输出，比方说，我在这里。

1072
00:47:41,330 --> 00:47:43,470
好了，没有变量，我们会留下这样的。

1073
00:47:43,470 --> 00:47:44,860
让我重新运行。

1074
00:47:44,860 --> 00:47:47,940
让我重新运行合唱团。

1075
00:47:47,940 --> 00:47:51,235
。

1076
00:47:53,880 --> 00:47:55,130
继续下去。

1077
00:47:57,630 --> 00:47:59,750
顺便说一句，为什么它没有崩溃吗？

1078
00:47:59,750 --> 00:48:02,050
分割故障发生前超级快。

1079
00:48:02,050 --> 00:48:04,250
[听不清]

1080
00:48:04,250 --> 00:48:04,830
DAVID J.马兰：没错。

1081
00:48:04,830 --> 00:48:06,350
因此，它需要一定的时间来打印。

1082
00:48:06,350 --> 00:48:08,370
它只是需要更多的工作在计算机的一部分。

1083
00:48:08,370 --> 00:48:09,550
有。

1084
00:48:09,550 --> 00:48:10,620
分割故障。

1085
00:48:10,620 --> 00:48:12,140
>> 因此，发现是多么快的程序运行。

1086
00:48:12,140 --> 00:48:14,110
如果你没有打印任何东西，超级快。

1087
00:48:14,110 --> 00:48:18,100
但是，我们仍然得到了该段故障，因为发生了什么事？

1088
00:48:18,100 --> 00:48:21,310
好吧，如果你认为您的计算机的内存，这

1089
00:48:21,310 --> 00:48:22,890
恰好是主要的。

1090
00:48:22,890 --> 00:48:23,800
但在这里 - 

1091
00:48:23,800 --> 00:48:28,670
我们只需要调用这个合唱之中，让我们这个合唱团。

1092
00:48:28,670 --> 00:48:33,420
现在，如果我做我的美学，这只是说合唱，

1093
00:48:33,420 --> 00:48:38,060
合唱团，合唱团，合唱团，合唱团，合唱团，合唱团，广告nauseum。

1094
00:48:38,060 --> 00:48:39,920
最终，会发生什么呢？

1095
00:48:39,920 --> 00:48:46,690
如果大的画面字面意思是这样的，这是发生在概念上吗？

1096
00:48:46,690 --> 00:48:48,320
该协议栈溢出堆。

1097
00:48:48,320 --> 00:48:52,400
更糟糕的是，你只是溢出的一切，包括文本段，这是

1098
00:48:52,400 --> 00:48:54,530
0和1代表你的程序。

1099
00:48:54,530 --> 00:48:56,690
总之，这仅仅是超级，超级坏。

1100
00:48:56,690 --> 00:48:56,860
对吗？

1101
00:48:56,860 --> 00:48:58,620
你的程序已失去控制。

1102
00:48:58,620 --> 00:49:02,840
您使用的是比你打算一切都是因为一个愚蠢的方式更多的内存

1103
00:49:02,840 --> 00:49:03,920
错误，在这种情况下。

1104
00:49:03,920 --> 00:49:08,160
或者，在这种情况下，故意做的函数调用自己。

1105
00:49:08,160 --> 00:49:09,210
现在，这并不全是坏事。

1106
00:49:09,210 --> 00:49:12,540
调用自己的函数实际上拥有极大的权力

1107
00:49:12,540 --> 00:49:13,700
当你正确地使用它。

1108
00:49:13,700 --> 00:49:15,650
我还没有正确地使用它在这里。

1109
00:49:15,650 --> 00:49:16,940
>> 因此，这并不全是坏事。

1110
00:49:16,940 --> 00:49:20,620
但事实上，我从来没有真正停止称自己是一个基本的

1111
00:49:20,620 --> 00:49:23,050
这一方案的弱点在这里。

1112
00:49:23,050 --> 00:49:25,090
那么，我们要与所有这一切吗？

1113
00:49:25,090 --> 00:49:26,230
那么，到底发生了什么？

1114
00:49:26,230 --> 00:49:30,010
当我打电话的增量功能，像我们所做的是在那些例子，

1115
00:49:30,010 --> 00:49:33,290
我有一个值，如1，我传进去

1116
00:49:33,290 --> 00:49:35,820
我通过在副本的头号。

1117
00:49:35,820 --> 00:49:37,080
因此，发生以下情况。

1118
00:49:37,080 --> 00:49:40,390
因此，让进入的增量例子。

1119
00:49:40,390 --> 00:49:44,230
而且这家伙就在这里。

1120
00:49:44,230 --> 00:49:46,800
因此，这里实际上发生了什么。

1121
00:49:46,800 --> 00:49:50,770
当我打电话的增量，和我通过在X，形象地什么

1122
00:49:50,770 --> 00:49:53,660
在这里是这样的 - 

1123
00:49:53,660 --> 00:50:00,240
如果我有1的值保存在这里，和其实我打电话增量，这

1124
00:50:00,240 --> 00:50:02,680
现在被称为合唱团 - 

1125
00:50:02,680 --> 00:50:04,010
是啊，把我关在这里。

1126
00:50:04,010 --> 00:50:06,750
所以，让我们把这个增量。

1127
00:50:06,750 --> 00:50:09,420
我们不知道这是什么下一个功能将是。

1128
00:50:09,420 --> 00:50:14,270
那么，什么是实际发生的事情是这里的某个地方，我有一个在主块的

1129
00:50:14,270 --> 00:50:16,670
存储器，存储数字1。

1130
00:50:16,670 --> 00:50:19,730
当我打电话给增量，我使用其他的内存块，但现在我

1131
00:50:19,730 --> 00:50:20,840
有副本1。

1132
00:50:20,840 --> 00:50:25,480
当我增加值，这将成为2  - 可怕的写在

1133
00:50:25,480 --> 00:50:26,420
屏幕在这里。

1134
00:50:26,420 --> 00:50:30,550
但后来，发生了什么，尽快增加回报吗？

1135
00:50:30,550 --> 00:50:34,610
内存只是被交还给操作系统，这意味着所有

1136
00:50:34,610 --> 00:50:37,470
你这样做是没有什么用处。

1137
00:50:37,470 --> 00:50:43,460
实际上仍然是存在的，最初是包含在主。

1138
00:50:43,460 --> 00:50:44,650
>> 所以，我们要这个吗？

1139
00:50:44,650 --> 00:50:49,400
好了，事实证明，在内存中，你有这个背靠背序列

1140
00:50:49,400 --> 00:50:50,940
字节，你可以把东西英寸

1141
00:50:50,940 --> 00:50:53,760
而事实证明，我们已经看到的东西，包括把

1142
00:50:53,760 --> 00:50:55,100
事情背靠背背靠背。

1143
00:50:55,100 --> 00:51:00,170
什么是一个字符串，第一个星期，现在在本周二的基础上吗？

1144
00:51:00,170 --> 00:51:01,840
所以它只是一个字符集合。

1145
00:51:01,840 --> 00:51:05,290
因此，原来，就像你可以把数字在内存中，同样你也可以

1146
00:51:05,290 --> 00:51:06,900
把字符在内存中。

1147
00:51:06,900 --> 00:51:09,810
一旦我们开始把字符在内存中背靠背

1148
00:51:09,810 --> 00:51:12,800
回来，事实证明，使用最简单的事情，比如一个for循环

1149
00:51:12,800 --> 00:51:14,510
while循环中，我们可以遍历 - 

1150
00:51:14,510 --> 00:51:17,130
从左至右在字符串中的字符 - 

1151
00:51:17,130 --> 00:51:20,720
开始按摩到完全不同的字符。

1152
00:51:20,720 --> 00:51:25,550
A可能变为B。有可能成为C.所以，最终，我们可以采取一个

1153
00:51:25,550 --> 00:51:28,830
英语句子，其实是有道理的，每个人转换

1154
00:51:28,830 --> 00:51:32,440
一次一个步行通过我们的计算机的内存离开

1155
00:51:32,440 --> 00:51:34,300
实际上加密的权利。

1156
00:51:34,300 --> 00:51:36,590
>> 因此，让我们在这里，我们五分钟的休息时间，当我们回来时，我们会

1157
00:51:36,590 --> 00:51:39,060
启动这一进程的扰码信息。

1158
00:51:41,640 --> 00:51:43,180
>> 好的。

1159
00:51:43,180 --> 00:51:48,440
所以，在我们深入到一些加密，这些东西称为“阵列”，让我

1160
00:51:48,440 --> 00:51:51,610
暂停任何问题，因为我觉得我是那种混乱的一些

1161
00:51:51,610 --> 00:51:52,230
这些议题。

1162
00:51:52,230 --> 00:51:53,940
所以现在，如果我们可以让我们来解决。

1163
00:51:53,940 --> 00:51:56,480
所以，我们刚才讲的返回值。

1164
00:51:56,480 --> 00:51:58,630
我们谈论的论点。

1165
00:51:58,630 --> 00:52:02,330
我们谈论这个概念，我们回来在周

1166
00:52:02,330 --> 00:52:07,140
来，这些堆积一大堆的查看内存

1167
00:52:07,140 --> 00:52:08,540
托盘，可以这么说。

1168
00:52:08,540 --> 00:52:13,460
从底部上起来，使得每个托盘会在栈上代表

1169
00:52:13,460 --> 00:52:15,160
的功能，这是目前被调用。

1170
00:52:17,970 --> 00:52:20,300
有什么问题吗？

1171
00:52:20,300 --> 00:52:22,890
因此，如何对 - 让我试着问了一个问题。

1172
00:52:22,890 --> 00:52:25,520
我一直在破坏，但现在it's  - 地一下男孩的脸。

1173
00:52:25,520 --> 00:52:27,020
因此，我们将回来。

1174
00:52:27,020 --> 00:52:29,700
>> 因此，让我在这里问一个问题。

1175
00:52:29,700 --> 00:52:34,810
让我简化这回它是什么之前，我们早期的Q＆A.

1176
00:52:34,810 --> 00:52:41,730
而事实上，增量左括号，INT数，关闭

1177
00:52:41,730 --> 00:52:42,260
括号内。

1178
00:52:42,260 --> 00:52:46,370
整数数字代表什么？

1179
00:52:46,370 --> 00:52:47,250
[听不清]

1180
00:52:47,250 --> 00:52:47,870
DAVID J.马兰的说法。

1181
00:52:47,870 --> 00:52:50,732
好了，但什么是参数？

1182
00:52:50,732 --> 00:52:51,620
[听不清]

1183
00:52:51,620 --> 00:52:52,500
DAVID J.马兰：对不起，那是什么？

1184
00:52:52,500 --> 00:52:53,150
主讲人3：你传进去的东西

1185
00:52:53,150 --> 00:52:53,570
DAVID J.马兰：好吧。

1186
00:52:53,570 --> 00:52:54,780
所以，你传进去的东西

1187
00:52:54,780 --> 00:52:56,560
更一般地，它仅仅是输入。

1188
00:52:56,560 --> 00:52:59,860
如果你在生活中写一个函数，该函数的目的是做

1189
00:52:59,860 --> 00:53:03,290
有点不同的东西，每次你使用它，那么唯一的办法

1190
00:53:03,290 --> 00:53:07,710
要做到这一点真的会似乎是为它提供输入，所以它

1191
00:53:07,710 --> 00:53:10,180
可以做不同的事情，每次输入。

1192
00:53:10,180 --> 00:53:13,590
>> 所以，你需要指定两件事情，当一个函数需要输入。

1193
00:53:13,590 --> 00:53:17,240
你需要指定你想给，输入的名称，纯粹是为了

1194
00:53:17,240 --> 00:53:20,790
自己的方便，所以，你可以参考它的功能

1195
00:53:20,790 --> 00:53:23,610
自己写作，我在这里的第32行。

1196
00:53:23,610 --> 00:53:27,840
但是，你还需要指定它的类型，因为C是一种编程语言

1197
00:53:27,840 --> 00:53:28,840
只需要

1198
00:53:28,840 --> 00:53:31,810
如果你想要一个变量，你必须告诉计算机

1199
00:53:31,810 --> 00:53:32,790
数据类型是，

1200
00:53:32,790 --> 00:53:35,540
在很大程度上，以便它知道多少位

1201
00:53:35,540 --> 00:53:37,230
分配给该变量。

1202
00:53:37,230 --> 00:53:38,600
因为它可能是6  - 

1203
00:53:38,600 --> 00:53:39,990
对不起，它不会是6。

1204
00:53:39,990 --> 00:53:41,050
它也可以是16。

1205
00:53:41,050 --> 00:53:41,630
它可以是8位。

1206
00:53:41,630 --> 00:53:44,410
它可以是32个，甚至64。

1207
00:53:44,410 --> 00:53:45,820
但是，计算机需要知道。

1208
00:53:45,820 --> 00:53:49,110
现在，在左边的int代表着什么，与此相反呢？

1209
00:53:52,825 --> 00:53:53,780
[听不清]

1210
00:53:53,780 --> 00:53:54,570
DAVID J.马兰：那是什么？

1211
00:53:54,570 --> 00:53:55,390
[听不清]

1212
00:53:55,390 --> 00:53:57,920
DAVID J. MALAN：类型的函数，并更具体地，在

1213
00:53:57,920 --> 00:53:59,755
其输出的类型。

1214
00:53:59,755 --> 00:54:00,220
右。

1215
00:54:00,220 --> 00:54:04,220
因此，而括号中的东西代表的输入，如果有的话，

1216
00:54:04,220 --> 00:54:06,640
事情左边表示其输出端。

1217
00:54:06,640 --> 00:54:10,560
在这种情况下，增量显然是返回一个int。

1218
00:54:10,560 --> 00:54:14,590
所以int是这个函数的返回类型。

1219
00:54:14,590 --> 00:54:16,090
>> 要返回的是什么意思？

1220
00:54:16,090 --> 00:54:19,810
从字面上看，，使用关键字回报。

1221
00:54:19,810 --> 00:54:24,640
然后，如果你返回到正确的关键字是

1222
00:54:24,640 --> 00:54:28,340
整数，那么这确实是符合我们所承诺的。

1223
00:54:28,340 --> 00:54:31,110
你不能做这样的事情 - 

1224
00:54:31,110 --> 00:54:32,280
你好，世界 - 

1225
00:54:32,280 --> 00:54:33,500
因为这是一个字符串。

1226
00:54:33,500 --> 00:54:35,440
很明显，这不是一个整数。

1227
00:54:35,440 --> 00:54:40,450
因此，在短，真的是对我们的负担，程序员，具体为

1228
00:54:40,450 --> 00:54:44,730
我们回国，然后返回。

1229
00:54:44,730 --> 00:54:49,030
一点点，然后作出更明确的背景下 - 

1230
00:54:49,030 --> 00:54:50,080
他又出来了。

1231
00:54:50,080 --> 00:54:51,060
背景 - 

1232
00:54:51,060 --> 00:54:52,830
大惊喜，在短短的时刻。

1233
00:54:52,830 --> 00:54:57,720
这里的背景是，现在是您的计算机的内存中，再次，

1234
00:54:57,720 --> 00:54:59,070
技嘉，2千兆字节，什么都好。

1235
00:54:59,070 --> 00:54:59,630
也许是更重要的。

1236
00:54:59,630 --> 00:55:00,540
也许它的不足。

1237
00:55:00,540 --> 00:55:03,750
但电脑的看法有不同的部分。

1238
00:55:03,750 --> 00:55:04,860
出现下降。

1239
00:55:04,860 --> 00:55:06,020
别的东西。

1240
00:55:06,020 --> 00:55:07,540
不同的东西在中间。

1241
00:55:07,540 --> 00:55:09,300
今天，我们就开始讲这个故事。

1242
00:55:09,300 --> 00:55:11,130
>> 但我们会回来到这个随着时间的推移。

1243
00:55:11,130 --> 00:55:15,000
现在，唯一的一块内存中，我们真正关心的是文本段

1244
00:55:15,000 --> 00:55:17,160
因为这只是代表了0和1

1245
00:55:17,160 --> 00:55:18,460
，铛输出。

1246
00:55:18,460 --> 00:55:21,570
所以，当你在键盘上像a.out的运行命令，或者双击

1247
00:55:21,570 --> 00:55:25,350
在Mac OS或Windows点击一个图标，你的程序从硬盘装入

1248
00:55:25,350 --> 00:55:26,930
开车到RAM中。

1249
00:55:26,930 --> 00:55:30,850
它的屁股在您的计算机的RAM的顶部，可以这么说。

1250
00:55:30,850 --> 00:55:35,470
同时，为您的程序开始运行，并在被称为主

1251
00:55:35,470 --> 00:55:39,240
程序，你写的程序微软和苹果写道，任何其

1252
00:55:39,240 --> 00:55:42,930
局部变量结束了在那里降落的底部，您的计算机的内存中。

1253
00:55:42,930 --> 00:55:46,490
但是，如果主本身调用另一个函数，变量或

1254
00:55:46,490 --> 00:55:48,340
参数，它们最终会在它的上面。

1255
00:55:48,340 --> 00:55:50,670
如果该函数调用的东西，他们最终在它上面，

1256
00:55:50,670 --> 00:55:51,840
在它上面，在它之上。

1257
00:55:51,840 --> 00:55:56,100
只有一次是执行不托盘堆叠，所以

1258
00:55:56,100 --> 00:55:58,320
说话，开始越来越低。

1259
00:55:58,320 --> 00:56:03,370
这是什么话，概括地说，解释了为什么当你调用立方体 - 

1260
00:56:03,370 --> 00:56:04,660
还是你打的增量 - 

1261
00:56:04,660 --> 00:56:06,490
你在副本的价值传递。

1262
00:56:06,490 --> 00:56:09,840
是什么意思形象地是，你从字面上写

1263
00:56:09,840 --> 00:56:14,540
号1中的存储器的另一部分，改变一个1至2，在箱子的

1264
00:56:14,540 --> 00:56:15,360
增量 - 

1265
00:56:15,360 --> 00:56:17,450
或8，在多维数据集的情况下 - 

1266
00:56:17,450 --> 00:56:21,450
然后投掷，内存只要增加或多维数据集

1267
00:56:21,450 --> 00:56:23,410
函数返回。

1268
00:56:23,410 --> 00:56:24,267
>> 问题。

1269
00:56:24,267 --> 00:56:25,517
[听不清]

1270
00:56:28,090 --> 00:56:29,970
DAVID J.马兰：凡 - 全局变量中存储的是什么

1271
00:56:29,970 --> 00:56:32,960
目前被称为初始化的数据和未初始化的数据。

1272
00:56:32,960 --> 00:56:35,900
区别在于，如果你有一个全局变量，并赋予它

1273
00:56:35,900 --> 00:56:39,530
立即等号的值，它结束了在顶部。

1274
00:56:39,530 --> 00:56:43,390
如果你只是说没有价值的诠释x分号，它最终小幅上涨

1275
00:56:43,390 --> 00:56:46,670
简单地按照惯例，在RAM。

1276
00:56:46,670 --> 00:56:49,308
其他的问题。

1277
00:56:49,308 --> 00:56:49,750
好的。

1278
00:56:49,750 --> 00:56:53,040
>> 因此，这幅画会回来的，因为我们变得更强大，我们能做些什么

1279
00:56:53,040 --> 00:56:53,830
与计算机。

1280
00:56:53,830 --> 00:56:58,790
但现在，让我们有一个简短的介绍，特定类型的加密技术，

1281
00:56:58,790 --> 00:57:01,910
密码学不解决世界上所有的问题，但没有解决

1282
00:57:01,910 --> 00:57:02,480
其中的一些。

1283
00:57:02,480 --> 00:57:06,090
在这种情况下，在这里，我们有一些所谓的密钥加密。

1284
00:57:06,090 --> 00:57:10,430
密钥加密，顾名思义，源于它的安全性

1285
00:57:10,430 --> 00:57:11,330
从一个秘密。

1286
00:57:11,330 --> 00:57:14,720
因此，举例来说，如果你是在小学和你通过一个

1287
00:57:14,720 --> 00:57:18,040
小秘密情书的男孩或女孩，你破碎 - 如果你

1288
00:57:18,040 --> 00:57:20,820
想通过贯穿全场的，你可能不会写

1289
00:57:20,820 --> 00:57:24,120
英语中的注释，或任何你的母语，而是你

1290
00:57:24,120 --> 00:57:25,800
可以对它进行加密。

1291
00:57:25,800 --> 00:57:27,820
或者你可能只是给他们一个文本消息，这些天。

1292
00:57:27,820 --> 00:57:30,310
但你实际上可能会通过他们在教室。

1293
00:57:30,310 --> 00:57:33,820
而要做到这安全地，以这样一种方式，您的朋友和教师

1294
00:57:33,820 --> 00:57:36,820
不知道你写的东西，你可能会想出一个相当简单的

1295
00:57:36,820 --> 00:57:37,800
算法 - 

1296
00:57:37,800 --> 00:57:39,290
年轻人虽然你可能是 - 

1297
00:57:39,290 --> 00:57:40,780
只是争夺的话。

1298
00:57:40,780 --> 00:57:44,390
因此，而不是写一个，你可能会写B.而不是B，你可以写

1299
00:57:44,390 --> 00:57:46,670
C.而不是C，你可能会写D，等等。

1300
00:57:46,670 --> 00:57:50,020
或者，你能想出一个更复杂的字母翻译

1301
00:57:50,020 --> 00:57:51,300
以不同的字母。

1302
00:57:51,300 --> 00:57:55,440
但美中不足的是男孩还是女孩，你发送此说明需要

1303
00:57:55,440 --> 00:57:56,850
知道的东西。

1304
00:57:56,850 --> 00:57:59,620
这是什么，很明显吗？

1305
00:57:59,620 --> 00:58:01,400
一样，你的秘密是什么。

1306
00:58:01,400 --> 00:58:04,620
喜欢什么，是AS和BS和CS和DS之间的映射？

1307
00:58:04,620 --> 00:58:08,780
难道仅仅是增加一个，可以这么说，每一个字母去从

1308
00:58:08,780 --> 00:58:09,730
A到B，从B到C？

1309
00:58:09,730 --> 00:58:11,350
它是比这更复杂吗？

1310
00:58:11,350 --> 00:58:16,450
所以，你和你的美眉需要有这个秘密的信息。

1311
00:58:16,450 --> 00:58:18,170
但有一个catch-22在这里种。

1312
00:58:18,170 --> 00:58:20,760
如果这是第一次通过你这封情书

1313
00:58:20,760 --> 00:58:25,590
类的是男孩还是女孩，怎么会知道这个秘密，甚至是吗？

1314
00:58:25,590 --> 00:58:28,450
因此秘密密钥加密并不能解决世界上所有的问题。

1315
00:58:28,450 --> 00:58:30,490
其实有关系，我们再回过头来朝

1316
00:58:30,490 --> 00:58:31,370
学期结束。

1317
00:58:31,370 --> 00:58:35,970
>> 同样，我们有没有可能发送过 - 

1318
00:58:35,970 --> 00:58:39,453
同样，我们大多数人不知道的人的作品，例如，在

1319
00:58:39,453 --> 00:58:40,300
Amazon.com。

1320
00:58:40,300 --> 00:58:43,130
然而，我们很多人可能买的东西在Amazon.com。

1321
00:58:43,130 --> 00:58:45,670
我们一直被教导要承担这些电子商务

1322
00:58:45,670 --> 00:58:47,060
交易是安全的。

1323
00:58:47,060 --> 00:58:47,210
对吗？

1324
00:58:47,210 --> 00:58:49,310
HTTPS URL可能说。

1325
00:58:49,310 --> 00:58:51,590
有可能一个愚蠢的小挂锁图标的地方。

1326
00:58:51,590 --> 00:58:54,680
有某种形式的加密技术保护您的信用卡信息

1327
00:58:54,680 --> 00:58:56,980
你和亚马逊（Amazon.com）之间。

1328
00:58:56,980 --> 00:59:00,410
然而，如果密码学需要知道一些秘密，但我不

1329
00:59:00,410 --> 00:59:03,330
知道在亚马逊的人，而且我肯定不会安排任何形式的

1330
00:59:03,330 --> 00:59:07,350
有人在亚马逊的秘密，我的电脑或浏览器这样做呢？

1331
00:59:07,350 --> 00:59:10,100
好了，原来有其他类型的加密技术完全解决

1332
00:59:10,100 --> 00:59:10,740
那样的问题。

1333
00:59:10,740 --> 00:59:13,610
但是今天，我们将重点放在简单的一个，在那里你可以安排在

1334
00:59:13,610 --> 00:59:18,480
提前知道一些秘密，如加1或一些AS和BS之间的映射。

1335
00:59:18,480 --> 00:59:20,710
>> 和加密过程一般涉及这一点。

1336
00:59:20,710 --> 00:59:23,550
你有一些简单的文字，描绘在左。

1337
00:59:23,550 --> 00:59:26,260
您可以运行它通过某种算法或过程

1338
00:59:26,260 --> 00:59:27,670
加密。

1339
00:59:27,670 --> 00:59:31,390
也许这只是一个变成了​​B，B变成C。然后你就结束了

1340
00:59:31,390 --> 00:59:32,260
密文。

1341
00:59:32,260 --> 00:59:36,450
同时，一旦你的美眉接收到的秘密纸条，他或她有那么

1342
00:59:36,450 --> 00:59:39,950
一般扭转这种算法，从而获得进行解密

1343
00:59:39,950 --> 00:59:41,640
备份纯文本。

1344
00:59:41,640 --> 00:59:43,860
现在有物理的化身。

1345
00:59:43,860 --> 00:59:46,720
举例来说，这是一个小秘密的解码器环。

1346
00:59:46,720 --> 00:59:50,060
这是在这个意义上，在这里两个表盘的环。

1347
00:59:50,060 --> 00:59:53,630
在这件事情的外周，有字母A到Z，

1348
00:59:53,630 --> 00:59:55,110
虽然他们以随机顺序。

1349
00:59:55,110 --> 00:59:58,410
在里面，有一些数字，例如，

1350
00:59:58,410 --> 01:00:02,940
戒指，你可以种翻在外面，但不是内部以排队

1351
01:00:02,940 --> 01:00:04,110
数字与字母。

1352
01:00:04,110 --> 01:00:08,290
而在剪辑你将要看到的 - 其中有些你可能已经看到24/7

1353
01:00:08,290 --> 01:00:11,120
从一部电影叫圣诞故事在圣诞节前后。

1354
01:00:11,120 --> 01:00:16,050
你会看到那个小拉尔夫是如此渴望要弄清楚什么的小孤儿

1355
01:00:16,050 --> 01:00:19,810
安妮的秘密是他的消息了沟通，我认为，在

1356
01:00:19,810 --> 01:00:22,810
数字信息串行中形成的。

1357
01:00:22,810 --> 01:00:26,760
你有积累的小卡片，来到

1358
01:00:26,760 --> 01:00:27,480
在麦片盒。

1359
01:00:27,480 --> 01:00:28,320
你必须邮寄他们。

1360
01:00:28,320 --> 01:00:31,060
你有秘密的解码器环，所以，你终于可以图

1361
01:00:31,060 --> 01:00:34,190
字母和数字之间的映射是什么，

1362
01:00:34,190 --> 01:00:35,420
或字母和字母。

1363
01:00:35,420 --> 01:00:39,790
所以，我给你这个短片从一个圣诞节的故事，以激励的pset 2

1364
01:00:39,790 --> 01:00:42,340
我们的讨论，在某一时刻的数组。

1365
01:00:42,340 --> 01:00:43,773
所以在这里我们拉尔夫。

1366
01:00:43,773 --> 01:00:44,126
>> [视频回放]

1367
01:00:44,126 --> 01:00:47,470
无论是向所有人拉尔夫·帕克委任一个

1368
01:00:47,470 --> 01:00:50,690
的小孤儿安妮秘密圈的成员，并有权

1369
01:00:50,690 --> 01:00:53,500
荣誉和利益发生于此。

1370
01:00:53,500 --> 01:00:56,040
签名，小孤儿安妮。

1371
01:00:56,040 --> 01:00:58,730
会签，皮埃尔·安德烈！

1372
01:00:58,730 --> 01:01:00,150
在油墨中！

1373
01:01:00,150 --> 01:01:02,910
荣誉和利益，已经9岁。

1374
01:01:09,970 --> 01:01:10,730
来吧，让我们用它。

1375
01:01:10,730 --> 01:01:15,000
我并不需要所有的爵士乐关于走私和海盗。

1376
01:01:15,000 --> 01:01:17,624
 - 听着明天晚上的结论冒险的黑色

1377
01:01:17,624 --> 01:01:19,710
海盗船。

1378
01:01:19,710 --> 01:01:23,380
现在，是时候为你的成员安妮的秘密消息

1379
01:01:23,380 --> 01:01:25,670
秘密圈。

1380
01:01:25,670 --> 01:01:30,260
请记住，孩子，只有安妮的秘密圈的成员可以解码

1381
01:01:30,260 --> 01:01:31,660
安妮的秘密消息。

1382
01:01:31,660 --> 01:01:36,230
请记住，安妮得靠你了。

1383
01:01:36,230 --> 01:01:38,720
将你的脚B2。

1384
01:01:38,720 --> 01:01:41,040
这里的消息。

1385
01:01:41,040 --> 01:01:42,470
12，11  - 

1386
01:01:42,470 --> 01:01:46,000
我在我的第一个秘密的会议。

1387
01:01:46,000 --> 01:01:49,440
-14，11，18，16  - 

1388
01:01:49,440 --> 01:01:51,700
皮埃尔是在今晚很大的发言权。

1389
01:01:51,700 --> 01:01:54,890
我可以告诉大家，今晚的消息是很重要的。

1390
01:01:54,890 --> 01:01:56,750
-3，25。

1391
01:01:56,750 --> 01:01:58,590
这是一个消息，安妮自己。

1392
01:01:58,590 --> 01:01:59,840
记住，千万不要告诉任何人。

1393
01:02:04,570 --> 01:02:08,750
-90秒后，我在一个房间里唯一的一个九岁的孩子

1394
01:02:08,750 --> 01:02:12,980
可以坐在隐私和解码。

1395
01:02:12,980 --> 01:02:17,130
啊哈，B.我去到下一个。

1396
01:02:17,130 --> 01:02:20,330
E.第一个字是。

1397
01:02:20,330 --> 01:02:22,670
S.它现在更容易。

1398
01:02:22,670 --> 01:02:24,590
U.

1399
01:02:24,590 --> 01:02:26,510
哦，来吧，拉尔夫。

1400
01:02:26,510 --> 01:02:28,430
我得走了。

1401
01:02:28,430 --> 01:02:30,350
 - 我是正确的，妈妈。

1402
01:02:30,350 --> 01:02:33,720
 - 啧啧奇才。

1403
01:02:33,720 --> 01:02:38,270
-T，O.一定要。

1404
01:02:38,270 --> 01:02:40,000
要确保的是什么？

1405
01:02:40,000 --> 01:02:42,105
小孤儿安妮想说的是什么呢？

1406
01:02:42,105 --> 01:02:43,095
要确保的是什么？

1407
01:02:43,095 --> 01:02:43,590
 - 拉尔夫！

1408
01:02:43,590 --> 01:02:44,580
兰迪得走了。

1409
01:02:44,580 --> 01:02:45,570
请你出来吗？

1410
01:02:45,570 --> 01:02:46,560
好吧，马。

1411
01:02:46,560 --> 01:02:48,540
我马上就出来。

1412
01:02:48,540 --> 01:02:50,580
我越来越近了。

1413
01:02:50,580 --> 01:02:52,550
张力是可怕的。

1414
01:02:52,550 --> 01:02:53,355
它是什么？

1415
01:02:53,355 --> 01:02:56,315
这个星球的命运悬而未决。

1416
01:02:56,315 --> 01:02:56,790
 - 拉尔夫！

1417
01:02:56,790 --> 01:02:59,165
兰迪得走了。

1418
01:02:59,165 --> 01:03:02,310
 - 我就出来，哭出声来。

1419
01:03:02,310 --> 01:03:04,000
哎呀，几乎没有。

1420
01:03:04,000 --> 01:03:05,180
我的手指飞了起来。

1421
01:03:05,180 --> 01:03:07,150
我的心是钢的陷阱。

1422
01:03:07,150 --> 01:03:08,790
每一个毛孔振动。

1423
01:03:08,790 --> 01:03:10,040
这几乎是清楚的。

1424
01:03:10,040 --> 01:03:13,400
是的，是的，是的，是的。

1425
01:03:13,400 --> 01:03:18,960
要确保喝阿华田。

1426
01:03:18,960 --> 01:03:20,210
阿华田？

1427
01:03:24,010 --> 01:03:25,260
照出的商业？

1428
01:03:28,200 --> 01:03:29,640
狗娘养的。

1429
01:03:29,640 --> 01:03:33,340
[END视频播放]

1430
01:03:33,340 --> 01:03:36,040
>> DAVID J.马兰：因此，我们有加密技术。

1431
01:03:36,040 --> 01:03:39,670
因此，如何在一台计算机，我们可以去实现，或者

1432
01:03:39,670 --> 01:03:40,950
代表这样的事情吗？

1433
01:03:40,950 --> 01:03:44,430
好了，我们需要一种方式表达自己一点更灵活

1434
01:03:44,430 --> 01:03:46,420
因此，我们的变量不允许的。

1435
01:03:46,420 --> 01:03:47,370
我们已经有整数。

1436
01:03:47,370 --> 01:03:48,380
我们已经有个字符。

1437
01:03:48,380 --> 01:03:50,790
我们的花车和双打和其他几个人。

1438
01:03:50,790 --> 01:03:55,050
但是，这些都是个人的内存不真的让我们

1439
01:03:55,050 --> 01:03:58,010
表达的东西，如单词和句子和短语。

1440
01:03:58,010 --> 01:04:00,200
事实上，我们叫这样的事情串。

1441
01:04:00,200 --> 01:04:03,650
但我们所承诺的，这是真的只是一个简化的CS50

1442
01:04:03,650 --> 01:04:07,020
库，我们打算剥离回来。

1443
01:04:07,020 --> 01:04:08,970
>> 让我们开始做，在这里。

1444
01:04:08,970 --> 01:04:11,130
让我继续前进，打开一个文件 - 

1445
01:04:11,130 --> 01:04:13,770
所有这些文件都可以像往常一样在网上 - 

1446
01:04:13,770 --> 01:04:19,120
称为array.c解决的问题无关字符串，但描绘一个

1447
01:04:19,120 --> 01:04:23,040
的图片在这里，我们怎么可能使用的东西称为数组。

1448
01:04:23,040 --> 01:04:25,530
数组是一种数据类型。

1449
01:04:25,530 --> 01:04:31,320
这是一个类型的变量，各种各样的，有多个较小的数据类型

1450
01:04:31,320 --> 01:04:34,150
它里面的背靠背背靠背。

1451
01:04:34,150 --> 01:04:37,700
因此，举例来说，如果我们要编写一个小程序，让您的

1452
01:04:37,700 --> 01:04:42,110
测验平均为一疗程，有两个小测验，你可以很容易像50

1453
01:04:42,110 --> 01:04:45,170
编写这个程序 - 甚至在一些上周的材料 - 

1454
01:04:45,170 --> 01:04:47,770
通过调用getInt和一对夫妇的变量。

1455
01:04:47,770 --> 01:04:51,920
诠释quiz1，诠释quiz2，这是很简单的。

1456
01:04:51,920 --> 01:04:55,930
这也许是10，20行的代码，最大，实施程序，要求

1457
01:04:55,930 --> 01:05:01,170
两个测验的分数，然后计算它们的平均用户通过将它们添加

1458
01:05:01,170 --> 01:05:03,850
在一起，除以二，然后打印结果。

1459
01:05:03,850 --> 01:05:06,380
我们或许可以做到这一点很容易现在，

1460
01:05:06,380 --> 01:05:07,510
有些分钟数。

1461
01:05:07,510 --> 01:05:11,005
>> 但问题是，假设有50有三个测验或4。

1462
01:05:11,005 --> 01:05:13,510
假设你想使用相同的程序，有一类

1463
01:05:13,510 --> 01:05:14,850
每周测验。

1464
01:05:14,850 --> 01:05:16,610
想想一个类时，每周测验。

1465
01:05:16,610 --> 01:05:20,610
如果有像在一个学期16周，现在你有16个变量 - 

1466
01:05:20,610 --> 01:05:24,270
quiz1，诠释quiz2，诠释第quiz3，诠释quiz4。

1467
01:05:24,270 --> 01:05:27,560
只要你开始看到这种冗余，复制和粘贴

1468
01:05:27,560 --> 01:05:31,390
的代码，它应该让你希望有一个更好的办法。

1469
01:05:31,390 --> 01:05:33,930
幸运的是，因为数组。

1470
01:05:33,930 --> 01:05:34,980
因此，让我们做到这一点。

1471
01:05:34,980 --> 01:05:38,430
首先，让我介绍一个非常简单的事情，我们到目前为止还没有使用，

1472
01:05:38,430 --> 01:05:40,140
但偶尔你会看到它的代码。

1473
01:05:40,140 --> 01:05:42,360
这就是通常被称为一个常数。

1474
01:05:42,360 --> 01:05:45,790
所以在这个意义上，这个值不会改变，它是一个常数。

1475
01:05:45,790 --> 01:05:49,210
创建一个常量时，是使用全部大写的人的约定

1476
01:05:49,210 --> 01:05:51,940
字母，只是，使其真正站出来，在你的代码。

1477
01:05:51,940 --> 01:05:55,960
特殊的关键字，您使用的C＃定义。

1478
01:05:55,960 --> 01:06:00,250
所以，如果你说的，然后是一个空格，然后你想使用这个词，

1479
01:06:00,250 --> 01:06:03,260
常量的名称，然后该常数的值。

1480
01:06:03,260 --> 01:06:06,180
因此，通知，这从一个变量分配的东西是不同的。

1481
01:06:06,180 --> 01:06:07,020
有没有等号。

1482
01:06:07,020 --> 01:06:08,240
有没有分号。

1483
01:06:08,240 --> 01:06:11,410
这是通常被称为预处理器指令，但更多的

1484
01:06:11,410 --> 01:06:12,210
另一个时间。

1485
01:06:12,210 --> 01:06:18,540
>> 就目前而言，这将创建一个不变的值，称为测验的实际

1486
01:06:18,540 --> 01:06:19,940
的数值是2。

1487
01:06:19,940 --> 01:06:24,020
因此，任何地方，你看到测验，测验，测验，这是整个文件

1488
01:06:24,020 --> 01:06:25,410
只是数字2。

1489
01:06:25,410 --> 01:06:28,100
现在，如果我看主要现在，让我们来看看它是如何工作的。

1490
01:06:28,100 --> 01:06:29,500
起初，这看起来有点神秘。

1491
01:06:29,500 --> 01:06:31,340
但它是从第一个星期，所有的东西。

1492
01:06:31,340 --> 01:06:32,710
询问用户的等级。

1493
01:06:32,710 --> 01:06:33,630
如何才能做到这一点呢？

1494
01:06:33,630 --> 01:06:35,470
那么，在第22行 - 

1495
01:06:35,470 --> 01:06:37,210
这是真的的多汁的一部分 - 

1496
01:06:37,210 --> 01:06:40,960
我声明了一个浮动，但是不只是一个单一的浮动。

1497
01:06:40,960 --> 01:06:44,620
我声明，而是一个浮点值数组。

1498
01:06:44,620 --> 01:06:49,100
这个变量将被称为档次，这里暗示。

1499
01:06:49,100 --> 01:06:53,080
但唯一的一块新的语法，那么这些方括号中，其实

1500
01:06:53,080 --> 01:06:59,350
我已经说过了浮动等级，然后打开支架，然后一个数字。

1501
01:06:59,350 --> 01:07:02,460
请注意，如果这是一个常数，这是像我们这样做。

1502
01:07:02,460 --> 01:07:06,890
这意味着哎电脑，给我两个花车，让我们共同呼吁

1503
01:07:06,890 --> 01:07:08,220
他们的成绩。

1504
01:07:08,220 --> 01:07:11,920
这是更繁琐的过程，这样的对比。

1505
01:07:11,920 --> 01:07:15,850
浮法级1，浮动grade2“，等等。

1506
01:07:15,850 --> 01:07:20,010
因此，一个阵列，使我们能够实现这个想法，但要少得多乱七八糟，在

1507
01:07:20,010 --> 01:07:24,630
这样的方式，我们可以写一行代码，而不是，比方说，一个16 16

1508
01:07:24,630 --> 01:07:25,740
周的学期。

1509
01:07:25,740 --> 01:07:29,950
所以我不想硬编码，因为，如果你认为现在

1510
01:07:29,950 --> 01:07:34,160
假设明年逻辑 -  CS50更改为3，而不是测验。

1511
01:07:34,160 --> 01:07:35,510
我有2号。

1512
01:07:35,510 --> 01:07:36,600
在这里，我有2号。

1513
01:07:36,600 --> 01:07:37,580
在这里，我有2号。

1514
01:07:37,580 --> 01:07:38,560
在这里，我有2号。

1515
01:07:38,560 --> 01:07:43,180
它变得非常乏味，很容易搞砸了，不小心改变

1516
01:07:43,180 --> 01:07:47,690
一个值，错过了一些其他值2。

1517
01:07:47,690 --> 01:07:52,460
所以我要这个距离，而不是抽象的，并使用此常量，其

1518
01:07:52,460 --> 01:07:54,120
顾名思义，永远不会改变。

1519
01:07:54,120 --> 01:07:57,710
而现在，无论我们有不同的测验今年或明年，我

1520
01:07:57,710 --> 01:08:01,210
只需要改变它在一个地方，在这里顶部。

1521
01:08:01,210 --> 01:08:02,720
>> 所以这是所有不变的是。

1522
01:08:02,720 --> 01:08:08,680
同时，新概念的特点是一个数组。

1523
01:08:08,680 --> 01:08:14,660
因此，在方括号给我这么多的花车，让我集体

1524
01:08:14,660 --> 01:08:16,630
他们成绩在这里。

1525
01:08:16,630 --> 01:08:17,990
所以，现在让我们来看看我会做什么。

1526
01:08:17,990 --> 01:08:20,359
在这里，在第24行是一个for循环的开始。

1527
01:08:20,359 --> 01:08:22,260
这实在是没有任何幻想。

1528
01:08:22,260 --> 01:08:25,060
这只是使用测验，而不是硬编码的数字。

1529
01:08:25,060 --> 01:08:27,790
但也有是没有从上周智力有不同的。

1530
01:08:27,790 --> 01:08:29,040
这仅仅是printf的。

1531
01:08:29,040 --> 01:08:35,490
因此我们知道printf（“小考数的％d％d”的），因为我只是想打印出来给我测验

1532
01:08:35,490 --> 01:08:38,050
数之一，两个，然后两个两个。

1533
01:08:38,050 --> 01:08:39,850
因此，这纯粹是一种审美的东西。

1534
01:08:39,850 --> 01:08:42,500
但是，现在最有趣的部分是在第27行。

1535
01:08:42,500 --> 01:08:48,310
为了填补的两个占位符的浮点

1536
01:08:48,310 --> 01:08:51,029
值，你再使用方括号。

1537
01:08:51,029 --> 01:08:55,620
在这种情况下，我使用的是我，因为for循环已开始与我等于

1538
01:08:55,620 --> 01:08:57,560
什么样的价值，显然是吗？

1539
01:08:57,560 --> 01:08:58,279
0。

1540
01:08:58,279 --> 01:09:01,350
>> 因此，在这个循环的第一次迭代，这是因为虽然我

1541
01:09:01,350 --> 01:09:02,689
写在代码中。

1542
01:09:02,689 --> 01:09:05,580
但在这个循环中的第二次迭代，这是因为虽然我

1543
01:09:05,580 --> 01:09:07,750
写在我的代码。

1544
01:09:07,750 --> 01:09:10,750
但事实上，我使用一个变量是完美的，因为，正如其名

1545
01:09:10,750 --> 01:09:14,300
表明，它改变它的值在每次迭代。

1546
01:09:14,300 --> 01:09:17,370
所以我填充这个数组一个地方的时间。

1547
01:09:17,370 --> 01:09:18,910
阵列看看这是什么样的呢？

1548
01:09:18,910 --> 01:09:21,430
好了，我之所以得出这个超级简单的屏幕上的矩形

1549
01:09:21,430 --> 01:09:23,350
之前是因为这个原因。

1550
01:09:23,350 --> 01:09:27,279
数组是另一块内存的内存块，

1551
01:09:27,279 --> 01:09:30,109
其次由另一个的内存块，等等。

1552
01:09:30,109 --> 01:09:35,260
所以，如果我的数组大小为2，在这种情况下，在这里，所有我会做的

1553
01:09:35,260 --> 01:09:37,590
打字在我测验成绩，喜欢上了这里。

1554
01:09:37,590 --> 01:09:39,430
我就这一个。

1555
01:09:39,430 --> 01:09:42,020
然后，我得到了99就这一个。

1556
01:09:42,020 --> 01:09:46,040
该内存可能甚至没有使用，因为我只问

1557
01:09:46,040 --> 01:09:48,689
电脑的数组大小为2。

1558
01:09:48,689 --> 01:09:50,180
这些广场仍然存在。

1559
01:09:50,180 --> 01:09:50,340
对吗？

1560
01:09:50,340 --> 01:09:52,500
你还有2 GB的RAM，即使你只

1561
01:09:52,500 --> 01:09:53,979
两个浮点的要求。

1562
01:09:53,979 --> 01:09:58,710
因此，阵列背后的想法是，计算机只需要一个内存块的

1563
01:09:58,710 --> 01:10:03,230
然后分给更小的碎片背靠背背靠背。

1564
01:10:03,230 --> 01:10:04,740
因此，这是所有的数组。

1565
01:10:04,740 --> 01:10:09,080
这是一个连续的内存块，这里面你可以把东西。

1566
01:10:09,080 --> 01:10:12,400
>> 现在发生这种情况，然后做一些无聊的算术。

1567
01:10:12,400 --> 01:10:16,170
如果我向下滚动在这里，这是我然后遍历数组中。

1568
01:10:16,170 --> 01:10:19,410
我拿出所有的数组中的值的总和。

1569
01:10:19,410 --> 01:10:22,390
然后，我在这里使用ROUND函数实际做的

1570
01:10:22,390 --> 01:10:23,940
总结除以测验。

1571
01:10:23,940 --> 01:10:27,450
但是，让我挥挥手，作为足够的算术现在的排序。

1572
01:10:27,450 --> 01:10:30,010
但是，所有为我做的最终计算平均值。

1573
01:10:30,010 --> 01:10:33,640
所以第一次测验加第二个测验，再除以2，然后打印

1574
01:10:33,640 --> 01:10:34,700
它作为一个int。

1575
01:10:34,700 --> 01:10:39,030
>> 但现在，让我们叫字符串转换到一个不同的例子，

1576
01:10:39,030 --> 01:10:42,370
它描绘了一个类似的画面，但使用​​字符串。

1577
01:10:42,370 --> 01:10:45,550
让我继续前进，简化这只是一个瞬间。

1578
01:10:45,550 --> 01:10:48,340
现在原谅缩进。

1579
01:10:48,340 --> 01:10:52,280
请注意，在这个例子中的第19行，我收到了来自用户的字符串。

1580
01:10:52,280 --> 01:10:55,780
但是请注意，我在22日线下做。

1581
01:10:55,780 --> 01:11:00,260
实际上，我遍历从我 - 这是一个新的伎俩 - 

1582
01:11:00,260 --> 01:11:02,730
strlen的字符串的长度。

1583
01:11:02,730 --> 01:11:07,010
这是一个与C的功能，如果你传递一个字符串，它告诉

1584
01:11:07,010 --> 01:11:08,950
你有多少个字符在该字符串中。

1585
01:11:08,950 --> 01:11:09,440
这就是全部。

1586
01:11:09,440 --> 01:11:12,520
事实上，它是strlen的字符串的长度，而不是仅仅是因为它的

1587
01:11:12,520 --> 01:11:13,040
更加简洁。

1588
01:11:13,040 --> 01:11:17,100
30年前，人们喜欢写东西尽量简洁。

1589
01:11:17,100 --> 01:11:19,080
因此，我们已经把该公约。

1590
01:11:19,080 --> 01:11:21,730
我+ +只是意味着我在每次迭代中增加。

1591
01:11:21,730 --> 01:11:24,310
而现在注意到这一点，这是非常有趣的。

1592
01:11:24,310 --> 01:11:28,730
因此，在第24行，我说电脑，给我一个字符，8

1593
01:11:28,730 --> 01:11:30,770
位，并称之为C。

1594
01:11:30,770 --> 01:11:35,370
不过这到底是上右手边说？

1595
01:11:35,370 --> 01:11:38,150
在英语中，什么代表什么呢？

1596
01:11:38,150 --> 01:11:40,070
[听不清]

1597
01:11:40,070 --> 01:11:40,490
DAVID J.马兰：没错。

1598
01:11:40,490 --> 01:11:42,390
给我的第一个字符数组中的。

1599
01:11:42,390 --> 01:11:45,400
或更一般地，给我的阵列中的第i个字符。

1600
01:11:45,400 --> 01:11:48,230
意识到这是重要的，现在，计算机科学家，我们实际上

1601
01:11:48,230 --> 01:11:49,330
从0开始计数。

1602
01:11:49,330 --> 01:11:51,290
你不拥有自由裁量权，现在开始这样做。

1603
01:11:51,290 --> 01:11:54,580
现在，你必须按照电脑的期望和行为

1604
01:11:54,580 --> 01:11:58,010
从0开始计算，因为[0]将是第一

1605
01:11:58,010 --> 01:11:59,670
字符串中的字符。

1606
01:11:59,670 --> 01:12:01,320
[1]将是第二个。

1607
01:12:01,320 --> 01:12:03,610
[2]将是第三个，等等。

1608
01:12:03,610 --> 01:12:08,840
所以，如果我编译这个程序 - 这是，再次字符串。

1609
01:12:08,840 --> 01:12:11,040
>> 所以字符串。

1610
01:12:11,040 --> 01:12:16,730
现在，我在我的终端窗口中执行字符串。

1611
01:12:16,730 --> 01:12:19,180
它在等待输入，所以我要输入，就说，大卫。

1612
01:12:19,180 --> 01:12:20,080
输入。

1613
01:12:20,080 --> 01:12:23,350
而现在它打印DAVID在不同线路上，因为

1614
01:12:23,350 --> 01:12:24,430
请注意我在做什么。

1615
01:12:24,430 --> 01:12:27,510
我一次打印一个字符。

1616
01:12:27,510 --> 01:12:29,100
现在，我们将进入今天。

1617
01:12:29,100 --> 01:12:31,610
但我删除了刚才在这里检查。

1618
01:12:31,610 --> 01:12:36,310
事实证明，如果用户出现异常，对抗性的，或只是

1619
01:12:36,310 --> 01:12:41,780
混淆，实际上，你可以不给一些长度字符串。

1620
01:12:41,780 --> 01:12:43,640
如果你按错键盘上的键，你可以给

1621
01:12:43,640 --> 01:12:44,390
没有在所有的字符串。

1622
01:12:44,390 --> 01:12:47,790
或者，如果你是恶意的，你可以尝试将其粘贴在一千兆字节的价值的

1623
01:12:47,790 --> 01:12:49,380
的文章，以填补这个字符串。

1624
01:12:49,380 --> 01:12:52,060
如果计算机运行内存，事实证明，我们将

1625
01:12:52,060 --> 01:12:54,310
这个特殊的值称为空。

1626
01:12:54,310 --> 01:12:57,550
因此，就目前而言，只是知道有这个特殊的值称为空

1627
01:12:57,550 --> 01:13:01,000
让我们来检查时，我们的记忆，在其他的事情。

1628
01:13:01,000 --> 01:13:07,330
>> 但是，如果我现在打开字符串，请注意区别就在这里。

1629
01:13:07,330 --> 01:13:09,760
看到一个与字​​符串的区别就在这里。

1630
01:13:09,760 --> 01:13:13,260
对于字符串，这个for循环是一个有点不同。

1631
01:13:13,260 --> 01:13:16,350
让我删除空值，这样我们就可以谈论其他时间的。

1632
01:13:16,350 --> 01:13:18,460
但是，什么是不同的for循环？

1633
01:13:21,580 --> 01:13:23,160
我可以回到前面的例子。

1634
01:13:23,160 --> 01:13:24,800
所以这是第二版。

1635
01:13:24,800 --> 01:13:27,020
这是一个版本。

1636
01:13:27,020 --> 01:13:31,935
一，二，一两个。

1637
01:13:35,030 --> 01:13:38,240
因此，strlen的电话是在哪里呢？

1638
01:13:38,240 --> 01:13:40,420
这是在for循环的第一部分。

1639
01:13:40,420 --> 01:13:43,060
任何想法，为什么我这样做？

1640
01:13:43,060 --> 01:13:43,690
是啊。

1641
01:13:43,690 --> 01:13:46,010
[听不清]

1642
01:13:46,010 --> 01:13:47,630
DAVID J.马兰：所以我们不会每一次调用该函数。

1643
01:13:47,630 --> 01:13:48,040
没错。

1644
01:13:48,040 --> 01:13:50,350
回想一下，他们是超级简单的for循环，一旦你

1645
01:13:50,350 --> 01:13:52,180
明白，这是初始化，

1646
01:13:52,180 --> 01:13:53,330
条件，和更新。

1647
01:13:53,330 --> 01:13:55,430
的问题是，对每个条件发生

1648
01:13:55,430 --> 01:13:56,600
循环的迭代。

1649
01:13:56,600 --> 01:13:59,930
因此，在这个例子中，什么是坏的事实

1650
01:13:59,930 --> 01:14:03,500
这是我的条件吗？

1651
01:14:03,500 --> 01:14:05,920
你调用strlen再，再而三。

1652
01:14:05,920 --> 01:14:08,990
但是，一旦我输入的国宝，该字符串的长度是5个。

1653
01:14:08,990 --> 01:14:11,560
它不会改变，因为在每次迭代循环

1654
01:14:11,560 --> 01:14:15,560
字符串仍然是D-A-V-I-D。所以这是一个暗示了这是怎么回事成为

1655
01:14:15,560 --> 01:14:19,650
越来越重要思想的设计决策， - 只是不

1656
01:14:19,650 --> 01:14:21,640
使计算机做不必要的工作。

1657
01:14:21,640 --> 01:14:25,630
>> 现在，正如pset的，PSET 2标准版先睹为快

1658
01:14:25,630 --> 01:14:28,850
要挑战你真正落实一定数量的密码，一些

1659
01:14:28,850 --> 01:14:32,650
数的加密算法，这样就可以加密和解密

1660
01:14:32,650 --> 01:14:35,530
秘密消息，就像一个拉尔夫解码。

1661
01:14:35,530 --> 01:14:38,720
在黑客版的pset 2，我们要去远一点。

1662
01:14:38,720 --> 01:14:42,010
我们将交给您的文件，其中包含一个实际的计算机系统

1663
01:14:42,010 --> 01:14:45,690
一大堆的用户名和加密的密码，和面临的挑战

1664
01:14:45,690 --> 01:14:49,110
为黑客版将是破解这些密码和数字

1665
01:14:49,110 --> 01:14:53,060
出了什么加密或什么秘密被用于实际

1666
01:14:53,060 --> 01:14:55,080
产生这些密码。

1667
01:14:55,080 --> 01:14:58,360
我们要做到这一点，使用一个新的功能，在这里我给的C

1668
01:14:58,360 --> 01:15:02,200
你只是一个演示，被称为命令行参数。

1669
01:15:02,200 --> 01:15:05,930
>> 因此，原来，你们有些人可能已经看到在部分或教科书中，

1670
01:15:05,930 --> 01:15:09,850
主并不总是括号中是无效的。

1671
01:15:09,850 --> 01:15:14,060
事实证明，主也可以这样写，有两个参数，

1672
01:15:14,060 --> 01:15:19,690
argc和argv，argc是的话，你输入后数

1673
01:15:19,690 --> 01:15:21,940
在命令行程序的名称。

1674
01:15:21,940 --> 01:15:24,550
而argv是实际的话。

1675
01:15:24,550 --> 01:15:29,470
的方括号，显然，argv是一个数组。

1676
01:15:29,470 --> 01:15:33,720
这将是一个字符串后的字符串后，内存中的字符串。

1677
01:15:33,720 --> 01:15:36,170
所以，我们要能够做到的，开始的pset 2，

1678
01:15:36,170 --> 01:15:37,310
这样的事情。

1679
01:15:37,310 --> 01:15:42,450
如果我argv1，这是一个例子，我们会回来（星期一）运行

1680
01:15:42,450 --> 01:15:45,180
，请注意，它似乎并没有做任何事情。

1681
01:15:45,180 --> 01:15:47,050
它只是打印出自己的名字。

1682
01:15:47,050 --> 01:15:53,220
但是，如果我说再见类，请注意，这个方案显然迭代

1683
01:15:53,220 --> 01:15:57,030
在每一个的话，在提示符下输入。

1684
01:15:57,030 --> 01:16:02,050
和手段，我们将获得用户的话，

1685
01:16:02,050 --> 01:16:06,780
在提示符下输入是通过改变为主，本周末开始，从int

1686
01:16:06,780 --> 01:16:10,710
主要（无效），INT主（ARGC ARGV）。

1687
01:16:10,710 --> 01:16:13,700
因此，将要出生的命令行参数。

1688
01:16:13,700 --> 01:16:17,210
而一旦你得到真正的成熟，你就可以写

1689
01:16:17,210 --> 01:16:21,370
很迷幻的程序，如这一个在这里，这超出

1690
01:16:21,370 --> 01:16:25,520
我们已经做了一些功能迄今为止，所有功能相当强大。

1691
01:16:25,520 --> 01:16:27,330
>> 因此，我们将离开这个在屏幕上。

1692
01:16:27,330 --> 01:16:29,160
我们星期一见。