1
00:00:00,000 --> 00:00:02,270
[Powered by Google Translate] [第2周，续]

2
00:00:02,270 --> 00:00:04,220
戴维·J·马兰，哈佛大学]

3
00:00:04,220 --> 00:00:06,880
[这是CS50。 -  CS50.TV]

4
00:00:06,880 --> 00:00:10,990
好的。这是CS50，这是第2周的结束。

5
00:00:10,990 --> 00:00:14,410
如果你是饿了明天的这个时候左右，

6
00:00:14,410 --> 00:00:18,620
知道我们要召开会议，明天一小群，周四，下午1:15。

7
00:00:18,620 --> 00:00:21,360
这个URL，在这里，如果你想回覆。

8
00:00:21,360 --> 00:00:26,740
空间是有限的，所以请原谅的时候，你填这张表的形式填补了。

9
00:00:26,740 --> 00:00:29,300
另一个URL，虽然，您可能会感兴趣的就是这个。

10
00:00:29,300 --> 00:00:32,369
在短短的一个月的时间，当然是要提供

11
00:00:32,369 --> 00:00:36,890
更广泛的通过EDX，通过在互联网上的人将能跟着，

12
00:00:36,890 --> 00:00:39,380
从事的过程相当积极，其实。

13
00:00:39,380 --> 00:00:42,270
他们将使用CS50电器和CS50讨论

14
00:00:42,270 --> 00:00:45,490
而且，我们已经一直在使用这个学期的各种软件工具。

15
00:00:45,490 --> 00:00:48,710
而其中一项措施，我们希望作为一个实验，今年

16
00:00:48,710 --> 00:00:51,930
是我们可以看到多少内容翻译

17
00:00:51,930 --> 00:00:53,960
成其他语言文字。

18
00:00:53,960 --> 00:00:57,500
所以，如果你有兴趣参与该项目的

19
00:00:57,500 --> 00:01:02,270
据此，我们将提供英文成绩单和字幕的课程的讲座

20
00:01:02,270 --> 00:01:05,450
和短裤研讨会和节之类的，

21
00:01:05,450 --> 00:01:08,200
如果你会讲一口流利的或写流利一些其他语言，

22
00:01:08,200 --> 00:01:12,290
我们很想吸引你，让你在这个项目中的一个或多个视频，

23
00:01:12,290 --> 00:01:15,200
将其转化为一个语言，你知道得很好。

24
00:01:15,200 --> 00:01:18,700
>> 为了让你的界面感，还有这个基于Web的用户界面

25
00:01:18,700 --> 00:01:22,090
我们将使用，将创建基本上是这样的一个UI。

26
00:01:22,090 --> 00:01:24,290
这是我教一些万圣节前，

27
00:01:24,290 --> 00:01:27,390
和右手侧有黑色旁边的这些时间戳记，

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

29
00:01:31,210 --> 00:01:34,850
然后在下面它，你就能够翻译成其他一些语言

30
00:01:34,850 --> 00:01:38,690
之间的映射是什么，在这种情况下，英语，并说，西班牙语。

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

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

33
00:01:43,370 --> 00:01:47,490
所以，如果你想参加这个实验，并有看到和阅读你的话，

34
00:01:47,490 --> 00:01:51,850
有可能有成千上万的人，请不要随意参加。

35
00:01:51,850 --> 00:01:54,350
一个字的小猫从周一。

36
00:01:54,350 --> 00:02:00,350
过于可怕的消息发送，免得我们认识到，作为办公时间建议

37
00:02:00,350 --> 00:02:03,300
和部分建议，在设计的过程是非常

38
00:02:03,300 --> 00:02:07,360
让学生协作和谈话工作，通过问题集

39
00:02:07,360 --> 00:02:11,260
和问题，真正的行仅仅归结为，

40
00:02:11,260 --> 00:02:16,010
再次，最终提交你的工作应该是你自己。

41
00:02:16,010 --> 00:02:18,860
因此，坦白地说，这是完全正常的办公时间，

42
00:02:18,860 --> 00:02:22,240
它完全可以预期的，甚至，你旁边的一些朋友聊天。

43
00:02:22,240 --> 00:02:24,370
>> 如果他或她挣扎着一些话题和你一样，

44
00:02:24,370 --> 00:02:27,940
“哦，好吧，让我给你一个瞥见的，我写了一些代码行，”这是罚款，

45
00:02:27,940 --> 00:02:31,250
出现这种情况，这是非常有利的，我认为，学习的过程。

46
00:02:31,250 --> 00:02:36,750
是在哪里得到的行交叉时，头是有点歪了太多秒

47
00:02:36,750 --> 00:02:41,160
或真正分钟，刚刚无障碍机会给你的朋友，

48
00:02:41,160 --> 00:02:44,160
当然，当事情会通过电子邮件和Dropbox和交换，

49
00:02:44,160 --> 00:02:45,640
也有就行了。

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

51
00:02:48,620 --> 00:02:52,810
有关pset和，只是和同学们认识到，你最终提交

52
00:02:52,810 --> 00:02:57,340
真的是你的创造，而不是别人的产品。

53
00:02:57,340 --> 00:03:00,490
因此，一个特定于域的为pset2问题，

54
00:03:00,490 --> 00:03:04,740
迟到明天晚上出来，是潜入世界的加密，

55
00:03:04,740 --> 00:03:08,970
这是艺术的加密和扰码信息，

56
00:03:08,970 --> 00:03:12,600
这最终涉及到世界的安全。

57
00:03:12,600 --> 00:03:16,560
现在对于大多数人来说，安全性是相当平凡的机制的形式。

58
00:03:16,560 --> 00:03:19,050
我们所有的用户名和密码，

59
00:03:19,050 --> 00:03:23,450
我们所有的人都非常糟糕的用户名​​和密码，最有可能的。

60
00:03:23,450 --> 00:03:28,240
>> 如果您在多个网站上的密码是相同的，这可能不是最好的主意，

61
00:03:28,240 --> 00:03:30,070
我们将讨论向学期的结束。

62
00:03:30,070 --> 00:03:34,720
如果您的密码是写在一个便签 - 可不是闹着玩的 - 在您的显示器，

63
00:03:34,720 --> 00:03:38,350
那也是不一定是最好的设计，而是一个相当普遍的现象。

64
00:03:38,350 --> 00:03:42,470
而且，如果你不使用加密技术来加密您的密码，

65
00:03:42,470 --> 00:03:44,210
他们特别容易受到伤害。

66
00:03:44,210 --> 00:03:47,270
所以，如果你认为你是超级聪明，有一个隐藏的Word文档

67
00:03:47,270 --> 00:03:49,910
在您的硬盘驱动器上的某个地方，有你所有的密码

68
00:03:49,910 --> 00:03:53,670
但它在一个文件夹，没有人会看的，也不是一个非常安全的机制。

69
00:03:53,670 --> 00:03:56,990
还等什么pset2将介绍的是密码学这门艺术

70
00:03:56,990 --> 00:04:02,010
和扰码信息，如密码，这样的事情是更安全的。

71
00:04:02,010 --> 00:04:05,790
这里的背景是不安全的数据

72
00:04:05,790 --> 00:04:07,930
来加密和争夺它的机会。

73
00:04:07,930 --> 00:04:11,470
等，例如，是一个加密的消息的一个例子。

74
00:04:11,470 --> 00:04:14,700
这实际上说的是英语，但很明显，这是不完全明显。

75
00:04:14,700 --> 00:04:18,279
我们将兜了一圈，今天捉弄除了这个秘密的讯息是什么。

76
00:04:18,279 --> 00:04:23,490
但在现实世界中的电脑，事情并不显得像他们可能是英语短语。

77
00:04:23,490 --> 00:04:28,430
例如，这是一个标准的Linux或Mac或UNIX计算机上你可能会发现

78
00:04:28,430 --> 00:04:32,070
在一个文件中，曾经有段时间被称为密码文件。

79
00:04:32,070 --> 00:04:34,200
>> 如今，它已经搬到别的地方。

80
00:04:34,200 --> 00:04:39,210
但是，如果你的系统上，在正确的地方，你会看到不仅是你的用户名

81
00:04:39,210 --> 00:04:43,400
或系统上的其他人，但你会看到他们的密码的加密版本。

82
00:04:43,400 --> 00:04:47,980
事实上，这个词地下室有以下的东西是加密的，

83
00:04:47,980 --> 00:04:52,680
这一系列看似随机字母和字符和数字等等

84
00:04:52,680 --> 00:04:56,480
可解密仅由一般知道的一些秘密 - 

85
00:04:56,480 --> 00:04:58,840
一个秘密的话，一个秘密数字 - 

86
00:04:58,840 --> 00:05:03,160
事实上，艺术的加密技术最终都归结到信任的某种

87
00:05:03,160 --> 00:05:05,650
，别人不知道的东西。

88
00:05:05,650 --> 00:05:10,090
因此，我们将探讨这方面更详细一点今天在pset中来。

89
00:05:10,090 --> 00:05:12,200
而现在通过/失败的一个词。

90
00:05:12,200 --> 00:05:15,360
特别是作为一些你跳入pset1移动设备的，

91
00:05:15,360 --> 00:05:19,080
和为自己是一个非常新的世界，认识到挫折和困惑

92
00:05:19,080 --> 00:05:21,700
只是技术上的困难是相当可以预期的，

93
00:05:21,700 --> 00:05:24,180
特别是与第一pset中，那里有这么多新的，

94
00:05:24,180 --> 00:05:27,730
刚刚熟悉的ls和cd，所有这些神秘的命令

95
00:05:27,730 --> 00:05:33,050
一个新的环境，这就是从实际材料和编程本身分开。

96
00:05:33,050 --> 00:05:36,940
所以实现也有一定的支撑结构存在的办公时间。

97
00:05:36,940 --> 00:05:38,880
>> 节本星期日开始。

98
00:05:38,880 --> 00:05:42,960
但最重要的是，如果你觉得这是不是只是你的世界，

99
00:05:42,960 --> 00:05:44,710
认识到，它确实只是需要时间。

100
00:05:44,710 --> 00:05:48,600
，它不给我这个机会年前我一类的合格/不合格，

101
00:05:48,600 --> 00:05:50,990
说实话，我永远不会甚至踏上在教室里。

102
00:05:50,990 --> 00:05:53,690
你可以改变这件事，直到说，第五次周一的课程，

103
00:05:53,690 --> 00:05:58,280
所以，如果你现在上的优势，完全实现，而不是头部到一些其他水域，

104
00:05:58,280 --> 00:06:01,260
我肯定会考虑转变为通过/失败。

105
00:06:01,260 --> 00:06:04,570
同样，有没有真的这种文化在哈佛考虑的事情通过/失败

106
00:06:04,570 --> 00:06:08,670
因为每个人都希望实现或超额完成，

107
00:06:08,670 --> 00:06:11,130
但坦率地说，这是一个美妙的方式尝试了

108
00:06:11,130 --> 00:06:16,720
可能不很熟悉的，到头来你会做什么，在大多数情况下，相当精细，

109
00:06:16,720 --> 00:06:18,210
也许是很多给您惊喜。

110
00:06:18,210 --> 00:06:20,980
更具体的，我觉得通过/失败一般不，

111
00:06:20,980 --> 00:06:22,940
尤其是当你可能会经历与pset0，

112
00:06:22,940 --> 00:06:26,560
10小时，15小时，25小时，如果你把一些pset的

113
00:06:26,560 --> 00:06:29,920
你撞你的头靠在墙上，它的超级深夜

114
00:06:29,920 --> 00:06:33,950
但你在pset 90％的方式，你就不能弄清楚一件事，

115
00:06:33,950 --> 00:06:36,520
通过/失败真的需要这样的一类边缘，

116
00:06:36,520 --> 00:06:39,100
在那里你可以排序，高兴地说：“好吧，我知道这是不完美的，

117
00:06:39,100 --> 00:06:42,350
但我的工作我的屁股上，就结束了，我很高兴。“

118
00:06:42,350 --> 00:06:44,850
，这将满足期望通过/失败。

119
00:06:44,850 --> 00:06:47,540
所以千万记住这一点。好的。

120
00:06:47,540 --> 00:06:50,520
>> 因此，那些你一直在努力使用哈佛大学的Wi-Fi，

121
00:06:50,520 --> 00:06:54,780
我知道，有一个CS50 SSID，通过Wi-Fi连接，漂浮

122
00:06:54,780 --> 00:06:56,490
你可能有更好的运气。

123
00:06:56,490 --> 00:07:00,130
这是一个有点讽刺的密码，如果你想尝试连接到该

124
00:07:00,130 --> 00:07:08,350
为更好的速度 - 让我们知道，如果没有更好的 - 是12345，一直到8

125
00:07:08,350 --> 00:07:10,910
因为8比5更安全。

126
00:07:10,910 --> 00:07:16,910
因此，如果你需要的Wi-Fi密码，连接到CS50无线在这里，12345678，

127
00:07:16,910 --> 00:07:20,380
发表于CS50讨论，如果你仍然有间歇性的连接问题，

128
00:07:20,380 --> 00:07:25,420
我们将让权力知道这个空间。好的。

129
00:07:25,420 --> 00:07:32,230
所以简单的玩笑话，尤其是对于那些你们谁是所有苹果的的风扇男孩或女孩的。

130
00:07:32,230 --> 00:07:37,460
我从几年前挖了这个文件，iUnlock.c，

131
00:07:37,460 --> 00:07:39,930
只是种更具体，更复杂

132
00:07:39,930 --> 00:07:42,560
一些更基本的C程序，我们一直都在写。

133
00:07:42,560 --> 00:07:46,910
于是，我打开了这个文件，iUnlock.c。这是今天的讲座页。

134
00:07:46,910 --> 00:07:49,810
在左侧，您会看到一个长长的清单功能。

135
00:07:49,810 --> 00:07:53,230
因此，研究员，这是谁写的写了一个功能很多，以上只是主。

136
00:07:53,230 --> 00:07:57,340
他用一大堆的库，在这里，如果我们开始滚动，

137
00:07:57,340 --> 00:08:04,890
这实际上是的，是的，我相信，原来的iPhone破解。

138
00:08:04,890 --> 00:08:09,830
>> 当你想原来的iPhone越狱，这意味着untether从AT＆T

139
00:08:09,830 --> 00:08:13,710
实际安装特殊的软件就可以了，做的事情，苹果不希望人们做，

140
00:08:13,710 --> 00:08:18,480
有人花时间弄清楚他们是如何利用软件漏洞，

141
00:08:18,480 --> 00:08:22,690
错误，错误，苹果软件，并由此诞生iUnlock.c  - 

142
00:08:22,690 --> 00:08:26,760
如果你编译它，您的计算机上安装了一个iPhone上

143
00:08:26,760 --> 00:08:29,430
说，通过USB电缆连接到您的计算机，

144
00:08:29,430 --> 00:08:32,450
这将给你的行政或root权限在您的iPhone

145
00:08:32,450 --> 00:08:34,620
让你做几乎任何你想要的。

146
00:08:34,620 --> 00:08:36,400
所以这个迷人的猫捉老鼠的游戏

147
00:08:36,400 --> 00:08:39,340
苹果与世界其他地区，特别是他们，很多企业一样，

148
00:08:39,340 --> 00:08:43,350
试图锁定自己的东西，所以，你只能用它做什么，他们打算。

149
00:08:43,350 --> 00:08:47,360
但是，由于这样的低级别的细节和理解的人 - 

150
00:08:47,360 --> 00:08:50,830
在这种情况下C语言编程 - 和很多熟悉的结构

151
00:08:50,830 --> 00:08:55,280
我们已经开始玩，你能够真正利用硬件

152
00:08:55,280 --> 00:08:59,250
在您认为合适的方式，而不一定是一些企业实体。

153
00:08:59,250 --> 00:09:01,600
因此，举例来说，我不知道这是做，

154
00:09:01,600 --> 00:09:03,580
但的GetVersion听起来很简单，

155
00:09:03,580 --> 00:09:05,710
看起来这是一个函数，这个人写的。

156
00:09:05,710 --> 00:09:09,250
这需要某种整数作为参数，不返回任何东西，

157
00:09:09,250 --> 00:09:13,710
但似乎循环用一个for循环和if条件，如果条件中断，

158
00:09:13,710 --> 00:09:16,770
并以某种方式涉及到的版本号，如果我们向下滚动，

159
00:09:16,770 --> 00:09:19,650
尽管很多这些关键字将是新的。

160
00:09:19,650 --> 00:09:22,590
有一个整体的功能在这里，我们从来没有见过，可能不会看到很多

161
00:09:22,590 --> 00:09:24,350
在本学期课程。

162
00:09:24,350 --> 00:09:29,160
>> 在一天结束的时候，它遵循相同的规则和逻辑，我们一直在玩迄今。

163
00:09:29,160 --> 00:09:34,340
因此，这是破解你的iPhone 3S或4S或很快5S这些天太旧，

164
00:09:34,340 --> 00:09:38,830
但要知道，这一切都非常来源于这个世界上，我们已经潜入。

165
00:09:38,830 --> 00:09:42,280
让我们来看看一个更简单一点的例子：

166
00:09:42,280 --> 00:09:46,260
这一块，只是热身的一些语法，还有一些其他的数据类型

167
00:09:46,260 --> 00:09:48,910
我们已经讨论过，但还没有真正看到在C

168
00:09:48,910 --> 00:09:53,670
这是一个的文件名为positive1.c，每在上面的评论，

169
00:09:53,670 --> 00:09:56,070
这只是要求用户提供一个正数。

170
00:09:56,070 --> 00:09:59,910
所以这是一个例子，一个do-whil​​e循环，这是很好的用户互动节目

171
00:09:59,910 --> 00:10:02,070
当你需要告诉用户做一些事情，

172
00:10:02,070 --> 00:10:05,530
如果他们不配合你骂他们，或拒绝他们的意见。

173
00:10:05,530 --> 00:10:10,480
举个例子：我会做19至24行

174
00:10:10,480 --> 00:10:14,620
只要用户还没有给我一个正数。

175
00:10:14,620 --> 00:10:21,340
这个细节在这里的第18行，为什么我声明Ň高于整个循环结构

176
00:10:21,340 --> 00:10:26,870
而不是到第22行旁边，我真正关心得到n？是啊。

177
00:10:26,870 --> 00:10:29,330
[学生]范围。 “是啊，所以这个问题的范围。

178
00:10:29,330 --> 00:10:31,770
通俗地说，是什么范围是指什么？

179
00:10:34,880 --> 00:10:41,560
是啊。 >> [听不见的学生回应] >>你说大声一点好吗？

180
00:10:41,560 --> 00:10:45,440
[学生]在这里您可以访问该变量。 >>完美。

181
00:10:45,440 --> 00:10:47,610
在这里你可以访问一个特定的变量。

182
00:10:47,610 --> 00:10:50,990
而且一般的经验法则迄今为止一直认为某些变量的范围

183
00:10:50,990 --> 00:10:56,140
最近你见过的花括号定义。

184
00:10:56,140 --> 00:11:03,070
>> 因此，在这种情况下，如果我犯了个错误的声明n在第22行，该行会的工作。

185
00:11:03,070 --> 00:11:10,840
我会得到一个int，我会把它到第22行中的变量n，

186
00:11:10,840 --> 00:11:17,060
但哪一行代码，现在已经不知道我在说什么吗？ >> [学生] 25。

187
00:11:17,060 --> 00:11:23,840
[马兰] 25和24，因为在这种情况下，它不属于花括号。

188
00:11:23,840 --> 00:11:28,550
因此，只要一点点的滋扰，但很容易解决，通过简单地声明的变量

189
00:11:28,550 --> 00:11:30,700
外本身的功能。

190
00:11:30,700 --> 00:11:32,760
稍后我们将看到今天你可以多走一步

191
00:11:32,760 --> 00:11:34,940
你甚至可以得到一个有点懒惰。

192
00:11:34,940 --> 00:11:39,660
这是一般不被推荐，但你甚至可以偷懒

193
00:11:39,660 --> 00:11:44,150
并把一个全局变量，可以这么说，而不是在函数，而不是内部的循环，

194
00:11:44,150 --> 00:11:49,800
但在文件本身以外的所有功能，你写了，我在这里的第15行。

195
00:11:49,800 --> 00:11:55,220
这是令人难以接受的，但意识到这是一个解决方案，有时其他的问题，

196
00:11:55,220 --> 00:11:56,910
我们最终会看到的。

197
00:11:56,910 --> 00:11:59,500
所以现在我们将离开这个样子，但让我们看看我们可以重写此

198
00:11:59,500 --> 00:12:02,360
刚开始表达自己有点不同。

199
00:12:02,360 --> 00:12:05,550
这个方案，仅仅是明确的，是阳性。

200
00:12:05,550 --> 00:12:11,980
让我继续在这里，在我的终端窗口阳性，回车。

201
00:12:11,980 --> 00:12:15,080
编译没问题。我要去，运行positive1，按下回车键。

202
00:12:15,080 --> 00:12:19,250
我要求你给我一个正整数。我会说：-1。没有工作。

203
00:12:19,250 --> 00:12:22,340
0，99。这似乎工作。

204
00:12:22,340 --> 00:12:25,310
也许不是最严峻的考验，但至少它是一个不错的完整性检查

205
00:12:25,310 --> 00:12:27,100
我们在正确的轨道上。

206
00:12:27,100 --> 00:12:29,570
>> 所以，现在让我继续前进，打开第2版，

207
00:12:29,570 --> 00:12:32,800
有什么不同了吗？

208
00:12:32,800 --> 00:12:39,030
它实现了同样的事情，但什么是跳出清楚地不同，这一次呢？

209
00:12:40,790 --> 00:12:47,090
这BOOL绿色。它的显示为绿色，这被称为布尔值，它是一种数据类型的关键字。

210
00:12:47,090 --> 00:12:50,510
它不内置于所有版本的C

211
00:12:50,510 --> 00:12:52,650
您需要包括一个特定的库。

212
00:12:52,650 --> 00:12:56,460
在我们的例子中，我的CS50库，使我们有机会为bool。

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

214
00:12:59,860 --> 00:13:02,190
我可以叫什么，但我把它叫做感谢

215
00:13:02,190 --> 00:13:04,750
只是一种传达一些语义上的意义。

216
00:13:04,750 --> 00:13:07,700
因此，最初的第18行，我显然不是感谢

217
00:13:07,700 --> 00:13:12,230
因为在第18行初始化为false的布尔值感谢。

218
00:13:12,230 --> 00:13:16,500
然后，似乎我做了什么，在21行〜23

219
00:13:16,500 --> 00:13:19,200
我只是一种重写我的逻辑。

220
00:13:19,200 --> 00:13:26,100
因此，没有在功能上不同，但在第22行现在我如果int用户提供了

221
00:13:26,100 --> 00:13:31,360
大于0，那么我简单地改变感谢真正的价值。

222
00:13:31,360 --> 00:13:35,590
我为什么这样做呢？因为在第25行，显然我要检查的条件。

223
00:13:35,590 --> 00:13:39,760
做这个循环，同时感谢是假的。

224
00:13:39,760 --> 00:13:42,960
所以，我提出作为替代第1版

225
00:13:42,960 --> 00:13:47,050
因为它至少有一点也许更直观的，这是一个有点植根于英语。

226
00:13:47,050 --> 00:13:51,980
因此，请执行以下操作，而你不感谢，同时感谢是假的。

227
00:13:51,980 --> 00:13:56,220
而这个时候，我也显然不关心记住用户输入的

228
00:13:56,220 --> 00:14:00,050
因为通知中，没有任何变量n，所以实际上，有一个善意的谎言。

229
00:14:00,050 --> 00:14:03,290
>> 在功能上，该方案是一个有点不同的，一旦我们得到它的底部

230
00:14:03,290 --> 00:14:04,960
因为我不记得n是什么。

231
00:14:04,960 --> 00:14:09,120
但我想在这里展示我们已经看到过，即使调用getInt

232
00:14:09,120 --> 00:14:13,780
和GetString正在使用的右手边的等号，迄今为止，

233
00:14:13,780 --> 00:14:17,310
让我们记住它们的价值，从技术上讲，这不是绝对必要的。

234
00:14:17,310 --> 00:14:20,290
如果因为任何原因，你只是不小心保存的价值，

235
00:14:20,290 --> 00:14:25,540
你只是要检查的值，请注意，我们可以简单地这样写调用getInt，

236
00:14:25,540 --> 00:14:27,320
开括号，括号接近。

237
00:14:27,320 --> 00:14:30,570
该函数会返回一个值，因为我们一直在说。

238
00:14:30,570 --> 00:14:32,220
这将会给你一个int。

239
00:14:32,220 --> 00:14:34,460
所以，如果你在精神上认为这种情况发生，

240
00:14:34,460 --> 00:14:38,190
当我输入99，调用getInt返回99号，

241
00:14:38,190 --> 00:14:41,840
因此从理论上讲，它虽然我的代码实际上是这个。

242
00:14:41,840 --> 00:14:45,950
因此，如果99的确是大于0的，然后感谢成为真正的，

243
00:14:45,950 --> 00:14:50,810
第25行实现哦，我们正在做的，因为我现在感谢，

244
00:14:50,810 --> 00:14:53,970
第26行，我们简单地说，“谢谢你正整数！”

245
00:14:53,970 --> 00:14:55,960
不管它发生。

246
00:14:55,960 --> 00:14:59,140
现在，让我们在这里做轻微的语法糖，可以这么说。

247
00:14:59,140 --> 00:15:04,670
让我们来看看如果我们能清理这条线25在positive3这第三个和最后的变体。

248
00:15:04,670 --> 00:15:13,600
>> 请注意，唯一不同的是哪一行代码？ >> [学生] 25。 >> [马兰]是啊，25。

249
00:15:13,600 --> 00:15:17,680
我们还没有真正看到这一招只是还没有，但我们没有看到1月21日的感叹号，

250
00:15:17,680 --> 00:15:21,070
这表示什么呢？ >> [学生]。 >>或否定。

251
00:15:21,070 --> 00:15:23,510
因此，需要一个布尔值，，并翻转它的价值。

252
00:15:23,510 --> 00:15:25,810
真亦假，假的变成真的。

253
00:15:25,810 --> 00:15:30,420
所以，我建议，即使是一点点更直观的方式编写代码

254
00:15:30,420 --> 00:15:33,430
因为我仍然会初始化为false感谢，我还是做到以下几点，

255
00:15:33,430 --> 00:15:36,010
我感谢设置为true，在时机成熟时，

256
00:15:36,010 --> 00:15:40,880
但现在你可以真的只是翻译代码口头左到右，

257
00:15:40,880 --> 00:15:45,630
（感谢）;因为爆炸或感叹号表示不的概念，

258
00:15:45,630 --> 00:15:47,580
因此，虽然不感谢。

259
00:15:47,580 --> 00:15:49,900
所以，再一次，我们没有引入任何新的概念本身。

260
00:15:49,900 --> 00:15:53,730
我们谈论布尔值，当我们从头打了，

261
00:15:53,730 --> 00:15:56,720
但现在认识到，我们就可以开始写我们的代码在许多不同的方式。

262
00:15:56,720 --> 00:16:01,060
因此，尤其是在pset1移动，如果你是那种挣扎的方式来编写一些程序，

263
00:16:01,060 --> 00:16:04,340
赔率是你很幸运，因为可以有任意数量的解决方案

264
00:16:04,340 --> 00:16:06,110
您可以在发生。

265
00:16:06,110 --> 00:16:10,500
举例来说，这仅仅是3，即使是最简单的方案。好的。

266
00:16:10,500 --> 00:16:14,200
现在还记得上周一，我们在此说明离开与返回值。

267
00:16:14,200 --> 00:16:18,450
因此，对于第一次，我们写了一个程序，不只是有主;

268
00:16:18,450 --> 00:16:22,550
它也有它自己的自定义函数，我写在这里。

269
00:16:22,550 --> 00:16:26,810
因此，在第31行到34，我已经实现了一个多维数据集函数。

270
00:16:26,810 --> 00:16:30,240
这并不复杂。这只是一个* A * A在这种情况下。

271
00:16:30,240 --> 00:16:34,750
但是，重要的是它是我输入的形式

272
00:16:34,750 --> 00:16:39,180
我回A * A * A的形式输出。

273
00:16:39,180 --> 00:16:43,560
所以，现在我有能力，就像我单独与prinf，

274
00:16:43,560 --> 00:16:47,240
调用该函数调用的立方体函数。

275
00:16:47,240 --> 00:16:51,970
>> 和多维数据集函数需要一定的投入，和多维数据集函数返回一些输出。

276
00:16:51,970 --> 00:16:56,960
与此相反，输出只是做了一些事情。

277
00:16:56,960 --> 00:17:00,840
它没有返回任何东西，我们关心的，顺便说一句，即使它返回一个值;

278
00:17:00,840 --> 00:17:03,110
你只是笼统地忽略它。

279
00:17:03,110 --> 00:17:06,510
的printf只是做了一些事情。它有打印到屏幕上的副作用。

280
00:17:06,510 --> 00:17:11,770
通过对比在这里，我们有多维数据集函数，它实际上返回的东西。

281
00:17:11,770 --> 00:17:15,520
因此，对于那些熟悉的，这是一个非常简单的想法。

282
00:17:15,520 --> 00:17:19,640
但对于那些不太熟悉这个想法传递的投入，并取回输出，

283
00:17:19,640 --> 00:17:21,950
让我们尝试只是超级简单的东西。

284
00:17:21,950 --> 00:17:25,490
是任何人都舒服了舞台上简单吗？

285
00:17:25,490 --> 00:17:28,040
你有舒适与你的相机。是吗？好吧。

286
00:17:28,040 --> 00:17:31,240
你叫什么名字？ >> [学生]肯。 “肯。好的。肯，就到了。

287
00:17:31,240 --> 00:17:35,050
肯将是各种各样的功能，在这里。

288
00:17:35,050 --> 00:17:38,720
让我们继续前进，并做到这一点。让我们一点点花哨。

289
00:17:38,720 --> 00:17:42,260
认识你很高兴。欢迎来到舞台中央。好的。

290
00:17:42,260 --> 00:17:46,640
让打这个按钮，在这里。好的。

291
00:17:46,640 --> 00:17:49,820
所以，在这里你有一个现代化的黑板上，

292
00:17:49,820 --> 00:17:53,470
我的主要功能是，例如，

293
00:17:53,470 --> 00:17:56,460
我没有一台iPad拿在手中。

294
00:17:56,460 --> 00:17:59,710
>> 我真的不记得怎么样 - 好了，我不能说。

295
00:17:59,710 --> 00:18:02,480
我真的不具有良好的手写，

296
00:18:02,480 --> 00:18:05,520
因此，我想你打印的东西对我来说在屏幕上。

297
00:18:05,520 --> 00:18:12,040
我的主程序，我要你说这

298
00:18:12,040 --> 00:18:16,720
它在我的鸡从头开始写，然后通过您的输入。

299
00:18:16,720 --> 00:18:20,400
虽然这项工作是太傻了，功能和调用一个函数的概念

300
00:18:20,400 --> 00:18:22,400
并返回一个函数真的归结到这。

301
00:18:22,400 --> 00:18:26,260
我主，我刚才写的printf，报价享有的东西在屏幕上，

302
00:18:26,260 --> 00:18:29,110
我运行这个程序，一旦被调用的printf，

303
00:18:29,110 --> 00:18:32,880
它需要一个参数一个参数，有时在双引号之间。

304
00:18:32,880 --> 00:18:35,880
这里有这样的说法。我把它传递给肯。

305
00:18:35,880 --> 00:18:39,020
写了一些数年前，他是一个黑盒子

306
00:18:39,020 --> 00:18:41,510
显然只知道如何打印在屏幕上的东西。

307
00:18:41,510 --> 00:18:43,150
所以执行。

308
00:18:49,280 --> 00:18:51,280
这是不坏的。非常好。

309
00:18:51,280 --> 00:18:55,510
所以，现在肯执行。他递给我任何东西吗？

310
00:18:55,510 --> 00:18:57,470
这并不是说我们迄今为止见过的。

311
00:18:57,470 --> 00:19:00,460
同样，printf并实际上返回一个数字，但我们忽略，现在

312
00:19:00,460 --> 00:19:03,470
因为我们从来没有用过它。所以这是它为肯。

313
00:19:03,470 --> 00:19:08,580
因此，现在主要需要控制的程序

314
00:19:08,580 --> 00:19:11,060
因为这行代码，输出，完成执行。

315
00:19:11,060 --> 00:19:14,050
我们去我们的方式，执行任何其他线。

316
00:19:14,050 --> 00:19:17,320
现在让我们尝试一个稍微不同的例子。

317
00:19:17,320 --> 00:19:24,940
这一次在这里让我们先来清除屏幕，这时候我们会做的魔方功能，

318
00:19:24,940 --> 00:19:27,080
但是这一次，我期望的输出值。

319
00:19:27,080 --> 00:19:29,180
>> 因此，让我们继续前进，并做到这一点。

320
00:19:29,180 --> 00:19:35,790
现在，我必须说，X获取立方体的x行的代码。

321
00:19:41,370 --> 00:19:46,370
这行代码，召回，看起来像这样：X =立方体（X）;

322
00:19:46,370 --> 00:19:50,930
所以，这是怎么去上班？让我们继续前进，并给你一个白色的屏幕。

323
00:19:50,930 --> 00:19:54,070
我要写下x的值，

324
00:19:54,070 --> 00:20:01,400
在这个时候，恰好是，比方说，保持它的简单。

325
00:20:01,400 --> 00:20:06,150
我已经写在一张纸的价值，这是我的x值。

326
00:20:06,150 --> 00:20:10,920
我把它肯。 “我只写答案是什么？呀，让我们只写答案。

327
00:20:12,760 --> 00:20:18,940
好吧。现在他已经回到我的东西。完美的。尼斯SEGUE。

328
00:20:18,940 --> 00:20:23,120
所以，现在他递给我回值8，在这种情况下，我用它做什么？

329
00:20:23,120 --> 00:20:28,250
其实 - 让我们来看看，得到这个权利。我会用它做什么呢？

330
00:20:28,250 --> 00:20:33,440
现在，我要借此价值和实际存储在内存中在这些相同的位。

331
00:20:33,440 --> 00:20:35,170
但是请注意，我是那种挣扎在这里。

332
00:20:35,170 --> 00:20:38,210
我有点困惑，因为我在哪里写x的值，

333
00:20:38,210 --> 00:20:43,150
因为我刚刚做的是需要亲自肯一张纸的值是2，

334
00:20:43,150 --> 00:20:46,590
这是X，而事实上，这恰恰发生了什么事。

335
00:20:46,590 --> 00:20:50,210
因此，原来，当你调用该函数，并传递参数

336
00:20:50,210 --> 00:20:53,290
喜欢Hello，世界传递的参数，如2，

337
00:20:53,290 --> 00:20:57,110
一般情况下，你通过在副本这样的说法。

338
00:20:57,110 --> 00:21:00,730
所以，正如我写下的2号这里，并把它交给肯，

339
00:21:00,730 --> 00:21:04,720
必须说我的地方仍然有一份价值2

340
00:21:04,720 --> 00:21:08,890
因为事实上，现在我已经得到了值8，我需要回去RAM

341
00:21:08,890 --> 00:21:12,130
写下我曾经有过的数字2。

342
00:21:12,130 --> 00:21:16,950
因此，在视觉上，请记住这个概念，从字面上看，一个副本的价值。

343
00:21:16,950 --> 00:21:20,780
>> 肯做他的东西，递给我的东西 - 在这种情况下，这样的值8  - 

344
00:21:20,780 --> 00:21:24,980
然后，我必须做一些与该值，如果我要保持它的周围。

345
00:21:24,980 --> 00:21:29,650
因此，所有的一切都会回来不久是所有太熟悉了。

346
00:21:29,650 --> 00:21:34,920
非常感谢你在这里演示，肯。 [掌声]

347
00:21:34,920 --> 00:21:36,920
非常好。

348
00:21:36,920 --> 00:21:42,690
让我们来看看如何，最终涉及到的一些函数调用，我们一直在这里做。

349
00:21:42,690 --> 00:21:47,910
让我继续前进，把我们带回了魔方的例子在这里。

350
00:21:47,910 --> 00:21:53,300
请注意，如果我们要真正开始采取进一步

351
00:21:53,300 --> 00:21:57,570
我们必须考虑到一个事实，即数x的传递在这里

352
00:21:57,570 --> 00:22:01,530
从实际被传递给函数的是不同的。

353
00:22:01,530 --> 00:22:05,880
所以，再一次，通过复制传递将成为相当有密切关系，在短短的时刻。

354
00:22:05,880 --> 00:22:09,580
让我们来看看的东西，不工作的权利，但。

355
00:22:09,580 --> 00:22:13,250
我要继续前进，打开第三个车为例，这是有缺陷的性质，

356
00:22:13,250 --> 00:22:18,550
这就是所谓的buggy3，它实现了一个交换的功能。

357
00:22:18,550 --> 00:22:25,110
在这里，我们有一个主要功能，x和y任意初始化为1和2，分别。

358
00:22:25,110 --> 00:22:27,700
我们可以使用调用getInt，但我们只需要一个简单的练习，

359
00:22:27,700 --> 00:22:30,170
所以它是硬编码为1和2。

360
00:22:30,170 --> 00:22:35,340
在第21行和22行，我们似乎打印出x和y，每行1。

361
00:22:35,340 --> 00:22:39,720
然后在第23行，我要求我交换这些值，点，点，点。

362
00:22:39,720 --> 00:22:44,170
显然，我在第24行所谓的交换，需要两个参数，调用一个函数。

363
00:22:44,170 --> 00:22:48,300
这是完全合法的功能，需要两个参数。我们已经看到输出已经做到这一点了。

364
00:22:48,300 --> 00:22:51,830
>> 所以交换显然需要x和y，正如它的名字所暗示的，

365
00:22:51,830 --> 00:22:54,670
我希望它会交换这两个值。

366
00:22:54,670 --> 00:23:00,090
因此，我要求在第25行“换！”我和转载的X和Y

367
00:23:00,090 --> 00:23:03,070
的假设下，他们已经确实被交换。

368
00:23:03,070 --> 00:23:06,080
但是，如果我运行这个程序 - 让我打开一个终端窗口，

369
00:23:06,080 --> 00:23:09,860
让我buggy3  - 顾名思义，这是没有好下场的

370
00:23:09,860 --> 00:23:15,770
因为当我按下Enter键，注意x是1，y是2，

371
00:23:15,770 --> 00:23:19,420
尚未在程序结束时，它们仍然是，实际上，相同的。

372
00:23:19,420 --> 00:23:22,960
因此，根据示范与肯，刚才到底发生了什么？

373
00:23:22,960 --> 00:23:28,710
我们来看看这个交换功能。它的超级短。这是只有几行代码长。

374
00:23:28,710 --> 00:23:34,520
但是，什么是最根本的问题的基础上简单的故事与肯在这里告诉吗？

375
00:23:34,520 --> 00:23:36,670
交换为什么坏了？

376
00:23:36,670 --> 00:23:39,660
[学生]你存储的副本，而不是变量。

377
00:23:39,660 --> 00:23:43,980
没错。我们存储的副本，而不是变量本身。

378
00:23:43,980 --> 00:23:47,170
换句话说，交换显然需要两个参数，一个int，

379
00:23:47,170 --> 00:23:49,370
和它的任意称为a和b，

380
00:23:49,370 --> 00:23:54,420
这里我已经通过在x和y分别为1和2，这是

381
00:23:54,420 --> 00:23:58,770
但我不是真的通过在x，我不从字面上通过在y

382
00:23:58,770 --> 00:24:01,450
我是通过x和y的副本的副本。

383
00:24:01,450 --> 00:24:04,510
这几乎就好像你复制并粘贴到交换

384
00:24:04,510 --> 00:24:07,810
你希望它是实际操作的值。

385
00:24:07,810 --> 00:24:14,480
所以，如果是这样的话，当我的程序开始执行第35行，然后36，

386
00:24:14,480 --> 00:24:18,650
当我到37行，在这一点上的故事，是什么值呢？

387
00:24:21,040 --> 00:24:25,050
在这一点上的故事，37号线，在这一点上的价值是什么？ >> [学生] 1。

388
00:24:25,050 --> 00:24:29,280
[马兰它应该只是1，正确的，因为x的第一个参数中传递，

389
00:24:29,280 --> 00:24:33,080
此功能只是任意调用它的第一个参数。

390
00:24:33,080 --> 00:24:38,200
同样是Y的第二个参数，它只是随意调用的第二个参数b。

391
00:24:38,200 --> 00:24:40,990
>> 这种两分法其实是相当简单的解释。想想吧。

392
00:24:40,990 --> 00:24:43,320
我们没有见过的人谁写输出，

393
00:24:43,320 --> 00:24:50,770
因此可以肯定，他或她不知道30年后，我们的变量来调用。

394
00:24:50,770 --> 00:24:56,650
因此，必须有区分你叫什么变量的功能，你写的

395
00:24:56,650 --> 00:25:02,080
你叫什么功能，你打电话或使用的变量。

396
00:25:02,080 --> 00:25:05,340
所以，换句话说，我写了我的变量x和y，

397
00:25:05,340 --> 00:25:08,890
但如果别人已经写了交换功能，他或她肯定会不知道

398
00:25:08,890 --> 00:25:10,690
我的变量来调用，

399
00:25:10,690 --> 00:25:13,830
所以认识到，这就是为什么你有这种二元性的名称。

400
00:25:13,830 --> 00:25:16,750
从技术上讲，我可以做到这一点巧合，

401
00:25:16,750 --> 00:25:20,080
但他们仍然可以通过为副本。

402
00:25:20,080 --> 00:25:23,650
这仅仅是一个纯粹的巧合，美观，如果人谁写的交换

403
00:25:23,650 --> 00:25:26,150
曾使用相同的名称。

404
00:25:26,150 --> 00:25:32,370
所以在这一点上故事中的第37行，一个是1，B是2，现在我进行交换。

405
00:25:32,370 --> 00:25:34,900
首先，让我真正做到这一点简单得多。

406
00:25:34,900 --> 00:25:36,690
我不知道这3行代码做什么。

407
00:25:36,690 --> 00:25:41,210
让我这样做：B = A; A = B;完成。

408
00:25:41,210 --> 00:25:44,690
为什么是这个破碎的，逻辑上吗？

409
00:25:46,490 --> 00:25:48,900
这是一种直观的东西，对不对？

410
00:25:48,900 --> 00:25:52,560
因此，一个变为b和b成为一个

411
00:25:52,560 --> 00:25:57,730
但问题是，只要线37执行，什么是a和b的值？

412
00:25:57,730 --> 00:26:03,410
相同的是，1，因为你已经篡改，可以这么说，你已经改变了b为一个。

413
00:26:03,410 --> 00:26:08,890
因此，一旦线路37条的执行，这是伟大的，你现在有2份1号

414
00:26:08,890 --> 00:26:13,350
里面的这个函数，你说这样的话时，在第38行A = B，

415
00:26:13,350 --> 00:26:17,640
你因为你只是指定1到1种旋。

416
00:26:17,640 --> 00:26:20,580
你失去了你关心的价值。

417
00:26:20,580 --> 00:26:23,220
因此，在原始版本，请注意，我就是这样做的。

418
00:26:23,220 --> 00:26:26,850
我不是有三分之一的代码看起来是这样的。

419
00:26:26,850 --> 00:26:28,580
我声明了一个临时变量。

420
00:26:28,580 --> 00:26:32,170
>> tmp是一个临时变量，一个很常见的名字，它是一个int

421
00:26:32,170 --> 00:26:34,580
因为它符合我要的副本。

422
00:26:34,580 --> 00:26:39,770
我的tmp目录内的存储复制，所以一旦已经执行了37行，

423
00:26:39,770 --> 00:26:45,860
的值是 - 快速完整性检查 -  1，b的值是2，

424
00:26:45,860 --> 00:26:48,970
TMP的价值也是1。

425
00:26:48,970 --> 00:26:52,060
所以，现在我执行第38行。

426
00:26:52,060 --> 00:27:00,540
一旦执行第38行，一个需要的b的值。和B是2，所以现在是2。

427
00:27:00,540 --> 00:27:05,210
所以在这一点上的故事，一个是2，B 2，tmp是1，

428
00:27:05,210 --> 00:27:11,060
所以现在从逻辑上讲，我们只是扑通TMP到b的值，我们就大功告成了。

429
00:27:11,060 --> 00:27:12,800
因此，我们已经解决了这个问题。

430
00:27:12,800 --> 00:27:17,720
不幸的是，当我运行这个程序，在这种形式，它并不实际交换的任何值。

431
00:27:17,720 --> 00:27:20,100
但要清楚，为什么呢？

432
00:27:23,660 --> 00:27:26,450
我刚才固定的逻辑问题，

433
00:27:26,450 --> 00:27:31,020
但话又说回来，如果我运行这个程序，X和Y保持不变

434
00:27:31,020 --> 00:27:33,310
结束程序的执行。

435
00:27:33,310 --> 00:27:37,220
[听不见的学生评论] >>我们还没有返回任何东西，所以这是真的。

436
00:27:37,220 --> 00:27:39,670
但事实证明，这里有一个有点问题，因为到目前为止，

437
00:27:39,670 --> 00:27:44,170
，我们已经能够返回的唯一的一件事，这是一个限制C.

438
00:27:44,170 --> 00:27:49,070
你可以只返回一个真正的价值，在这种情况下，我坚持在这里

439
00:27:49,070 --> 00:27:53,310
因为我可以返回新的x值，或者我可以返回新的y值，

440
00:27:53,310 --> 00:27:55,190
但我既要回来了。

441
00:27:55,190 --> 00:27:58,650
于是久违这里没有简单的解决方案。

442
00:27:58,650 --> 00:28:01,710
但问题的根本是为什么呢？我们有什么实际交换？

443
00:28:01,710 --> 00:28:04,190
[学生]：a和b。 >> a和b。

444
00:28:04,190 --> 00:28:08,230
但是A和B是x和y，这意味着我们只是做了所有的工作副本，

445
00:28:08,230 --> 00:28:11,650
我们只用了3分钟，谈论交换功能，所有这些变量，

446
00:28:11,650 --> 00:28:15,420
这是伟大的，完全正确的隔离，

447
00:28:15,420 --> 00:28:20,740
但A和B的范围是在这些行。

448
00:28:20,740 --> 00:28:24,790
>> 就像一个for循环，如果你声明一个整数，我在for循环中，

449
00:28:24,790 --> 00:28:28,760
同样，如果你声明a和b里面的一个函数，你写的，

450
00:28:28,760 --> 00:28:33,320
该函数的内部，他们是唯一有效的，这意味着只要交换是执行

451
00:28:33,320 --> 00:28:38,470
和我们去从第24行到第25行中，x和y没有被改变在所有。

452
00:28:38,470 --> 00:28:42,790
你只是浪费了大量的时间交换的变量的副本。

453
00:28:42,790 --> 00:28:47,010
所以，事实证明，要解决这个实际上是不很明显。

454
00:28:47,010 --> 00:28:50,670
这不是很充足的返回值，因为我们只能返回1的值，

455
00:28:50,670 --> 00:28:53,470
我真的想交换x和y都在相同的时间，

456
00:28:53,470 --> 00:28:55,210
所以我们要回来这。

457
00:28:55,210 --> 00:29:01,020
但现在，意识到该问题，a和b的副本的事实从根本上来自

458
00:29:01,020 --> 00:29:03,630
他们是在自己的范围内。

459
00:29:03,630 --> 00:29:05,050
让我们以某种方式设法解决这个。

460
00:29:05,050 --> 00:29:11,250
让我真正滚动回到这里打开了，让我们说，第四个变种，buggy4。

461
00:29:11,250 --> 00:29:13,370
这个怎么样？

462
00:29:13,370 --> 00:29:17,810
这是一个类似的，但简单的问题之前，我们需要解决它的刺。

463
00:29:17,810 --> 00:29:24,190
此程序被称为增量，它显然初始化的x 1在第18行中的整数。

464
00:29:24,190 --> 00:29:28,150
然后，我x是1，然后我要求“递增...”

465
00:29:28,150 --> 00:29:33,730
然后我叫增量，但在22日和23行，我要求它已经增加，

466
00:29:33,730 --> 00:29:40,220
我要求x现在不管它是什么 -  2，据推测 - 这是越野车的计划。

467
00:29:40,220 --> 00:29:42,610
有什么问题吗？

468
00:29:43,440 --> 00:29:50,160
是啊。 >> [听不见的学生回应] >>没错。

469
00:29:50,160 --> 00:29:52,490
因此X已经宣布，很明显，第18行。

470
00:29:52,490 --> 00:29:54,700
这是内主要的大括号中。

471
00:29:54,700 --> 00:29:58,440
所以，简单的答案是x存在，在这里，

472
00:29:58,440 --> 00:30:03,930
它不存在，在第32行，因此这个方案甚至不会编译。

473
00:30:03,930 --> 00:30:07,940
我尝试编译代码时，编译器会骂我

474
00:30:07,940 --> 00:30:14,100
一些未声明的标识符或东西的效果。事实上，让我们尝试。

475
00:30:14,100 --> 00:30:18,470
这是使buggy4。在那里，它是。

476
00:30:18,470 --> 00:30:22,110
使用未声明的标识符“X”的第32行。

477
00:30:22,110 --> 00:30:25,580
而实际上，让我们更加明确，今天在这里，这是非常有用的

478
00:30:25,580 --> 00:30:27,580
在办公时间和在家里。

479
00:30:27,580 --> 00:30:29,300
>> 请注意，这是一个有点神秘的书面。

480
00:30:29,300 --> 00:30:37,270
但事实上，铿锵有对我们大吼大叫，说buggy4.c：32:5，实际上是有用的。

481
00:30:37,270 --> 00:30:42,050
这意味着，该错误是在第5字符位置的线32上。

482
00:30:42,050 --> 00:30:46,700
因此，1，2，3，4，5。这是，事实上，问题出在哪里。

483
00:30:46,700 --> 00:30:49,790
此外，也记住在办公时间，在家里，我很幸运在这里。

484
00:30:49,790 --> 00:30:52,990
我有一个错误。这将是比较容易解决的。

485
00:30:52,990 --> 00:30:55,990
但是，如果你得到了整个画面充满压倒性的错误消息，

486
00:30:55,990 --> 00:31:00,330
再次，实现最底层的人可能只是最上面的症状。

487
00:31:00,330 --> 00:31:03,450
因此，总是追逐你的错误，从上而下

488
00:31:03,450 --> 00:31:05,820
因为有可能只是一个菊花链效应

489
00:31:05,820 --> 00:31:09,240
建议你有比你实际做的方式更多的问题。

490
00:31:09,240 --> 00:31:15,150
那么，我们怎么能解决这个问题，如果我的目标是增加x？ >> [学生] X全局。

491
00:31:15,150 --> 00:31:17,060
好了，我们可以使X全球。

492
00:31:17,060 --> 00:31:20,480
让我们以快捷，我先前警告，但心里很不舒服，我们只需要一个快速解决方案，

493
00:31:20,480 --> 00:31:25,730
所以让我们只说在这里诠释x。这使得X全球。

494
00:31:25,730 --> 00:31:31,800
所以，现在主要有访问和增量访问，

495
00:31:31,800 --> 00:31:34,110
所以让我继续前进，现在编译这个。

496
00:31:34,110 --> 00:31:37,630
，输入使buggy4。似乎现在编译。

497
00:31:37,630 --> 00:31:41,230
让运行buggy4。看来，以实际工作。

498
00:31:41,230 --> 00:31:45,150
这是一个，按我说的这些东西，还不如我呢，

499
00:31:45,150 --> 00:31:47,010
我刚刚在这里完成的，因为在一般情况下，

500
00:31:47,010 --> 00:31:50,440
我们的计划会得到更有趣，比这更长的时间，

501
00:31:50,440 --> 00:31:56,390
如果您解决生活中的问题，只是把所有的变量在文件的开头，

502
00:31:56,390 --> 00:31:59,690
做节目非常迅速获得惊人，难以管理。

503
00:31:59,690 --> 00:32:02,190
它变得很难想出新的变量名，

504
00:32:02,190 --> 00:32:05,240
它会更难明白变量是做什么的，

505
00:32:05,240 --> 00:32:08,460
所以在一般，这是不是一个好的解决方案。

506
00:32:08,460 --> 00:32:10,030
因此，让我们做到这一点。

507
00:32:10,030 --> 00:32:12,160
我们不想在这里使用一个全局变量。

508
00:32:12,160 --> 00:32:16,240
>> 我想增加x，所以我可以很明显 - 

509
00:32:16,240 --> 00:32:18,670
在一天结束的时候，这是一个愚蠢的故事，因为我们只要做到这一点 - 

510
00:32:18,670 --> 00:32:24,450
但是，如果我不知道，运营商或我是不允许改变它在主本身，

511
00:32:24,450 --> 00:32:30,730
我还能实现肯在这里没有对多维数据集，但增加？

512
00:32:31,380 --> 00:32:33,190
我该如何改变这件事情吗？是啊。

513
00:32:33,190 --> 00:32:38,480
[学生] PASS x，然后返回[听不清] >>好，好。

514
00:32:38,480 --> 00:32:41,900
那么，为什么不我通过在x和，而不是返回，

515
00:32:41,900 --> 00:32:44,870
我为什么不只是返回x + 1。

516
00:32:44,870 --> 00:32:47,710
一对夫妇更多的事情必须改变。我在正确的轨道上。

517
00:32:47,710 --> 00:32:49,770
还有什么我需要调整吗？别人。是啊。

518
00:32:49,770 --> 00:32:51,740
[听不见的学生反应]

519
00:32:51,740 --> 00:32:54,730
我需要改变返回类型的增量，因为它没有失效。

520
00:32:54,730 --> 00:32:57,780
被返回无效意味着什么，但清楚的是，

521
00:32:57,780 --> 00:32:59,830
所以这需要改变 -  >> [学生]诠释。

522
00:32:59,830 --> 00:33:02,740
int类型是一致的，无论我返回。

523
00:33:02,740 --> 00:33:05,180
现在别的东西，是大声喧哗。是啊。

524
00:33:05,180 --> 00:33:08,400
[听不见的学生反应] >> [马兰]所以，我需要增加x？

525
00:33:08,400 --> 00:33:12,080
[听不见的学生反应] >> [马兰啊，所以我需要传递X。

526
00:33:12,080 --> 00:33:16,660
所以我需要在这里做到这一点。 >> [听不见的学生评论]

527
00:33:16,660 --> 00:33:20,050
[马兰]的原型，我必须要改变这个在这里。

528
00:33:20,050 --> 00:33:22,930
因此，这已经成为一个int，成为 - 

529
00:33:22,930 --> 00:33:25,620
嗯，我其实有一个错误在这里。让我们来解决这个问题第一次。

530
00:33:25,620 --> 00:33:29,590
应该是什么内容究竟是什么？它是一个int的东西。

531
00:33:29,590 --> 00:33:32,700
这可能是X，但坦率地说，如果你开始调用所有的变量x，

532
00:33:32,700 --> 00:33:35,390
它会得到越来越不清晰哪个是哪个。

533
00:33:35,390 --> 00:33:39,560
>> 因此，让我们任意选择一个不同的命名约定为我的助手功能，

534
00:33:39,560 --> 00:33:41,940
我写的功能。我们会打电话给它，或者我们可以把它称为 - 

535
00:33:41,940 --> 00:33:45,010
让我们把它数更明确。

536
00:33:45,010 --> 00:33:47,560
于是我返回任何数加1，

537
00:33:47,560 --> 00:33:50,740
现在我要改变的事情，在这里，一个其他的东西在这里。

538
00:33:50,740 --> 00:33:54,350
我有什么改变第21行第一次吗？ >> [听不见的学生反应]

539
00:33:54,350 --> 00:33:57,610
[马兰]我有把它分配给x。我可以不叫增量（X）。

540
00:33:57,610 --> 00:34:01,960
我需要记住的答案，通过改变x的值的左侧。

541
00:34:01,960 --> 00:34:04,680
即使x是现在的左，右，这是完全正常

542
00:34:04,680 --> 00:34:08,860
因为右手边先被执行，然后得到一屁股到左手的事情 - 

543
00:34:08,860 --> 00:34:10,600
x在这种情况下。

544
00:34:10,600 --> 00:34:12,159
最后，这是一个简单的办法。

545
00:34:12,159 --> 00:34:17,230
这应该只是匹配下，INT编号。

546
00:34:17,230 --> 00:34:20,570
因此，一大堆的一个非常愚蠢的功能

547
00:34:20,570 --> 00:34:24,420
但具有代表性，我们将越来越多地想要做的事情。

548
00:34:24,420 --> 00:34:27,090
因此，请buggy4。我搞砸了的地方。

549
00:34:27,090 --> 00:34:30,139
哦，我的上帝。五6行程序中的错误。

550
00:34:30,139 --> 00:34:35,690
那么，什么是错的第18行，字符？

551
00:34:35,690 --> 00:34:39,610
所以，我必须声明，诠释。

552
00:34:39,610 --> 00:34:41,920
让我们来看看。有一大堆其他错误。

553
00:34:41,920 --> 00:34:47,010
哦，我的上帝 -  19，18，21  - 但同样，让我们​​清除屏幕，控制L，

554
00:34:47,010 --> 00:34:49,380
并重新运行铿锵。

555
00:34:49,380 --> 00:34:51,340
因此，5个问题，其实只是1。

556
00:34:51,340 --> 00:34:57,520
所以，现在让我们来运行buggy4，回车。哇，x已经被正确地增加。

557
00:34:57,520 --> 00:35:02,720
好的。如何增加数字的任何问题？是啊。

558
00:35:02,720 --> 00:35:09,870
[听不见的学生问题] >>很好的问题。

559
00:35:09,870 --> 00:35:14,220
它是如何，我可以只改变x的数量，程序将立即知道吗？

560
00:35:14,220 --> 00:35:16,200
>> 同样，认为它是这个抽象。

561
00:35:16,200 --> 00:35:21,600
所以，我主要和Ken是增量，坦率地说，我不关心，什么肯称，他的iPad。

562
00:35:21,600 --> 00:35:26,570
我不在乎他所说的任何有跟他实现这个功能。

563
00:35:26,570 --> 00:35:33,340
这是一个实现细节，我主，不关心。

564
00:35:33,340 --> 00:35:38,250
因此，简单地改变它一贯里面的功能 - 数字和数量在这里 - 

565
00:35:38,250 --> 00:35:40,960
都需要只要我重新编译。

566
00:35:40,960 --> 00:35:44,180
这是有点像，如果你认为我们很多人，你的驾驶执照

567
00:35:44,180 --> 00:35:46,770
驱动或如果你甚至驱动的汽车，

568
00:35:46,770 --> 00:35:50,950
我们大多数人不知道如何汽车引擎盖下的。

569
00:35:50,950 --> 00:35:54,970
从字面上看，如果你打开​​引擎盖，我们大多数人 - 包括我自己 - 

570
00:35:54,970 --> 00:35:56,940
不会真正了解我们正在寻找，

571
00:35:56,940 --> 00:35:59,220
就像你可能会觉得现在的东西，如这项权利的一种。

572
00:35:59,220 --> 00:36:01,480
但是，我们真的不关心的汽车是如何工作的，

573
00:36:01,480 --> 00:36:05,970
我们不必关心的所有的汽车内的杆和活塞和电缆

574
00:36:05,970 --> 00:36:08,160
实际上这样做。

575
00:36:08,160 --> 00:36:12,770
所以像你所说的在这里并不重要，在这种情况下，活塞的东西。同样的想法。

576
00:36:12,770 --> 00:36:25,300
是啊。 >> [听不见的学生问题]

577
00:36:25,300 --> 00:36:29,180
如果还有更多的用途可变的舍的时刻前，

578
00:36:29,180 --> 00:36:32,150
作为程序员，你将不得不改变他们无处不在。

579
00:36:32,150 --> 00:36:36,600
或者你可以从字面上文件，菜单，然后查找，替换 - 类似的东西 - 

580
00:36:36,600 --> 00:36:39,170
但你会拥有自己的这些变化。

581
00:36:39,170 --> 00:36:47,450
你必须是一致的。 >> [学生]如果有多个变量[听不清]

582
00:36:47,450 --> 00:36:53,100
喜欢这里，如果这是一个特定的顺序int的另一个电话号码吗？ >> [学生]正确。

583
00:36:53,100 --> 00:36:56,590
[马兰]是啊。顺序很重要，当你调用该函数。

584
00:36:56,590 --> 00:37:00,050
>> 所以，如果我在这里呼吁增加的东西逗号东西，

585
00:37:00,050 --> 00:37:01,680
有一个直接的映射。

586
00:37:01,680 --> 00:37:05,690
第一个变量，不管它的名字，在这里的第一个参数的副本。

587
00:37:05,690 --> 00:37:07,760
抱歉。这不应该是一个括号。

588
00:37:07,760 --> 00:37:11,490
第二个参数与第二个。 ，是的，所以，为了事宜。好的。

589
00:37:11,490 --> 00:37:17,020
抱歉。我花了很长的路到那里。其他问题吗？好的。

590
00:37:17,020 --> 00:37:20,610
让我们看看如果我们不能描绘出一个什么样的居然会在这里

591
00:37:20,610 --> 00:37:23,090
引擎盖下的，可以这么说。

592
00:37:23,090 --> 00:37:26,640
这是一个矩形，可能代表你的计算机的内存。

593
00:37:26,640 --> 00:37:30,970
即使你不知道如何记忆或RAM作品如何，

594
00:37:30,970 --> 00:37:33,940
至少，假设你有束，这些天。

595
00:37:33,940 --> 00:37:36,280
你必须兆的，你有GB的，

596
00:37:36,280 --> 00:37:40,870
我们知道，从0周，一个字节是什么？ >> [学生] 8位。

597
00:37:40,870 --> 00:37:42,950
8位的，对不对？因此，8个零和1。

598
00:37:42,950 --> 00:37:45,880
所以，如果你的计算机有一个演出的RAM，2音乐会的RAM，这些天，

599
00:37:45,880 --> 00:37:55,030
你有一个亿或2亿字节的内存或大约8亿或16亿位

600
00:37:55,030 --> 00:37:56,890
您的计算机内。

601
00:37:56,890 --> 00:38:00,590
与毛茸茸的小威利例如，它没有磁性粒子通常会了。

602
00:38:00,590 --> 00:38:04,450
越来越多的 - 至少在笔记本电脑 - 它的固态硬盘，固态硬盘，

603
00:38:04,450 --> 00:38:08,580
只是没有可移动部件。这是所有的电子。这一切都基于电力。

604
00:38:08,580 --> 00:38:14,060
因此，认为这个矩形代表1或2 GB的内存，你必须。

605
00:38:14,060 --> 00:38:16,020
>> 因此，它是一个内存块。

606
00:38:16,020 --> 00:38:19,830
世界计算机科学排序分区

607
00:38:19,830 --> 00:38:22,950
内存块做不同的事情。

608
00:38:22,950 --> 00:38:27,190
举例来说，如果这是您的计算机的RAM，有建议由矩形，

609
00:38:27,190 --> 00:38:31,130
事实证明，按照惯例，在您的RAM的顶部，可以这么说，

610
00:38:31,130 --> 00:38:33,660
一般是什么所谓的文本段。

611
00:38:33,660 --> 00:38:36,740
这些都是“0”和“1编译了。

612
00:38:36,740 --> 00:38:39,020
所以，当我们已经看到引擎盖底下的a.out是什么，

613
00:38:39,020 --> 00:38:41,980
所有这些0和1，当你运行一个程序，

614
00:38:41,980 --> 00:38:46,290
那些“0”和“1”从您的硬盘驱动器加载到一些所谓的RAM，

615
00:38:46,290 --> 00:38:49,320
在RAM中，他们把在顶部。

616
00:38:49,320 --> 00:38:52,770
同时，你还有其他的事情：初始化数据，未初始化的数据。

617
00:38:52,770 --> 00:38:57,510
这些大片的内存是指为全局变量，你不经常使用

618
00:38:57,510 --> 00:39:00,760
但有时如果你这样做，他们结束了在那里为好。

619
00:39:00,760 --> 00:39:04,260
此外，还有一些其他的东西：环境变量，我们不会花太多的时间，

620
00:39:04,260 --> 00:39:06,860
但随后2个重要的事情，这将回来，整个学期，

621
00:39:06,860 --> 00:39:08,550
堆栈和堆。

622
00:39:08,550 --> 00:39:12,210
因此，大多数在运行程序时，您的计算机的内存被保留

623
00:39:12,210 --> 00:39:15,370
一些所谓的堆栈，称为堆的东西。

624
00:39:15,370 --> 00:39:18,840
我们不会谈论今天的堆，但我们将讨论有关堆栈。

625
00:39:18,840 --> 00:39:24,600
该协议栈是为了唤起了视觉的食堂餐托盘Mather中楼

626
00:39:24,600 --> 00:39:28,110
无论你发生的地方，食堂的工作人员清理他们的每一天，

627
00:39:28,110 --> 00:39:30,180
它们堆叠起来，从地板上起来，

628
00:39:30,180 --> 00:39:34,550
同样，在内存中，这种想法将在栈上的东西，

629
00:39:34,550 --> 00:39:36,860
把堆栈上的东西，将东西在栈上。

630
00:39:36,860 --> 00:39:38,240
是什么意思呢？

631
00:39:38,240 --> 00:39:41,860
>> 让我们放大只是这张照片的下半部分，您的计算机的RAM，

632
00:39:41,860 --> 00:39:44,330
提出以下建议。

633
00:39:44,330 --> 00:39:48,170
原来，当你运行一个程序，如a.out或你好 - 

634
00:39:48,170 --> 00:39:50,100
无论程序是你写的 - 

635
00:39:50,100 --> 00:39:54,020
再次，这些从您的硬盘驱动器，这是长期存储，加载“0”和“1”

636
00:39:54,020 --> 00:39:57,230
在那里停留，甚至当你拔出插头，加载到RAM中。

637
00:39:57,230 --> 00:40:00,610
RAM的速度比硬盘驱动器 - 它是小于硬盘驱动器 - 

638
00:40:00,610 --> 00:40:03,300
但它的节目直播，当你运行它们。

639
00:40:03,300 --> 00:40:08,230
所以，你双击一个Mac或PC上的程序，它的硬盘驱动器加载到RAM中。

640
00:40:08,230 --> 00:40:11,520
只要它加载到RAM中去的方式上，“0”和“1，

641
00:40:11,520 --> 00:40:16,610
所谓的文本段，但只要你的程序实际开始运行，

642
00:40:16,610 --> 00:40:21,360
的主要功能是打电话，主，正如我们已经看到的那样，经常有局部变量，

643
00:40:21,360 --> 00:40:24,870
它有整型和字符串和字符之类的。

644
00:40:24,870 --> 00:40:29,180
所以，如果你的程序，你写的程序，你已经双击

645
00:40:29,180 --> 00:40:32,970
使用的主要内部的一些变量，

646
00:40:32,970 --> 00:40:37,240
他们结束了在你的内存堆栈的底部，可以这么说。

647
00:40:37,240 --> 00:40:39,410
更具体地说，这究竟是什么意思？

648
00:40:39,410 --> 00:40:48,450
这也就意味着，如果我们要在您的计算机数量的字节RAM，

649
00:40:48,450 --> 00:40:55,750
注意到，这可能会对字节号0，字节数1，2，3，4，5，6，这可能会对

650
00:40:55,750 --> 00:41:01,480
一路攀升至2亿美元将一路攀升，在顶部。

651
00:41:01,480 --> 00:41:05,880
所以，换句话说，当我们谈论RAM或内存中的字节，

652
00:41:05,880 --> 00:41:11,500
它只是意味着有人已经决定什么号每个这些内存块。

653
00:41:11,500 --> 00:41:16,650
所以，当你需要32位的int或者您需要一个字符的8位，

654
00:41:16,650 --> 00:41:18,840
他们在哪里结束在内存中吗？

655
00:41:18,840 --> 00:41:22,350
>> 从概念上讲，他们刚刚结束了这个东西叫做堆栈的底部。

656
00:41:22,350 --> 00:41:25,870
但现在有什么有趣的是，当主调用一个函数 - 

657
00:41:25,870 --> 00:41:28,750
假设有一个名为foo的功能，只是一个任意的名称 - 

658
00:41:28,750 --> 00:41:32,330
会发生什么更主要的是在这个堆栈的内存的底部;

659
00:41:32,330 --> 00:41:35,680
美孚现在被放置在顶部的主内存中。

660
00:41:35,680 --> 00:41:40,990
因此，任何局部变量foo的结束排序的概念上高于主。

661
00:41:40,990 --> 00:41:47,070
如果foo调用另一个函数调用酒吧，这些变量在这里结束。

662
00:41:47,070 --> 00:41:50,120
如果酒吧调用别的东西，在这里，这里，这里。

663
00:41:50,120 --> 00:41:53,830
那么，在运行了一个程序很有意思的是，当你调用函数

664
00:41:53,830 --> 00:41:57,750
那些函数调用的函数，这些函数调用功能，

665
00:41:57,750 --> 00:42:01,470
你建立了这个堆栈在内存中的功能。

666
00:42:01,470 --> 00:42:06,890
而只有一个函数返回后，你开始，内存。

667
00:42:06,890 --> 00:42:10,860
因此，一个最简单的方法在计算机程序中运行的内存

668
00:42:10,860 --> 00:42:14,360
编写函数从不返回。

669
00:42:14,360 --> 00:42:18,900
因此，举例来说，让尽可能多的展示与故意错误的程序。

670
00:42:18,900 --> 00:42:22,230
让我继续做＃包括<stdio.h>的，

671
00:42:22,230 --> 00:42:25,000
诠释的主要（无效），

672
00:42:25,000 --> 00:42:32,940
，我该怎么办（2> 1），这可能会不会改变我们，

673
00:42:32,940 --> 00:42:37,560
让我继续做输出。

674
00:42:37,560 --> 00:42:40,700
事实上，这将是在视觉有趣的。让我们这样做。

675
00:42:40,700 --> 00:42:50,240
对于INT I = 0; I> 0  - 让我们犯这样的错误 - 我+ +。

676
00:42:50,240 --> 00:42:52,720
让我们在这里不是printf。我们的做法是我的说教。

677
00:42:52,720 --> 00:43:00,190
让我们有一个方法，在这里，无效合唱，我们会说INT I，

678
00:43:00,190 --> 00:43:06,830
然后我会说printf的 - 不，让我们使这更有趣。

679
00:43:06,830 --> 00:43:15,790
让实际不打印任何东西，在所有。让公司只是这样做：合唱（一）。

680
00:43:15,790 --> 00:43:20,390
好的。因此，这是越野车，因为为什么呢？

681
00:43:20,390 --> 00:43:23,380
我正在做这件事，因为我去，因为该计划实际上并没有做任何的兴趣。

682
00:43:23,380 --> 00:43:25,320
>> 但是，这不是目标。

683
00:43:25,320 --> 00:43:29,630
我们的目标是编写一个程序，做什么，显然，其主要功能？

684
00:43:30,720 --> 00:43:32,860
调用自身。实际上，我们并不需要循环。

685
00:43:32,860 --> 00:43:37,200
让我们甚至简化，从而不能忽视的真正的根本错误。

686
00:43:37,200 --> 00:43:39,640
主要调用合唱团唱一些合唱团，

687
00:43:39,640 --> 00:43:41,440
然后我做了一些愚蠢的事情，我不得不合唱团的呼叫合唱团

688
00:43:41,440 --> 00:43:43,760
因为我以为别人要实现它，也许，

689
00:43:43,760 --> 00:43:47,210
现在这是不会还来编译。我需要做什么？

690
00:43:47,210 --> 00:43:49,970
我需要的原型，记住了。

691
00:43:49,970 --> 00:43:56,110
所以我需要在这里无效合唱团（int i）的;

692
00:43:56,110 --> 00:43:59,210
所以，现在如果我去了 - 实际上，让我们用更大的窗口。

693
00:43:59,210 --> 00:44:01,980
让我们继续前进，并合唱。

694
00:44:01,980 --> 00:44:06,490
让我们继续前进，并合唱。

695
00:44:06,490 --> 00:44:08,370
使用未声明的标识符我。

696
00:44:08,370 --> 00:44:12,500
哦，那是愚蠢的。我们并不需要的参数。我们只要做到这一点。

697
00:44:12,500 --> 00:44:16,370
我想我们已经开始这样。这本来是一个更简单的程序编写。

698
00:44:16,370 --> 00:44:25,590
有。现在，让我们去到我的终端窗口，重新运行铛，在这里，我们走。

699
00:44:25,590 --> 00:44:28,460
这是真快。

700
00:44:28,460 --> 00:44:31,150
究竟刚发生时，有关系吗？

701
00:44:31,150 --> 00:44:33,730
好了，现在我将添加打印线，这样我们就可以看到。

702
00:44:33,730 --> 00:44:43,490
让我说printf（“请我在这里”） - 不变量。我们会留下这样说。

703
00:44:43,490 --> 00:44:47,480
让我重新运行。让我重新运行合唱团。

704
00:44:47,480 --> 00:44:57,380
而且......来。继续下去。

705
00:44:57,380 --> 00:44:59,930
顺便说一句，为什么它没有崩溃吗？

706
00:44:59,930 --> 00:45:02,080
分割故障发生前超级快。

707
00:45:02,080 --> 00:45:06,570
[听不见的学生回应] >>没错。因此，需要一定的时间进行打印，对不对？

708
00:45:06,570 --> 00:45:08,610
它只是需要更多的工作在计算机的一部分。

709
00:45:08,610 --> 00:45:10,620
还有，它是：分割故障。

710
00:45:10,620 --> 00:45:12,340
>> 因此，发现是多么快的程序运行。

711
00:45:12,340 --> 00:45:14,130
如果你没有打印任何东西，超级快。

712
00:45:14,130 --> 00:45:18,770
但是，我们仍然得到了该段故障，因为发生了什么事？

713
00:45:18,770 --> 00:45:21,210
如果你仔细想想你的计算机的内存中的布局如何，

714
00:45:21,210 --> 00:45:28,740
这恰好是主要的，但在这里，我们只需要调用这个合唱，让我们这个合唱团。

715
00:45:28,740 --> 00:45:34,550
现在，如果我做我的美学，这只是要说的合唱团，合唱团，合唱团，

716
00:45:34,550 --> 00:45:40,550
合唱团，合唱团，合唱团，合唱团，广告不厌其烦，最终会发生什么？

717
00:45:40,550 --> 00:45:45,630
如果大的画面，从字面上看，是这样的，这是发生在概念上吗？

718
00:45:46,520 --> 00:45:48,630
该协议栈溢出堆。

719
00:45:48,630 --> 00:45:51,940
或者，更糟糕的是，你只是溢出的一切，包括文本段，

720
00:45:51,940 --> 00:45:54,590
这是“0”和“1”，代表你的程序。

721
00:45:54,590 --> 00:45:57,080
总之，这仅仅是超级，超级坏。

722
00:45:57,080 --> 00:45:58,830
你的程序已失去控制。

723
00:45:58,830 --> 00:46:01,220
您使用的是比你预期的方式更多的内存

724
00:46:01,220 --> 00:46:03,960
因为一个愚蠢的错误，在这种情况下，

725
00:46:03,960 --> 00:46:08,040
在这种情况下，故意做函数调用本身。

726
00:46:08,040 --> 00:46:09,500
现在，这并不全是坏事。

727
00:46:09,500 --> 00:46:13,800
调用自己的函数实际上有很大的权力，当你正确地使用它。

728
00:46:13,800 --> 00:46:15,800
我还没有正确地使用它在这里。

729
00:46:15,800 --> 00:46:19,780
因此，这并不全是坏事，但事实上，我从来没有真正停止称自己

730
00:46:19,780 --> 00:46:23,520
这个方案是一个根本的弱点在这里。

731
00:46:23,520 --> 00:46:26,400
那么，我们要与所有这一切吗？到底发生了什么？

732
00:46:26,400 --> 00:46:30,340
当我打电话的增值功能，如在那些例子中，我们正在做，

733
00:46:30,340 --> 00:46:33,420
我有一个值，如1，我传进去

734
00:46:33,420 --> 00:46:37,570
我通过在1号的副本，所以发生以下情况。

735
00:46:37,570 --> 00:46:44,240
让我们进入增量的例子，这家伙就在这里。

736
00:46:44,240 --> 00:46:46,870
下面是实际发生的事情。

737
00:46:46,870 --> 00:46:53,400
当我打电话的增量，和我通过在x，形象地，在这里发生了什么事情是这样的。

738
00:46:53,400 --> 00:46:59,520
>> 如果我有1的值存储在这里和其实我打电话增量，

739
00:46:59,520 --> 00:47:04,330
现在被称为合唱团 -  iPad是扔我在这里下车。

740
00:47:04,330 --> 00:47:09,760
让我们把这个增量，我们不知道这是什么功能将是。

741
00:47:09,760 --> 00:47:14,840
因此，实际发生的是这里的某个地方主要我有一个内存块，

742
00:47:14,840 --> 00:47:17,000
存储数字1。

743
00:47:17,000 --> 00:47:19,380
当我打电话给增量，我使用其他的内存块，

744
00:47:19,380 --> 00:47:21,230
但现在我有副本1。

745
00:47:21,230 --> 00:47:26,660
当我增加值，这将成为2

746
00:47:26,660 --> 00:47:30,560
但后来发生了什么，尽快增加收益？

747
00:47:30,560 --> 00:47:33,630
内存只是被交还给操作系统，

748
00:47:33,630 --> 00:47:37,450
这意味着你所做的一切是没有什么用处的。

749
00:47:37,450 --> 00:47:43,120
1，最初是包含在主实际上仍然存在。

750
00:47:43,120 --> 00:47:44,890
所以，我们要这个吗？

751
00:47:44,890 --> 00:47:49,770
事实证明，在内存中，你有这回的字节序列

752
00:47:49,770 --> 00:47:53,050
你可以把东西，事实证明，我们已经看到的东西

753
00:47:53,050 --> 00:47:55,390
把事情背靠背背靠背。

754
00:47:55,390 --> 00:47:59,860
什么是基于字符串的第1周，现在2周？

755
00:48:00,020 --> 00:48:01,980
这只是一个字符集合。

756
00:48:01,980 --> 00:48:04,310
所以，就像你可以把号码在内存中，

757
00:48:04,310 --> 00:48:06,990
同样，你可以把字符在内存中。

758
00:48:06,990 --> 00:48:10,530
一旦我们开始把字符在内存中背靠背背靠背，

759
00:48:10,530 --> 00:48:13,620
事实证明，用最简单的事情，比如一个for循环或while循环，

760
00:48:13,620 --> 00:48:17,170
我们可以遍历一个字符串中的字符从左至右

761
00:48:17,170 --> 00:48:20,600
并开始按摩完全不同的字符 - 

762
00:48:20,600 --> 00:48:23,370
一个可能成为B，B可能成为C  - 

763
00:48:23,370 --> 00:48:27,780
所以，归根结底，我们可以采取一个英语句子，其实是有道理的

764
00:48:27,780 --> 00:48:30,310
和转换每个那些字母1在一个时间

765
00:48:30,310 --> 00:48:34,400
通过步行通过我们的计算机的内存中，左到右，实际上是加密。

766
00:48:34,400 --> 00:48:35,810
因此，让我们在这里把我们五分钟的休息时间，

767
00:48:35,810 --> 00:48:40,730
当我们回来时，我们将启动这一进程的扰码信息。

768
00:48:42,020 --> 00:48:43,520
>> 好的。

769
00:48:43,520 --> 00:48:48,070
在我们深入到一些加密，这些东西称为“阵列”，

770
00:48:48,070 --> 00:48:51,470
有任何问题，让我停下来，因为我觉得我是那种混乱的

771
00:48:51,470 --> 00:48:54,080
一些主题。所以现在，如果我们可以让我们来解决。

772
00:48:54,080 --> 00:48:58,700
我们刚才谈到的返回值，我们谈论的参数，

773
00:48:58,700 --> 00:49:03,250
我们谈到这个概念，我们会回来的几个星期来，

774
00:49:03,250 --> 00:49:08,720
查看内存一大堆的这些堆叠托盘，可以这么说，

775
00:49:08,720 --> 00:49:12,660
从底部起来，这样会在栈上，每个托盘

776
00:49:12,660 --> 00:49:16,530
这是目前被称为代表一个函数。

777
00:49:17,900 --> 00:49:20,260
有什么问题吗？

778
00:49:20,260 --> 00:49:22,640
让我在这里问一个问题。

779
00:49:22,640 --> 00:49:27,890
让我简化这回它是什么之前，我们早期的Q＆A.

780
00:49:27,890 --> 00:49:35,570
事实上，增加开括号，整型数，封闭括号 - 

781
00:49:35,570 --> 00:49:39,110
整数数字代表什么？

782
00:49:39,110 --> 00:49:42,790
[学生]的说法。 >>的说法。好吧。但是，什么是参数？

783
00:49:42,790 --> 00:49:46,370
[听不见的学生回应] >>那是什么？ >> [学生]：这件事你传入

784
00:49:46,370 --> 00:49:49,940
好了，这样的东西，你传进去，更普遍的是，这仅仅是输入。

785
00:49:49,940 --> 00:49:52,450
如果你正在写一个函数，该函数的目的在生活中

786
00:49:52,450 --> 00:49:55,770
是做的东西有点不同，每次你使用它，

787
00:49:55,770 --> 00:50:00,110
要做到这一点真的那么唯一的办法似乎是为它提供输入

788
00:50:00,110 --> 00:50:03,510
因此，它可以做不同的事情，每次输入。

789
00:50:03,510 --> 00:50:06,650
>> 所以，你需要指定两件事情，当一个函数需要输入。

790
00:50:06,650 --> 00:50:09,590
您需要指定的名称，你想给的输入

791
00:50:09,590 --> 00:50:12,700
纯粹是为了自己的方便，使您可以参考

792
00:50:12,700 --> 00:50:16,540
在功能，你写，我在这里的第32行。

793
00:50:16,540 --> 00:50:20,800
但是，你还需要指定它的类型，因为C是一种编程语言

794
00:50:20,800 --> 00:50:25,940
只需要，如果你想要一个变量，你必须告诉计算机它是什么样的数据类型，

795
00:50:25,940 --> 00:50:30,200
在很大程度上，所以它知道有多少位分配给该变量

796
00:50:30,200 --> 00:50:33,020
因为它可能是6  - 对不起，不会是6。

797
00:50:33,020 --> 00:50:37,080
它也可以是16，它可以是8，它可以是32，甚至64，

798
00:50:37,080 --> 00:50:39,130
但电脑需要知道的。

799
00:50:39,130 --> 00:50:43,180
现在，在左手侧的int代表什么，相比之下？

800
00:50:46,350 --> 00:50:48,850
[听不见的学生回应] >>那是什么？ >> [学生]类型的功能。

801
00:50:48,850 --> 00:50:53,610
一个函数的类型，并且更具体的是，它的输出的类型。右。

802
00:50:53,610 --> 00:50:57,380
因此，而括号中的东西代表的输入，如果有的话，

803
00:50:57,380 --> 00:50:59,660
到左的东西它的输出。

804
00:50:59,660 --> 00:51:03,530
在这种情况下，增量显然是返回一个int，

805
00:51:03,530 --> 00:51:07,690
所以int是这个函数的返回类型。

806
00:51:07,690 --> 00:51:09,340
要返回的是什么意思？

807
00:51:09,340 --> 00:51:15,090
从字面上看，您可以使用关键字return，然后如果你正在返回

808
00:51:15,090 --> 00:51:18,600
关键字右侧的是一个整数，

809
00:51:18,600 --> 00:51:21,660
这确实是符合我们所承诺的。

810
00:51:21,660 --> 00:51:26,410
你不能做这样的事情 - 你好，世界 - 因为这是一个字符串。

811
00:51:26,410 --> 00:51:28,860
>> 显然，这是不是一个整数。

812
00:51:28,860 --> 00:51:33,140
因此，在短，真的是对我们的负担，程序员，要具体

813
00:51:33,140 --> 00:51:37,770
我们回国，然后返回。

814
00:51:37,770 --> 00:51:43,440
这里的背景是，现在你的电脑的内存是技嘉，2 GB的 - 

815
00:51:43,440 --> 00:51:45,920
什么 - 也许是更重要的，也许是少了，

816
00:51:45,920 --> 00:51:49,050
但电脑的看法有不同的部分。

817
00:51:49,050 --> 00:51:51,200
出现在那里，别的东西在那里，

818
00:51:51,200 --> 00:51:54,290
不同的东西在中间，今天我们刚开始讲的故事，

819
00:51:54,290 --> 00:51:56,340
但我们会回来到这个随着时间的推移。

820
00:51:56,340 --> 00:51:59,980
现在，唯一的一块内存中，我们真正关心的是文本段

821
00:51:59,980 --> 00:52:03,360
因为这只是代表了0和1铛输出。

822
00:52:03,360 --> 00:52:06,050
所以，当你运行一个命令在键盘上一样的a.out

823
00:52:06,050 --> 00:52:09,110
你双击一个图标在Mac OS或Windows，

824
00:52:09,110 --> 00:52:11,880
从您的硬盘驱动器程序被加载到RAM

825
00:52:11,880 --> 00:52:16,330
它的屁股在您的计算机的RAM的顶部，可以这么说。

826
00:52:16,330 --> 00:52:20,450
同时，为您的程序开始运行，并主要被调用

827
00:52:20,450 --> 00:52:23,640
在你的程序写或写的程序微软和苹果，

828
00:52:23,640 --> 00:52:27,860
任何局部变量结束了在那里降落的底部，您的计算机的内存中。

829
00:52:27,860 --> 00:52:33,230
但是，如果本身有变量或参数主要调用另一个函数，他们结束了在它的上面。

830
00:52:33,230 --> 00:52:36,680
如果该函数调用的东西，他们结束了在它上面，在它上面，在它的上面。

831
00:52:36,680 --> 00:52:41,460
>> 只有一次函数完成执行，托盘堆叠，可以这么说，

832
00:52:41,460 --> 00:52:43,240
开始越来越低。

833
00:52:43,240 --> 00:52:48,250
这是什么话，概括地说，解释了为什么当你调用立方体

834
00:52:48,250 --> 00:52:51,550
还是你打的增量，你在副本的价值传递。

835
00:52:51,550 --> 00:52:55,520
是什么意思形象地是，你从字面上写数字1

836
00:52:55,520 --> 00:53:00,460
的存储器的另一部分中，改变一个1至2中的情况下，增量

837
00:53:00,460 --> 00:53:04,820
或8在多维数据集的情况下，然后投掷该内存

838
00:53:04,820 --> 00:53:09,140
只要增量或多维数据集函数返回。问题。

839
00:53:09,140 --> 00:53:12,900
[学生]：全局变量存储在哪里？

840
00:53:12,900 --> 00:53:18,100
现称为初始化的数据或者未初始化的数据都存储在全局变量，

841
00:53:18,100 --> 00:53:21,920
区别在于，如果你有一个全局变量，并为它指定一个值就

842
00:53:21,920 --> 00:53:24,640
与等号，它结束了在顶部有，

843
00:53:24,640 --> 00:53:29,200
，如果你只是说诠释x;没有价值，最终小幅低RAM

844
00:53:29,200 --> 00:53:31,710
简单的约定。

845
00:53:31,710 --> 00:53:34,940
其他问题吗？好的。

846
00:53:34,940 --> 00:53:37,340
因此，这幅画会回来的，因为我们获得更强大

847
00:53:37,340 --> 00:53:39,170
我们能做些什么与电脑，

848
00:53:39,170 --> 00:53:42,720
但现在，让我们有一个简短的介绍了密码学，

849
00:53:42,720 --> 00:53:46,080
特定类型的加密技术并没有解决所有的世界问题的

850
00:53:46,080 --> 00:53:47,720
但不解决其中的一些。

851
00:53:47,720 --> 00:53:51,700
在这种情况下，在这里，我们有一些所谓的密钥加密。

852
00:53:51,700 --> 00:53:56,410
密钥加密，顾名思义，源于它从一个秘密的安全。

853
00:53:56,410 --> 00:54:00,690
>> 例如，如果你是在小学和你是通过一个小秘密情书

854
00:54:00,690 --> 00:54:04,850
男孩或女孩，你被粉碎，如果你想通过贯穿全场的注意，

855
00:54:04,850 --> 00:54:08,380
你可能不会写英语中的注释，或任何你的母语是。

856
00:54:08,380 --> 00:54:13,340
相反，你可能会对其进行加密，或者您可能只是给他们一个文本消息，这些天。

857
00:54:13,340 --> 00:54:15,460
但你实际上可能会通过他们在教室。

858
00:54:15,460 --> 00:54:18,700
而要做到这以这样的方式安全地，您的朋友和老师

859
00:54:18,700 --> 00:54:22,650
不知道你写的东西，你可能会想出一个相当简单的算法，

860
00:54:22,650 --> 00:54:25,920
年轻，当然，你可能只是争夺的话。

861
00:54:25,920 --> 00:54:28,130
因此，而不是写一个你可能会写，

862
00:54:28,130 --> 00:54:30,220
而不是B，你可能会写，

863
00:54:30,220 --> 00:54:32,140
，而不是C，你可能会写D，等等。

864
00:54:32,140 --> 00:54:34,360
或者，你能想出一个更复杂的翻译

865
00:54:34,360 --> 00:54:36,720
不同的字母字母。

866
00:54:36,720 --> 00:54:39,740
但美中不足的是男孩还是女孩，你发送此说明

867
00:54:39,740 --> 00:54:45,020
需要知道的东西，这是什么，很明显吗？ >> [学生]：您所发送的。

868
00:54:45,020 --> 00:54:49,720
你的秘诀是什么，喜欢什么是A和B的和C和D的之间的映射。

869
00:54:49,720 --> 00:54:54,650
难道仅仅是加1，每个字母从A到B，从B到C的吗？

870
00:54:54,650 --> 00:54:56,670
它是比这更复杂吗？

871
00:54:56,670 --> 00:55:01,540
>> 所以，你和你的美眉需要有这样的秘密信息，

872
00:55:01,540 --> 00:55:03,190
但有一个catch-22在这里种。

873
00:55:03,190 --> 00:55:06,830
如果这是第一次，你通过类，这封情书

874
00:55:06,830 --> 00:55:10,720
的是男孩还是女孩是如何知道的秘密，即使是吗？

875
00:55:10,720 --> 00:55:13,930
所以密钥加密并不能解决世界上所有的问题，

876
00:55:13,930 --> 00:55:16,320
有实际上是一个关系在这里，我们再回过头来朝学期的结束。

877
00:55:16,320 --> 00:55:25,110
同样我们大多数人不知道别人的作品，例如，在Amazon.com，

878
00:55:25,110 --> 00:55:28,190
，但我们很多人可能买的东西在Amazon.com，

879
00:55:28,190 --> 00:55:31,990
我们一直被教导要承担这些电子商务交易的安全性。

880
00:55:31,990 --> 00:55:36,470
HTTPS URL可能说，有可能是愚蠢的小挂锁图标的地方，

881
00:55:36,470 --> 00:55:39,930
有某种形式的加密技术保护您的信用卡信息

882
00:55:39,930 --> 00:55:42,160
你和亚马逊（Amazon.com）之间。

883
00:55:42,160 --> 00:55:45,430
但如果密码学需要知道一些秘密

884
00:55:45,430 --> 00:55:48,620
，但我不知道在亚马逊的人，我当然没有安排什么样的秘密

885
00:55:48,620 --> 00:55:52,710
与亚马逊的人，怎么会是我的电脑或浏览器这样做吗？

886
00:55:52,710 --> 00:55:55,720
事实证明，有其他类型的加密技术完全解决这个问题。

887
00:55:55,720 --> 00:55:57,670
但是今天，我们将重点放在简单的一

888
00:55:57,670 --> 00:56:00,290
在这里，你可以安排提前知道一些秘密

889
00:56:00,290 --> 00:56:03,760
如+1或一些A和B之间的映射。

890
00:56:03,760 --> 00:56:05,840
和加密过程一般涉及这一点。

891
00:56:05,840 --> 00:56:08,620
你有一些简单的文字，描绘在左，

892
00:56:08,620 --> 00:56:12,930
你运行它通过某种算法或过程进行加密 - 

893
00:56:12,930 --> 00:56:15,100
也许这只是一个变成B，B变成C  - 

894
00:56:15,100 --> 00:56:17,490
那么你最终的密文。

895
00:56:17,490 --> 00:56:20,380
同时，一旦你的美眉接收这个秘密纸条，

896
00:56:20,380 --> 00:56:24,200
他或她，然后将其解密一般扭转这一算法

897
00:56:24,200 --> 00:56:27,190
这样才能得到纯文本。

898
00:56:27,190 --> 00:56:28,960
有物理的化身。

899
00:56:28,960 --> 00:56:31,680
>> 举例来说，这是一个小秘密的解码器环，

900
00:56:31,680 --> 00:56:35,110
这是在这个意义上，在这里两个表盘的环。

901
00:56:35,110 --> 00:56:38,490
在这件事情的外周，有字母A到Z，

902
00:56:38,490 --> 00:56:40,340
虽然他们在随机的顺序，

903
00:56:40,340 --> 00:56:42,880
在里面，其实有一些数字

904
00:56:42,880 --> 00:56:46,620
这样，这个戒指，你可以种翻在外面，但不是内

905
00:56:46,620 --> 00:56:49,140
在排队的数字与字母。

906
00:56:49,140 --> 00:56:53,020
从一部电影叫圣诞故事，你会看到那个小拉尔夫

907
00:56:53,020 --> 00:56:58,000
要弄清楚什么小孤儿安妮的秘密消息是他是如此渴望

908
00:56:58,000 --> 00:57:02,570
已沟通，我认为，在麦片盒上的数字信息的形式

909
00:57:02,570 --> 00:57:07,220
你有积聚的麦片盒中附带的小卡片，

910
00:57:07,220 --> 00:57:09,770
你不得不将它们邮寄中，你必须回到秘密的解码器环

911
00:57:09,770 --> 00:57:13,910
所以，你终于可以弄清楚什么是字母和数字之间的映射

912
00:57:13,910 --> 00:57:15,550
或字母和字母。

913
00:57:15,550 --> 00:57:19,520
如何在一台计算机实施或代表这样的事情，我们可以去吗？

914
00:57:19,520 --> 00:57:22,560
我们需要一种方式表达自己一点更灵活

915
00:57:22,560 --> 00:57:25,080
因此，我们的变量不允许的。

916
00:57:25,080 --> 00:57:29,000
我们已经有整数，我们有个字符，我们已经有花车和双打和其他几个人，

917
00:57:29,000 --> 00:57:34,200
但这些都是个人的内存并不真正允许我们表达的东西

918
00:57:34,200 --> 00:57:36,440
如单词和句子和短语。

919
00:57:36,440 --> 00:57:38,630
事实上，我们称这样的事情串，

920
00:57:38,630 --> 00:57:42,660
但我们保证这是真的只是一个简化的CS50库中

921
00:57:42,660 --> 00:57:45,540
我们打​​算剥离。

922
00:57:45,540 --> 00:57:47,500
让我们开始做，在这里。

923
00:57:47,500 --> 00:57:49,840
让我继续前进，打开一个文件 - 

924
00:57:49,840 --> 00:57:54,100
所有这些文件，像往常一样，在线 - 所谓的array.c的

925
00:57:54,100 --> 00:57:58,960
要解决的问题无关字符串，但在这里描绘了

926
00:57:58,960 --> 00:58:01,520
怎么样，我们可能会使用称为数组的东西。

927
00:58:01,520 --> 00:58:04,050
>> 数组是一种数据类型。

928
00:58:04,050 --> 00:58:10,730
这是一个类型的变量有多个较小的数据类型，它里面的各种

929
00:58:10,730 --> 00:58:12,680
背靠背背靠背。

930
00:58:12,680 --> 00:58:16,980
因此，举例来说，如果我们想要写一个小程序，让你的测验平均

931
00:58:16,980 --> 00:58:19,780
像50，有2个测验为一疗程，

932
00:58:19,780 --> 00:58:23,450
你可以很容易地编写这个程序，即使在上周的一些材料

933
00:58:23,450 --> 00:58:28,830
通过调用getInt和一对夫妇的变量：quiz1，quiz2。

934
00:58:28,830 --> 00:58:30,550
这是很简单的。

935
00:58:30,550 --> 00:58:33,500
这也许是10，20行的代码最大的实施方案

936
00:58:33,500 --> 00:58:38,940
，要求用户为2个测验分数，然后计算它们的平均

937
00:58:38,940 --> 00:58:42,020
通过将它们添加在一起，除以2，然后打印结果。

938
00:58:42,020 --> 00:58:46,400
我们或许可以做到这一点很容易现在后一些的分钟数。

939
00:58:46,400 --> 00:58:49,450
但问题是，假设50 3测验或4。

940
00:58:49,450 --> 00:58:52,830
假设你想使用相同的程序为一类，每周测验。

941
00:58:52,830 --> 00:58:55,100
想想一个类时，每周测验。

942
00:58:55,100 --> 00:58:58,840
如果在一个学期有16周了，现在你有16个变量：

943
00:58:58,840 --> 00:59:03,030
quiz1，诠释quiz2，诠释第quiz3，诠释quiz4。

944
00:59:03,030 --> 00:59:06,870
只要你开始看到这种冗余，复制和粘贴的代码，

945
00:59:06,870 --> 00:59:09,810
它应该开始让你希望有一个更好的办法。

946
00:59:09,810 --> 00:59:13,610
幸运的是，因为数组。因此，让我们做到这一点。

947
00:59:13,610 --> 00:59:16,700
首先，让我介绍一个非常简单的事情，我们到目前为止还没有使用，

948
00:59:16,700 --> 00:59:18,820
但偶尔你会看到它的代码。

949
00:59:18,820 --> 00:59:21,270
>> 这就是通常被称为一个常数。

950
00:59:21,270 --> 00:59:24,410
所以在这个意义上，这个值不会改变，它是一个常数。

951
00:59:24,410 --> 00:59:26,450
人的惯例，当创建一个常数

952
00:59:26,450 --> 00:59:30,420
是全部使用大写字母，使其真正站出来，在你的代码，

953
00:59:30,420 --> 00:59:34,270
特殊的关键字，您使用的C＃定义。

954
00:59:34,270 --> 00:59:39,970
所以我们说的＃define，然后一个空格，然后这个词，您要使用的常量的名称

955
00:59:39,970 --> 00:59:41,730
，然后该值的常数。

956
00:59:41,730 --> 00:59:44,710
请注意，这是一个变量分配的东西不同。

957
00:59:44,710 --> 00:59:46,430
有没有等号，别无分号。

958
00:59:46,430 --> 00:59:49,140
这是通常被称为一个预处理器指令，

959
00:59:49,140 --> 00:59:50,840
但更多的是另一个时间。

960
00:59:50,840 --> 00:59:56,350
就目前而言，这将创建一个不变的值，称为测验

961
00:59:56,350 --> 00:59:58,290
其实际的数值为2。

962
00:59:58,290 --> 01:00:02,180
因此，任何地方，你看到测验，测验，测验整个文件，

963
01:00:02,180 --> 01:00:04,230
这只是数字2。

964
01:00:04,230 --> 01:00:06,550
如果我看主要现在，让我们来看看它是如何工作的。

965
01:00:06,550 --> 01:00:09,770
首先，它看起来有点神秘，但它的所有东西，从第1周。

966
01:00:09,770 --> 01:00:12,210
询问用户的等级。如何才能做到这一点呢？

967
01:00:12,210 --> 01:00:17,350
第22行 - 这是真正的多汁的一部分 - 我声明了一个浮动

968
01:00:17,350 --> 01:00:23,240
但不只是一个单一的浮动。我声明，而是一个浮点值数组。

969
01:00:23,240 --> 01:00:27,700
该变量将被称为等级，此处所暗示的，

970
01:00:27,700 --> 01:00:31,420
但唯一的一块新的语法，那么这些方括号。

971
01:00:31,420 --> 01:00:37,280
事实上，我已经说过了浮动等级，然后打开支架，然后一个数字 - 

972
01:00:37,280 --> 01:00:40,980
请注意，如果这是一个常数，这仅仅是像我们这样做 - 

973
01:00:40,980 --> 01:00:46,840
这意味着，“嘿，电脑，给我2漂浮，让我们共同给他们打电话等级。”

974
01:00:46,840 --> 01:00:51,780
>> 这是更繁琐的过程是这样的：浮法级1;

975
01:00:51,780 --> 01:00:54,580
浮动grade2等等。

976
01:00:54,580 --> 01:00:58,310
因此，一个阵列，使我们能够实现这个想法，但要少得多乱七八糟，

977
01:00:58,310 --> 01:01:04,560
在这样一种方式，我们可以写一行代码，而不是，比方说，16为期16周的学期。

978
01:01:04,560 --> 01:01:09,060
我不想硬编码到2，因为如果你觉得这个逻辑，

979
01:01:09,060 --> 01:01:12,560
假设明年CS50更改为3，而不是测验

980
01:01:12,560 --> 01:01:15,010
我有2号，在这里，我有2号

981
01:01:15,010 --> 01:01:17,210
我有这里的数量2，数字2这里。

982
01:01:17,210 --> 01:01:19,890
它变得非常乏味，很容易搞砸了

983
01:01:19,890 --> 01:01:26,550
意外更改值设置为3，错过了一些其他值2。

984
01:01:26,550 --> 01:01:30,660
所以我要这个距离，而不是抽象的和使用这个常数，

985
01:01:30,660 --> 01:01:32,520
正如它的名字所暗示的，永远不会改变。

986
01:01:32,520 --> 01:01:35,870
现在，无论我们有不同的测验今年年底或明年，

987
01:01:35,870 --> 01:01:39,380
我只需要改变它在一个地方，在这里顶部。

988
01:01:39,380 --> 01:01:41,230
所以这是一个常数。

989
01:01:41,230 --> 01:01:47,100
同时，新概念的特点是一个数组。

990
01:01:47,100 --> 01:01:55,030
因此，在方括号给我这么多的花车，让我共同呼吁他们的成绩。

991
01:01:55,030 --> 01:01:56,720
所以，现在让我们来看看我会做什么。

992
01:01:56,720 --> 01:01:59,220
在这里，在第24行是一个for循环的开始。

993
01:01:59,220 --> 01:02:03,380
>> 这实在是没有任何幻想。这只是使用测验，而不是硬编码的数字。

994
01:02:03,380 --> 01:02:06,740
但也有是没有从上周智力有不同的。

995
01:02:06,740 --> 01:02:11,650
这仅仅是printf的，因此我们知道printf（“测验＃％d的％d”）

996
01:02:11,650 --> 01:02:16,670
因为我只是想打印出来给我测验第1号和2 2。

997
01:02:16,670 --> 01:02:18,480
因此，这是一个纯粹审美的东西。

998
01:02:18,480 --> 01:02:21,000
但是，现在最有趣的部分是在第27行。

999
01:02:21,000 --> 01:02:27,840
为了填补的两个占位符，一个浮点值，

1000
01:02:27,840 --> 01:02:29,640
你再使用方括号。

1001
01:02:29,640 --> 01:02:35,170
在这种情况下，我使用的是我，因为for循环已开始与我等于什么样的价值，显然是吗？

1002
01:02:35,170 --> 01:02:36,670
[学生] 0。 >> [马兰] 0。

1003
01:02:36,670 --> 01:02:40,990
因此，在这个循环的第一次迭代，这是我写的代码，

1004
01:02:40,990 --> 01:02:46,310
但在这个循环中的第二次迭代，这是我写在我的代码。

1005
01:02:46,310 --> 01:02:49,970
但事实上，我使用一个变量是完美的，因为顾名思义，

1006
01:02:49,970 --> 01:02:52,600
它改变它的值在每次迭代，

1007
01:02:52,600 --> 01:02:55,900
所以我填充这个数组一个地方的时间。

1008
01:02:55,900 --> 01:02:57,380
阵列看看这是什么样的呢？

1009
01:02:57,380 --> 01:03:01,570
我画的超级简单的屏幕上的矩形前的原因是因为这个原因。

1010
01:03:01,570 --> 01:03:05,590
数组是另一块内存的内存块

1011
01:03:05,590 --> 01:03:08,570
其次由另一个的内存块，等等。

1012
01:03:08,570 --> 01:03:13,120
所以，如果我的数组大小为2，在这种情况下，在这里，我会做

1013
01:03:13,120 --> 01:03:20,200
通过输入我的测验分数，喜欢上了这里 - 我就这一个，然后我得到了99这个 - 

1014
01:03:20,200 --> 01:03:24,970
那么这个内存可能甚至没有被使用，因为我只要求电脑

1015
01:03:24,970 --> 01:03:26,840
数组大小为2。

1016
01:03:26,840 --> 01:03:28,600
这些广场仍然存在，对吗？

1017
01:03:28,600 --> 01:03:32,670
你还有2 GB的RAM，即使你只要求2漂浮。

1018
01:03:32,670 --> 01:03:36,840
因此，阵列背后的想法是，计算机只需要一个内存块的

1019
01:03:36,840 --> 01:03:41,340
然后分给更小的碎片背靠背背靠背。

1020
01:03:41,340 --> 01:03:43,310
因此，这是所有的数组。

1021
01:03:43,310 --> 01:03:47,350
>> 这是一个连续的块的内存里面的，你可以把事情。

1022
01:03:47,350 --> 01:03:50,700
发生这种情况，然后做一些无聊的算术。

1023
01:03:50,700 --> 01:03:54,640
如果我向下滚动在这里，这是我然后遍历数组中。

1024
01:03:54,640 --> 01:03:58,020
我拿出所有的数组中的值的总和，

1025
01:03:58,020 --> 01:04:02,470
然后，我在这里使用ROUND函数的总和除以测验。

1026
01:04:02,470 --> 01:04:06,320
但是，让我挥挥手，作为足够的算术现在的排序。

1027
01:04:06,320 --> 01:04:08,370
但是，所有为我做的最终计算平均值。

1028
01:04:08,370 --> 01:04:13,580
因此，第一次测验加第二个测验除以2，然后把它打印出来作为一个int。

1029
01:04:13,580 --> 01:04:17,280
但现在，让我们叫字符串转换到一个不同的例子，

1030
01:04:17,280 --> 01:04:20,700
它描绘了一个类似的画面，但使用​​字符串。

1031
01:04:20,700 --> 01:04:23,940
让我继续前进，简化这只是一个瞬间。

1032
01:04:23,940 --> 01:04:27,090
现在原谅缩进。

1033
01:04:27,090 --> 01:04:30,870
请注意，在这个例子中的第19行，我收到了来自用户的字符串。

1034
01:04:30,870 --> 01:04:34,640
但是请注意，我在22日线下做。

1035
01:04:34,640 --> 01:04:41,250
实际上，我遍历从我 - 这是一个新的绝招 -  STRLEN，字符串的长度。

1036
01:04:41,250 --> 01:04:44,880
这是一个与C的功能，如果你传递一个字符串，

1037
01:04:44,880 --> 01:04:47,730
它会告诉你如何在该字符串中的字符数。这就是全部。

1038
01:04:47,730 --> 01:04:51,550
而事实上，它是strlen的，而不是字符串的长度，仅仅是因为它更简洁。

1039
01:04:51,550 --> 01:04:55,100
30年前，人们喜欢写东西尽量简洁，

1040
01:04:55,100 --> 01:04:57,630
所以在这里，我们已经把该公约。

1041
01:04:57,630 --> 01:05:00,660
我+ +只是意味着我在每次迭代中增加。

1042
01:05:00,660 --> 01:05:02,990
而现在注意到这一点，这是非常有趣的。

1043
01:05:02,990 --> 01:05:09,180
在第24行，我说，“电脑，给我一个字符，8位，并称之为C”。

1044
01:05:09,180 --> 01:05:12,630
不过这到底是上右手边说？

1045
01:05:13,490 --> 01:05:16,530
在英语中，什么代表什么呢？

1046
01:05:16,530 --> 01:05:18,730
[学生]数组中的第一个字符。

1047
01:05:18,730 --> 01:05:20,790
没错。给我的第一个字符数组中的。

1048
01:05:20,790 --> 01:05:24,090
或者，更一般地，给我在数组中的第i个字符。

1049
01:05:24,090 --> 01:05:26,100
而意识到这一点是很重要的，现在的计算机科学家，

1050
01:05:26,100 --> 01:05:27,890
我们实际上是从0开始计数。

1051
01:05:27,890 --> 01:05:29,720
>> 您没有自由裁量权，现在就开始这样做。

1052
01:05:29,720 --> 01:05:34,160
现在，你必须按照电脑的期望的行为，从0数

1053
01:05:34,160 --> 01:05:38,180
因为[0]将是第一个字符在字符串中，

1054
01:05:38,180 --> 01:05:42,150
[1]将是第二个，[2]，将是第三个，等等。

1055
01:05:42,150 --> 01:05:49,720
所以这个程序，如果我编译它，这又是字符串，所以字符串，

1056
01:05:49,720 --> 01:05:54,670
现在我已经在我的终端窗口中执行字符串。

1057
01:05:54,670 --> 01:05:58,330
它在等待输入，所以我要输入大卫，输入，

1058
01:05:58,330 --> 01:06:02,540
现在它打印通知大卫在不同线路上，因为我在做什么。

1059
01:06:02,540 --> 01:06:05,820
我一次打印一个字符。

1060
01:06:05,820 --> 01:06:10,100
我们不会详细进入今天这个，但我删除刚才在这里检查。

1061
01:06:10,100 --> 01:06:15,480
事实证明，如果用户出现异常的，对抗性的，或只是困惑，

1062
01:06:15,480 --> 01:06:20,210
实际上，你可以不给一些长度字符串。

1063
01:06:20,210 --> 01:06:22,860
如果你按错键盘上的键，你可以给没有在所有的字符串，

1064
01:06:22,860 --> 01:06:26,950
如果你是恶意的，你可以尝试将其粘贴在一千兆字节的一篇文章的价值

1065
01:06:26,950 --> 01:06:29,290
来填补这个字符串，如果计算机运行的内存，

1066
01:06:29,290 --> 01:06:32,710
事实证明，我们要获得这个特殊的值NULL。

1067
01:06:32,710 --> 01:06:35,580
因此，就目前而言，只知道有这个特殊的值NULL

1068
01:06:35,580 --> 01:06:39,580
这将允许我们来检查时，我们的记忆，在其他的事情。

1069
01:06:39,580 --> 01:06:45,630
但是，如果我现在打开字符串，请注意区别就在这里。

1070
01:06:45,630 --> 01:06:48,210
看到一个与字​​符串的区别就在这里。

1071
01:06:48,210 --> 01:06:51,340
对于字符串，这个for循环是一个有点不同。

1072
01:06:51,340 --> 01:06:55,010
>> 让我删除的NULL，这样我们就可以谈论其他时间的。

1073
01:06:55,010 --> 01:06:57,800
的for循环有什么不同呢？

1074
01:06:59,620 --> 01:07:01,670
我可以回到前面的例子。

1075
01:07:01,670 --> 01:07:08,580
所以这是第2版，这是第1版。 1，2。

1076
01:07:08,580 --> 01:07:11,980
1，2。

1077
01:07:13,520 --> 01:07:16,660
strlen的呼叫是在哪里呢？

1078
01:07:16,660 --> 01:07:18,860
这是在for循环的第一部分。

1079
01:07:18,860 --> 01:07:21,830
任何想法，为什么我这样做？是啊。

1080
01:07:21,830 --> 01:07:24,560
[学生]：所以，你不必每一次调用该函数。

1081
01:07:24,560 --> 01:07:26,440
[马兰所以我们不每一次调用该函数。没错。

1082
01:07:26,440 --> 01:07:28,300
回想一下，他们是超级简单的for循环

1083
01:07:28,300 --> 01:07:31,770
一旦你明白，这是初始化，条件，和更新。

1084
01:07:31,770 --> 01:07:34,750
的问题是，在条件上发生的每一个循环的迭代。

1085
01:07:34,750 --> 01:07:40,010
因此，在这个例子中，什么是坏的事实，这是我的病情吗？

1086
01:07:40,010 --> 01:07:41,830
[学生]你调用strlen。

1087
01:07:41,830 --> 01:07:44,340
[马兰]你调用strlen再，再而三。

1088
01:07:44,340 --> 01:07:47,410
但是，一旦我输入的大卫，该字符串的长度是5，

1089
01:07:47,410 --> 01:07:49,650
它不会改变在每次迭代循环

1090
01:07:49,650 --> 01:07:51,670
因为该字符串是D-A-V-I-D。

1091
01:07:51,670 --> 01:07:55,320
因此，这将成为一个越来越重要思想是一个提示

1092
01:07:55,320 --> 01:08:00,410
被称为一个设计决定，只是不要让计算机做不必要的工作。

1093
01:08:00,410 --> 01:08:03,920
>> 正如先睹为快的pset2，pset2的标准版

1094
01:08:03,920 --> 01:08:07,030
会向你挑战，真正实现一些数字的密码，

1095
01:08:07,030 --> 01:08:10,410
一定数量的加密算法，这样就可以同时加密

1096
01:08:10,410 --> 01:08:13,840
和解密的秘密信息非常相似，拉尔夫解码。

1097
01:08:13,840 --> 01:08:16,810
在黑客版pset2，我们要去远一点。

1098
01:08:16,810 --> 01:08:19,649
我们要交给你一个文件从一个实际的计算机系统

1099
01:08:19,649 --> 01:08:23,479
包含一大堆的用户名和加密的密码，

1100
01:08:23,479 --> 01:08:26,939
的黑客版所面临的挑战将是破解这些密码

1101
01:08:26,939 --> 01:08:33,200
并找出产生这些密码加密或使用的是什么秘密。

1102
01:08:33,200 --> 01:08:36,109
我们要做到这一点，采用了全新的功能，在这里的C

1103
01:08:36,109 --> 01:08:40,630
我会给你只是一个演示被称为命令行参数。

1104
01:08:40,630 --> 01:08:44,229
事实证明，你们有些人可能已经看到在部分或教科书中，

1105
01:08:44,229 --> 01:08:48,260
主并不总是括号中是无效的。

1106
01:08:48,260 --> 01:08:52,430
事实证明，主也可以这样写，有两个参数，

1107
01:08:52,430 --> 01:08:56,870
argc和argv，argc是单词的数量

1108
01:08:56,870 --> 01:09:00,020
您键入程序的名称后，在命令行上

1109
01:09:00,020 --> 01:09:03,420
而argv是实际的话。

1110
01:09:03,420 --> 01:09:07,540
的方括号，显然，argv是一个数组。

1111
01:09:07,540 --> 01:09:12,210
这将是一个字符串后的字符串后，内存中的字符串。

1112
01:09:12,210 --> 01:09:16,010
>> 那么，我们将能够做的pset 2这样的事情。

1113
01:09:16,010 --> 01:09:21,350
，如果我做argv1的，这是一个例子，我们会回来（星期一），并运行它，

1114
01:09:21,350 --> 01:09:23,370
注意，它似乎并没有做任何事情。

1115
01:09:23,370 --> 01:09:25,490
它只是打印出自己的名字。

1116
01:09:25,490 --> 01:09:31,479
但是，如果我说再见类，请注意，这个方案显然迭代

1117
01:09:31,479 --> 01:09:35,479
在每一个的话，在提示符下输入。

1118
01:09:35,479 --> 01:09:41,630
和手段，我们将有机会获得的的话用户已键入的

1119
01:09:41,630 --> 01:09:49,160
是通过改变主要诠释的主要（无效）从本周末开始INT主（ARGC，ARGV）

1120
01:09:49,160 --> 01:09:52,050
从而将诞生的命令行参数。

1121
01:09:52,050 --> 01:09:57,100
而一旦你得到真正的成熟，你就可以写真正的迷幻程序

1122
01:09:57,100 --> 01:09:59,610
像这样的人在这里，这超出

1123
01:09:59,610 --> 01:10:03,940
我们已经做了一些功能迄今为止，所有功能相当强大。

1124
01:10:03,940 --> 01:10:08,950
>> 因此，我们将离开这个在屏幕上，我们将看到你在周一。

1125
01:10:17,570 --> 01:10:20,000
>> [CS50.TV]