1
00:00:00,000 --> 00:00:00,940

2
00:00:00,940 --> 00:00:05,440
>> [音乐播放]

3
00:00:05,440 --> 00:00:11,577

4
00:00:11,577 --> 00:00:12,660
戴维·J·马兰：好吧。

5
00:00:12,660 --> 00:00:15,590
这是CS50，这
是2周的开始。

6
00:00:15,590 --> 00:00:19,120
所以，让我们开始今天的错误。

7
00:00:19,120 --> 00:00:20,974
当然是一个错误，是一个
错误的程序，

8
00:00:20,974 --> 00:00:22,890
你会得到很
熟悉这个概念

9
00:00:22,890 --> 00:00:26,050
如果你从来没有编
前。 pset0现在PSET1。

10
00:00:26,050 --> 00:00:29,280
但是，让我们考虑的东西
一点简单的在第一。

11
00:00:29,280 --> 00:00:32,189
这个程序在这里，我
扔一块儿了，

12
00:00:32,189 --> 00:00:37,280
我说这应该打印
10星用printf在屏幕上，

13
00:00:37,280 --> 00:00:41,020
但它显然Buggy在某种方式。

14
00:00:41,020 --> 00:00:45,370
>> 由于规范
它应该打印10分，

15
00:00:45,370 --> 00:00:50,230
但它并不明显，什么
你会宣称是错误吗？

16
00:00:50,230 --> 00:00:52,004
是吗？

17
00:00:52,004 --> 00:00:54,420
所以，这是一个关闭一个错误，
和你是什么意思？

18
00:00:54,420 --> 00:01:00,991

19
00:01:00,991 --> 00:01:01,490
行。

20
00:01:01,490 --> 00:01:09,820

21
00:01:09,820 --> 00:01:10,410
优秀的。

22
00:01:10,410 --> 00:01:13,930
因此，我们已经指定了
开始的零值，因为我，

23
00:01:13,930 --> 00:01:18,399
我们已经指定了10的n值，
但我们使用小于或等于。

24
00:01:18,399 --> 00:01:21,190
其原因，这是二
字符，并且不只是一个符号

25
00:01:21,190 --> 00:01:22,630
就像在数学书，
是你没有

26
00:01:22,630 --> 00:01:24,880
表达的一种方式
一个字符等效的。

27
00:01:24,880 --> 00:01:28,450
>> 因此，这意味着小于，但
如果你从零开始计数，

28
00:01:28,450 --> 00:01:31,690
但你算一路
透过和等于10，

29
00:01:31,690 --> 00:01:34,170
你当然要去的
算上11事总。

30
00:01:34,170 --> 00:01:35,900
所以你要打印11星。

31
00:01:35,900 --> 00:01:37,990
那么，什么可能是这个修复？

32
00:01:37,990 --> 00:01:39,970
是吗？

33
00:01:39,970 --> 00:01:43,980
>> 因此，只要调整比较少
或等于刚小于，

34
00:01:43,980 --> 00:01:46,250
这里面的，我要求，或许
另一种解决方案，也。

35
00:01:46,250 --> 00:01:47,210
什么可能，否则你做什么？

36
00:01:47,210 --> 00:01:48,590
是吗？

37
00:01:48,590 --> 00:01:53,660
>> 所以启动它等于1，且
离开大于或等于以下。

38
00:01:53,660 --> 00:01:56,187
坦率地说，我会要求
，对于一个典型的人，

39
00:01:56,187 --> 00:01:57,770
这可能是更直接的。

40
00:01:57,770 --> 00:02:00,280
从1开始计数，
经过10计数。

41
00:02:00,280 --> 00:02:01,690
从本质上讲做你的意思。

42
00:02:01,690 --> 00:02:04,010
>> 但实际情况是在
编程，正如我们所看到的，

43
00:02:04,010 --> 00:02:07,598
计算机科学家和程序员
一般都从零开始计数。

44
00:02:07,598 --> 00:02:09,389
因此，这是一次精品
你要去适应它。

45
00:02:09,389 --> 00:02:12,640
你的情况一般会
是这样的不足。

46
00:02:12,640 --> 00:02:14,910
所以，一个简​​单的逻辑
的错误，我们现在可以

47
00:02:14,910 --> 00:02:17,990
修复并最终重新编译
这一点，得到的只是10。

48
00:02:17,990 --> 00:02:19,610
>> 以及怎么样在这里这个bug？

49
00:02:19,610 --> 00:02:24,200
在这里，再一次，我要求我有
打印10 stars--的目标

50
00:02:24,200 --> 00:02:28,140
每行这段时间的，但事实并非如此。

51
00:02:28,140 --> 00:02:30,940
之前我们提出什么
该修复程序，这是什么

52
00:02:30,940 --> 00:02:34,640
打印的视觉，如果我是编译
并运行这个程序，你觉得呢？

53
00:02:34,640 --> 00:02:35,140
是吗？

54
00:02:35,140 --> 00:02:38,360

55
00:02:38,360 --> 00:02:38,860
>> 星。

56
00:02:38,860 --> 00:02:41,690
因此，所有的星星
同一条线路是我听到的，

57
00:02:41,690 --> 00:02:43,391
，然后换行字符。

58
00:02:43,391 --> 00:02:44,140
所以让我们尝试。

59
00:02:44,140 --> 00:02:48,710
因此，让越野车-1，输入，
我看到了铿锵的命令

60
00:02:48,710 --> 00:02:50,090
我们谈到了最后一次。

61
00:02:50,090 --> 00:02:55,180
./buggy-1，而事实上我看到的所有10位明星
上，即使我要求在同一行

62
00:02:55,180 --> 00:02:58,690
在我的标准只是一个注释之上
我打算做一元的代码

63
00:02:58,690 --> 00:02:59,230
线。

64
00:02:59,230 --> 00:03:00,580
但是，这看起来是对的。

65
00:03:00,580 --> 00:03:04,620
>> 现在，第15行它看起来像我
打印一个明星，然后行16

66
00:03:04,620 --> 00:03:06,620
它看起来像我打印
新行字符，

67
00:03:06,620 --> 00:03:09,560
和他们俩都是这么缩进
我是清楚的循环里面。

68
00:03:09,560 --> 00:03:13,610
所以我不应该做的明星，新的
行，明星，新的生产线，明星，新的生产线？

69
00:03:13,610 --> 00:03:14,110
是吗？

70
00:03:14,110 --> 00:03:18,430

71
00:03:18,430 --> 00:03:21,240
>> 是啊，不像语言类
Python的，如果你是熟悉，

72
00:03:21,240 --> 00:03:23,540
压痕不
不管到计算机。

73
00:03:23,540 --> 00:03:25,280
它只关系到人类。

74
00:03:25,280 --> 00:03:29,860
所以，在这里，而我发明线
15 16--，看起来很美，

75
00:03:29,860 --> 00:03:31,330
但计算机不关心。

76
00:03:31,330 --> 00:03:34,640
计算机在乎
实际上有大括号

77
00:03:34,640 --> 00:03:36,310
围绕这些代码行。

78
00:03:36,310 --> 00:03:39,520
>> 因此，它的clear--就像在
Scratch--那些两行代码

79
00:03:39,520 --> 00:03:40,450
应该被执行。

80
00:03:40,450 --> 00:03:44,390
像那些黄色的划痕难题1
件再，再而三。

81
00:03:44,390 --> 00:03:50,920
>> 所以，现在如果我重新运行该
program-- ./buggy-2--嗯。

82
00:03:50,920 --> 00:03:51,770
我现在有一个错误。

83
00:03:51,770 --> 00:03:54,212
什么我忘了怎么办？

84
00:03:54,212 --> 00:03:55,420
是啊，所以我没有编译它。

85
00:03:55,420 --> 00:03:56,740
因此，让越野车-2。

86
00:03:56,740 --> 00:03:59,840
因为我没有没有这样的文件
实际编译的第二个版本。

87
00:03:59,840 --> 00:04:04,860
所以，现在有趣
未声明的变量 - 不是2。

88
00:04:04,860 --> 00:04:05,510
我们正在做的1。

89
00:04:05,510 --> 00:04:11,050
让越野车，1-- ./buggy-1--现在
其中的每一种在同一行上。

90
00:04:11,050 --> 00:04:13,880
>> 现在有一个例外
我的这个假设索赔

91
00:04:13,880 --> 00:04:15,520
你需要这些大括号。

92
00:04:15,520 --> 00:04:20,160
当实际上是OK--如果你
注意到，在部分或textbooks--

93
00:04:20,160 --> 00:04:22,130
省略大括号？

94
00:04:22,130 --> 00:04:22,630
是吗？

95
00:04:22,630 --> 00:04:26,290

96
00:04:26,290 --> 00:04:26,870
>> 没错。

97
00:04:26,870 --> 00:04:28,940
当只有一个
行代码，你

98
00:04:28,940 --> 00:04:32,830
要与相关的
环路中的第一实施例。

99
00:04:32,830 --> 00:04:36,380
这是完全合法的
省略花括号

100
00:04:36,380 --> 00:04:40,310
就像那种方便的
从编译器给你。

101
00:04:40,310 --> 00:04:40,810
是吗？

102
00:04:40,810 --> 00:04:43,347

103
00:04:43,347 --> 00:04:43,930
这个问题问得好。

104
00:04:43,930 --> 00:04:45,500
这是否算是一种风格的错误？

105
00:04:45,500 --> 00:04:49,340
我们会promote--在CS50
风格指南，网址为这

106
00:04:49,340 --> 00:04:51,926
在pset1--总是
使用花括号。

107
00:04:51,926 --> 00:04:53,550
当然，如果你是新来编程。

108
00:04:53,550 --> 00:04:56,800
现实情况是我们不
要禁止你

109
00:04:56,800 --> 00:04:58,680
在做这些的便利。

110
00:04:58,680 --> 00:05:00,846
但如果你刚开
事物的摇摆，

111
00:05:00,846 --> 00:05:04,020
绝对只是一直用花
牙套，直到你得到它的窍门。

112
00:05:04,020 --> 00:05:04,640
这个问题问得好。

113
00:05:04,640 --> 00:05:05,320
>> 好吧。

114
00:05:05,320 --> 00:05:07,660
使当时的错误。

115
00:05:07,660 --> 00:05:09,190
至少在一些相当简单的。

116
00:05:09,190 --> 00:05:11,260
然而，你可能会认为这
是相当简陋的，对不对？

117
00:05:11,260 --> 00:05:13,635
这是排序第一周
看着语言

118
00:05:13,635 --> 00:05:14,890
像，看到你的错误在其中。

119
00:05:14,890 --> 00:05:17,250
但现实是这些
实际上代表

120
00:05:17,250 --> 00:05:20,310
一些很可怕的问题
可能出现在真实世界中。

121
00:05:20,310 --> 00:05:23,530
>> 所以，有些人可能还记得
如果你遵循科技新闻，

122
00:05:23,530 --> 00:05:25,740
或者甚至抓
这个二月的风

123
00:05:25,740 --> 00:05:29,434
过去这一年，苹果已经对
在内部监督办公室做了一点错误，

124
00:05:29,434 --> 00:05:31,350
在操作系统上
他们的电话，并且还

125
00:05:31,350 --> 00:05:34,220
的Mac OS，操作系统
在他们的台式机和笔记本电脑。

126
00:05:34,220 --> 00:05:36,480
而你看到这样的头条新闻，因为这。

127
00:05:36,480 --> 00:05:41,120
此后，苹果
答应来修复这个bug，

128
00:05:41,120 --> 00:05:45,950
并很快做了修复它在iOS中，
但最终固定在它的Mac OS

129
00:05:45,950 --> 00:05:46,810
为好。

130
00:05:46,810 --> 00:05:50,370
>> 现在，所有这些头条实在孤独
揭示了什么潜在的问题是，

131
00:05:50,370 --> 00:05:55,640
但这个错误最终被减少到
在SSL中的一个bug，安全套接字层。

132
00:05:55,640 --> 00:05:57,390
而且长话短说，
这是软件

133
00:05:57,390 --> 00:06:01,030
我们的浏览器和其他
用软件做什么？

134
00:06:01,030 --> 00:06:04,090

135
00:06:04,090 --> 00:06:06,860
>> 如果我说，SSL是
参与，只要你

136
00:06:06,860 --> 00:06:13,920
参观以https开头的URL，
那么什么样的SSL可能涉及到？

137
00:06:13,920 --> 00:06:14,580
加密。

138
00:06:14,580 --> 00:06:16,470
因此，我们将讨论
这在未来的日子里。

139
00:06:16,470 --> 00:06:18,750
加密的艺术
扰码信息。

140
00:06:18,750 --> 00:06:22,200
>> 不过长话短说，苹果
前一段时间做了一个错误

141
00:06:22,200 --> 00:06:25,970
在实施SSL，则对
软件，最终实现

142
00:06:25,970 --> 00:06:30,120
如HTTPS或最大的网址
连接也有。

143
00:06:30,120 --> 00:06:32,850
其结果是，你的
连接可能潜在地

144
00:06:32,850 --> 00:06:33,920
被截获。

145
00:06:33,920 --> 00:06:37,130
和你的联系十分
不一定加密

146
00:06:37,130 --> 00:06:40,350
如果你有一些坏家伙之间
你和目标网站谁

147
00:06:40,350 --> 00:06:42,170
知道如何利用这一点。

148
00:06:42,170 --> 00:06:45,090
>> 现在，苹果最终发布
一种用于此修复最后，

149
00:06:45,090 --> 00:06:46,920
和描述
他们修复了这一点。

150
00:06:46,920 --> 00:06:49,878
安全可靠的运输无法验证
连接的可靠性。

151
00:06:49,878 --> 00:06:52,920
这个问题是由处理
恢复丢失的验证步骤。

152
00:06:52,920 --> 00:06:57,250
>> 所以这是一个很有一手波浪的解释
对于简单的说，我们搞砸了。

153
00:06:57,250 --> 00:07:00,920
从字面上有1
那是bug的代码行

154
00:07:00,920 --> 00:07:05,130
在他们的SSL实现，并
如果你去网上搜索这个

155
00:07:05,130 --> 00:07:07,210
你其实可以找到
原来的源代码。

156
00:07:07,210 --> 00:07:11,960
举例来说，这是一个屏幕截图
只是一个相当大的文件的一部分，

157
00:07:11,960 --> 00:07:15,965
但是这是一个很明显的功能称为
SSL验证签名的服务器密钥交换。

158
00:07:15,965 --> 00:07:17,840
它采用了一堆
参数和输入。

159
00:07:17,840 --> 00:07:20,298
而且我们不会把重点
太多的细节在那里，

160
00:07:20,298 --> 00:07:24,390
但如果你专注于里面的代码
在最上面的函数 - 让我们的

161
00:07:24,390 --> 00:07:25,590
放大了。

162
00:07:25,590 --> 00:07:28,140
你可能已经怀疑
什么样的错误可能

163
00:07:28,140 --> 00:07:31,230
甚至，如果你不知道
最终你要找什么样的。

164
00:07:31,230 --> 00:07:35,924
有一种异常的
在这里，这是什么？

165
00:07:35,924 --> 00:07:38,940
>> 是的，我真的不喜欢
两转到了一下失败。

166
00:07:38,940 --> 00:07:42,060
坦白说，我真的不知道该怎么转到
失败的方法，但有两个人

167
00:07:42,060 --> 00:07:42,810
背靠背。

168
00:07:42,810 --> 00:07:45,290
那种只是蹭到了我
理智上走错了路，

169
00:07:45,290 --> 00:07:48,910
而事实上，如果我们放大
只是那些线条，这是C。

170
00:07:48,910 --> 00:07:52,220
>> 所以很多苹果的代码
本身是用C写的，

171
00:07:52,220 --> 00:07:55,780
这显然​​是
真是equivalent--

172
00:07:55,780 --> 00:07:59,060
不是那个漂亮的压痕
版本，但如果你承认这个事实

173
00:07:59,060 --> 00:08:02,560
那有没有花括号，是什么
苹果真的写的是看起来代码

174
00:08:02,560 --> 00:08:03,540
像这样。

175
00:08:03,540 --> 00:08:07,080
所以我已经缩小了，我只是
固定在这个意义上的压痕

176
00:08:07,080 --> 00:08:10,690
如果没有大括号，即
第二页转到失败那是在黄

177
00:08:10,690 --> 00:08:12,500
将要执行的无论什么。

178
00:08:12,500 --> 00:08:15,540
它没有关联
如果条件上面。

179
00:08:15,540 --> 00:08:19,590
>> 因此，即使再次，如果你不是很
明白这可能可能

180
00:08:19,590 --> 00:08:23,230
是干什么的，知道每种
条件 - 每个行

181
00:08:23,230 --> 00:08:26,180
是一个非常重要的步骤
在检查的过程

182
00:08:26,180 --> 00:08:28,350
如果您的数据实际上是加密的。

183
00:08:28,350 --> 00:08:31,710
所以跳过这些中的一个
步骤，不是最好的主意。

184
00:08:31,710 --> 00:08:34,840
>> 但是因为我们有这个
黄第二的goto失败，

185
00:08:34,840 --> 00:08:36,840
因为一旦我们
那种美感

186
00:08:36,840 --> 00:08:40,480
它移动到左边的地方
在逻辑上是目前，是什么

187
00:08:40,480 --> 00:08:43,230
这是否意味着该行
以下是第二页转到代码

188
00:08:43,230 --> 00:08:46,480
失败，你会想到什么？

189
00:08:46,480 --> 00:08:48,860
它总是会被跳过。

190
00:08:48,860 --> 00:08:52,100
所以goto方法是在一般不赞成
对于原因，我们也不会真的去成，

191
00:08:52,100 --> 00:08:54,940
而其实在CS50，我们往往不
教这一说法跳转，

192
00:08:54,940 --> 00:08:58,130
但你能想到的后藤
失败的意思去跳

193
00:08:58,130 --> 00:08:59,600
在代码的其它部分。

194
00:08:59,600 --> 00:09:03,120
>> 换句话说跳过
最后一行共，

195
00:09:03,120 --> 00:09:07,420
所以这个愚蠢的结果
简单的错误，只是

196
00:09:07,420 --> 00:09:10,330
大概有人的结果
复制并粘贴1太

197
00:09:10,330 --> 00:09:14,150
多次的是，在整个
的iOS和Mac OS的安全性

198
00:09:14,150 --> 00:09:18,240
是很容易被截获
坏家伙相当长的一段时间。

199
00:09:18,240 --> 00:09:19,940
直到苹果最终解决了这个问题。

200
00:09:19,940 --> 00:09:23,100
>> 现在，如果你们中的一些实际上是
运行旧版本的iOS或Mac OS中，

201
00:09:23,100 --> 00:09:27,250
你可以去gotofail.com这
是一个网站，有人成立

202
00:09:27,250 --> 00:09:29,190
基本上确定
编程

203
00:09:29,190 --> 00:09:30,980
如果你的电脑仍然是脆弱的。

204
00:09:30,980 --> 00:09:33,600
坦率地说，如果是这样，
它可能是一个好主意

205
00:09:33,600 --> 00:09:36,870
更新您的手机或
您的Mac在这一点上。

206
00:09:36,870 --> 00:09:40,120
但是，只要证明是多么的
这些较低层次的欣赏

207
00:09:40,120 --> 00:09:42,400
细节及公平
简单的想法真的可以

208
00:09:42,400 --> 00:09:44,590
转化为决策
和问题

209
00:09:44,590 --> 00:09:47,320
affected--在这个case--
数以百万计的人。

210
00:09:47,320 --> 00:09:49,107
>> 现在的政府的话。

211
00:09:49,107 --> 00:09:50,690
部分将于本星期日。

212
00:09:50,690 --> 00:09:53,360
你会被收到一封电子邮件，
周末约部分，在这一点

213
00:09:53,360 --> 00:09:55,290
切除过程
将开始，如果你已经

214
00:09:55,290 --> 00:09:56,998
意识到你现在有
一些新的矛盾。

215
00:09:56,998 --> 00:10:00,180
所以，这种情况每年都有，而我们
将在未来的日子容纳前来。

216
00:10:00,180 --> 00:10:02,430
>> 办公室hours--做一个守
眼睛在这里时间表。

217
00:10:02,430 --> 00:10:05,100
本周改变一点点，
特别是在开始时间

218
00:10:05,100 --> 00:10:08,180
和位置，所以咨询
在前往上班时间前

219
00:10:08,180 --> 00:10:09,520
任何在未来四年夜。

220
00:10:09,520 --> 00:10:12,680
现在就评估一个字，
特别是当你潜入问题

221
00:10:12,680 --> 00:10:14,350
设置一个和超越。

222
00:10:14,350 --> 00:10:17,070
>> 所以每说明书中，
这些通常是

223
00:10:17,070 --> 00:10:20,360
轴沿
我们评估你的工作。

224
00:10:20,360 --> 00:10:23,170
范围指的是什么
程度的代码实现

225
00:10:23,170 --> 00:10:25,690
所需的功能
我们的规范。

226
00:10:25,690 --> 00:10:28,290
换句话说，有多少
一块一套做你咬掉。

227
00:10:28,290 --> 00:10:30,440
你做了它的三分之一，
半吧，它100％。

228
00:10:30,440 --> 00:10:33,000
即使是不正确的，
你有多少尝试？

229
00:10:33,000 --> 00:10:35,290
以便捕获水平
的努力和量

230
00:10:35,290 --> 00:10:38,260
为您咬下了
问题集中的问题。

231
00:10:38,260 --> 00:10:40,690
>> Correctness--这其中，以
什么程度，是你的代码

232
00:10:40,690 --> 00:10:43,150
与我们一致
规格和免费的错误。

233
00:10:43,150 --> 00:10:44,770
所以它正常工作？

234
00:10:44,770 --> 00:10:48,700
如果我们给它一些投入，做它
给我们，我们期待的输出？

235
00:10:48,700 --> 00:10:52,570
设计 - 现在，这是第
特别是在定性的人，

236
00:10:52,570 --> 00:10:56,180
或者需要人为判断的人。

237
00:10:56,180 --> 00:10:59,690
事实上，这就是为什么我们有一个工作人员
这么多的教学研究员，当然

238
00:10:59,690 --> 00:11:00,350
助理。

239
00:11:00,350 --> 00:11:03,480
到什么程度是你的
代码写得好？

240
00:11:03,480 --> 00:11:05,810
>> 而这同样是一个非常
定性评估

241
00:11:05,810 --> 00:11:09,100
这将与您合作
双向的几周里。

242
00:11:09,100 --> 00:11:12,060
所以，当你得到不
只有数字得分，但也

243
00:11:12,060 --> 00:11:16,682
书面的分数，或键入反馈，
或书面反馈的英语单词。

244
00:11:16,682 --> 00:11:19,640
这就是我们将用它来驱动你
对实际编写更好的代码。

245
00:11:19,640 --> 00:11:23,320
并在演讲和节中，我们将尝试
来点out--因为我们can--经常

246
00:11:23,320 --> 00:11:26,420
是什么让一个程序，不仅
正确的和功能良好，

247
00:11:26,420 --> 00:11:28,200
同时也精心设计。

248
00:11:28,200 --> 00:11:31,850
最有效的可能是，或
即使是最美丽也可以是。

249
00:11:31,850 --> 00:11:33,100
>> 这使我们的风格。

250
00:11:33,100 --> 00:11:36,876
风格最终是
审美判断。

251
00:11:36,876 --> 00:11:38,750
你选择好
名称的变量？

252
00:11:38,750 --> 00:11:40,330
你有没有适当的缩进你的代码？

253
00:11:40,330 --> 00:11:44,010
它是否好看，因此，
是很容易让另一个人

254
00:11:44,010 --> 00:11:46,550
看你们各自的
它的正确性。

255
00:11:46,550 --> 00:11:50,300
>> 现在一般按教学大纲，我们得分
这些东西对一个五点量表。

256
00:11:50,300 --> 00:11:53,640
让我费尽心思点
这三个确实是不错的。

257
00:11:53,640 --> 00:11:55,550
很快做伙计
开始做算术。

258
00:11:55,550 --> 00:11:58,133
当他们得到四分之三的
五张正确性一些PSET

259
00:11:58,133 --> 00:12:02,040
他们认为该死的，我要60％
它本质上是一个D或大肠

260
00:12:02,040 --> 00:12:03,980
>> 这是没有办法的办法，我们
认为这些数字。

261
00:12:03,980 --> 00:12:06,880
一个三确实不错，而我们
普遍预期在开始

262
00:12:06,880 --> 00:12:09,820
这个词的是，如果你要
一堆three's--的，也许一对夫妇

263
00:12:09,820 --> 00:12:12,540
展览会，一对夫妇的fours--或
一对夫妇的两岁，一对夫妇fours--的

264
00:12:12,540 --> 00:12:13,748
这是一个良好的开端。

265
00:12:13,748 --> 00:12:16,320
所以，只要我们看到
向上的轨迹随着时间的推移，

266
00:12:16,320 --> 00:12:18,540
你在一个特别好的地方。

267
00:12:18,540 --> 00:12:20,752
>> 我们使用公式
重的东西基本上是

268
00:12:20,752 --> 00:12:22,710
这每教学大纲，
这只是意味着我们

269
00:12:22,710 --> 00:12:24,750
给予更多的权重正确性。

270
00:12:24,750 --> 00:12:27,930
因为它往往正确性
这需要的时间最多。

271
00:12:27,930 --> 00:12:28,760
现在相信我。

272
00:12:28,760 --> 00:12:31,190
你会find--至少
在一个pset--你

273
00:12:31,190 --> 00:12:36,790
花90％的时间
处理问题的10％。

274
00:12:36,790 --> 00:12:39,320
>> 和一切形式的作品
除了一个或两个错误，

275
00:12:39,320 --> 00:12:41,570
而这些都是错误的
迟到让你彻夜难眠。

276
00:12:41,570 --> 00:12:43,380
这些是那些
那种逃避你。

277
00:12:43,380 --> 00:12:45,560
不过，睡在它之后，
或参加工作时间

278
00:12:45,560 --> 00:12:48,844
或问问题网上，被
当你到了100％的目标，

279
00:12:48,844 --> 00:12:50,760
这就是为什么我们重
正确之最。

280
00:12:50,760 --> 00:12:54,102
设计有点少，和
款式比少一点。

281
00:12:54,102 --> 00:12:56,060
但请mind--风格
也许是最简单的

282
00:12:56,060 --> 00:12:58,890
这些咬掉
按风格指南。

283
00:12:58,890 --> 00:13:01,580
>> 而现在，一个更严重
注意，学术诚信。

284
00:13:01,580 --> 00:13:05,000
CS50拥有的不幸区别
是AD板的最大生产国

285
00:13:05,000 --> 00:13:07,330
案件几乎每年都有历史。

286
00:13:07,330 --> 00:13:11,012
这并不是因为学生作弊
CS50任远远超过其他类，

287
00:13:11,012 --> 00:13:13,720
但因为由工作性质，
事实上，它是电子，

288
00:13:13,720 --> 00:13:16,636
事实上，我们寻找它，
其实我们是计算机科学家，

289
00:13:16,636 --> 00:13:20,570
我可以说，我们是不幸的
在检测是非常好的。

290
00:13:20,570 --> 00:13:22,710
>> 那么这意味着什么实质？

291
00:13:22,710 --> 00:13:24,820
所以，按照教学大纲，
课程的理念

292
00:13:24,820 --> 00:13:28,090
确实归结为是合理的。

293
00:13:28,090 --> 00:13:31,684
之间有此线
做一个人的工作，在自己的

294
00:13:31,684 --> 00:13:34,100
并获得一点点
从朋友合理的帮助下，

295
00:13:34,100 --> 00:13:38,020
和彻底的做这件工作你
朋友，或者送他（她）你的代码

296
00:13:38,020 --> 00:13:41,080
因此，他或她可以简单地
采取或借用它的权利。

297
00:13:41,080 --> 00:13:43,580
和横交线
我们在课堂上画。

298
00:13:43,580 --> 00:13:45,410
>> 你看，教学大纲
最终的行

299
00:13:45,410 --> 00:13:48,209
我们画的是合理的
不合理的行为，

300
00:13:48,209 --> 00:13:50,000
但它确实熬
下到实质

301
00:13:50,000 --> 00:13:53,980
你的工作需要，以
是你到底自己。

302
00:13:53,980 --> 00:13:56,230
现在，随着中说，
有一种启发式。

303
00:13:56,230 --> 00:13:58,980
因为你可能imagine--
从办公时间和视觉效果

304
00:13:58,980 --> 00:14:01,060
和影片，我们已经
由此显示far-- CS50

305
00:14:01,060 --> 00:14:04,530
的确意味着是作为协作
并为合作和社会

306
00:14:04,530 --> 00:14:06,450
越好。

307
00:14:06,450 --> 00:14:08,570
由于协作，因为它是严格的。

308
00:14:08,570 --> 00:14:11,314
>> 但是，与此说，启发式，
您将在教学大纲看，

309
00:14:11,314 --> 00:14:12,980
是，你有一些问题的时候。

310
00:14:12,980 --> 00:14:16,470
你必须在你的代码中的一些错误，你
解决不了，这是合理的你

311
00:14:16,470 --> 00:14:18,039
展现你的代码给别人。

312
00:14:18,039 --> 00:14:21,080
有朋友甚至在课堂上，一个朋友
坐在办公室时间在你旁边，

313
00:14:21,080 --> 00:14:22,680
或工作人员中的一员。

314
00:14:22,680 --> 00:14:25,810
但他们可能不是他们的代码给你看。

315
00:14:25,810 --> 00:14:27,710
>> 换句话说，一个
回答你的question--

316
00:14:27,710 --> 00:14:29,940
我需要帮助 - 是不是哦，这是我的代码。

317
00:14:29,940 --> 00:14:32,440
看看这个和
从中推断出你的意愿。

318
00:14:32,440 --> 00:14:34,580
当然，现在，有
办法明确，以游戏

319
00:14:34,580 --> 00:14:37,760
这个制度，我会告诉你
我有一个问题，之前的代码。

320
00:14:37,760 --> 00:14:40,150
您能告诉我，我的代码
之前，有一个问题。

321
00:14:40,150 --> 00:14:45,870
但再次看到教学大纲为
的这条线是精细度。

322
00:14:45,870 --> 00:14:50,606
>> 只是现在画的图片，
分享尽可能透明

323
00:14:50,606 --> 00:14:53,480
在这里我们是在近年来
这是AD板的个案数目

324
00:14:53,480 --> 00:14:56,260
该CS50拥有超过
在过去的七年。

325
00:14:56,260 --> 00:14:58,717
有14个情况下，这最新的秋季。

326
00:14:58,717 --> 00:15:01,300
在所涉及的学生而言，
这是一些20多名学生

327
00:15:01,300 --> 00:15:02,490
过去的这个秋天。

328
00:15:02,490 --> 00:15:05,670
有33峰
学生在几年前。

329
00:15:05,670 --> 00:15:08,830
其中许多人是不幸的
这里不再在校园里。

330
00:15:08,830 --> 00:15:13,100
>> 由于所涉及的百分比学生
类历史上从0％不等

331
00:15:13,100 --> 00:15:17,300
到5.3％，这是唯一的说
每年，这是一个挑战。

332
00:15:17,300 --> 00:15:20,390
而为了实现这一目标，有什么
我们想要做的是传达1

333
00:15:20,390 --> 00:15:24,310
我们dd--只是FYI--在比较
公平性，以谁的学生

334
00:15:24,310 --> 00:15:26,520
在下面的相应行。

335
00:15:26,520 --> 00:15:29,620
我们做的比较全电流
提交对所有过去的任务

336
00:15:29,620 --> 00:15:30,840
从过去的许多年。

337
00:15:30,840 --> 00:15:33,620
>> 我们也知道如何围绕谷歌
并找到代码库

338
00:15:33,620 --> 00:15:36,360
在网上，论坛
在线招聘网站在线。

339
00:15:36,360 --> 00:15:41,580
如果一个学生能找到它，就一定能够
发现它就像我们遗憾地做。

340
00:15:41,580 --> 00:15:45,330
所以，你会在看大纲
虽然这是遗憾的条款。

341
00:15:45,330 --> 00:15:47,500
我可以肯定的
明白了，我们都有

342
00:15:47,500 --> 00:15:50,870
工作人员已经做了类似课程
这一点，或者这个本身随着时间的推移，

343
00:15:50,870 --> 00:15:53,997
当然知道是什么感觉时，
生活变得在当你有办法

344
00:15:53,997 --> 00:15:56,080
一些深夜deadline--
不仅在这个类中，

345
00:15:56,080 --> 00:15:58,660
但another--你的时候
完全丧失，压力太大了，

346
00:15:58,660 --> 00:16:00,659
拥有过多数量
其他的事情要做。

347
00:16:00,659 --> 00:16:03,660
你会在某个时刻
生活中肯定是不好的，也许迟

348
00:16:03,660 --> 00:16:04,620
晚上的决定。

349
00:16:04,620 --> 00:16:06,520
>> 所以每教学大纲，
有这一条款，

350
00:16:06,520 --> 00:16:10,629
这样，如果在72小时内作出的
一些贫穷的决定，你自己到它

351
00:16:10,629 --> 00:16:12,670
并伸出手给我，
的过程中的一个头

352
00:16:12,670 --> 00:16:14,300
我们会好好聊聊。

353
00:16:14,300 --> 00:16:16,220
我们会处理事情
在内部的希望

354
00:16:16,220 --> 00:16:18,770
它变得更加的
教学时刻或生命的教训，

355
00:16:18,770 --> 00:16:22,120
而不是用
特别厉害的后果

356
00:16:22,120 --> 00:16:24,570
你可能对这些图表在这里看到。

357
00:16:24,570 --> 00:16:26,540
>> 所以这是一个非常严肃的口气。

358
00:16:26,540 --> 00:16:29,960
让我们停下来只有几
秒打破了紧张局势。

359
00:16:29,960 --> 00:16:34,442
>> [音乐播放]

360
00:16:34,442 --> 00:17:17,768

361
00:17:17,768 --> 00:17:20,250
>> 戴维·J·马兰：好吧，
因此，如何是一个SEGUE？

362
00:17:20,250 --> 00:17:22,059
今天的主要话题。

363
00:17:22,059 --> 00:17:23,859
其中第一个是抽象。

364
00:17:23,859 --> 00:17:26,900
另外，其中将要成为
数据，其中坦白的表示

365
00:17:26,900 --> 00:17:31,640
是说如何在真干，才能
去解决问题和思考

366
00:17:31,640 --> 00:17:33,250
对解决问题？

367
00:17:33,250 --> 00:17:37,285
所以，你看到的划痕，而且你已经
用C见过也许已经在PSET1

368
00:17:37,285 --> 00:17:39,930
你不仅可以使用
函数，如printf，

369
00:17:39,930 --> 00:17:42,770
其他人在
过去几年里为你写的。

370
00:17:42,770 --> 00:17:45,340
您也可以编写自己的函数。

371
00:17:45,340 --> 00:17:48,440
>> 而且即使你可能没有
C语言中PSET1做到了这一点，并坦言

372
00:17:48,440 --> 00:17:51,866
你并不真的需要写你
自己的功能，因为problem--

373
00:17:51,866 --> 00:17:53,990
而或许是艰巨的
第一glance--你会看到

374
00:17:53,990 --> 00:17:57,910
可最终被解决
不是所有的多行代码。

375
00:17:57,910 --> 00:18:01,140
但随着中说，在条件
编写自己的功能，

376
00:18:01,140 --> 00:18:03,570
意识到ç确实给
你这种能力。

377
00:18:03,570 --> 00:18:06,940
>> 我要进去了今天的源代码，
它可已在网上，

378
00:18:06,940 --> 00:18:10,900
而我要继续前进，开
一个调用的函数0.C程序，

379
00:18:10,900 --> 00:18:14,620
和在功能零
我们会看到一些东西。

380
00:18:14,620 --> 00:18:19,160
在通过第18行
23是我的主要功能。

381
00:18:19,160 --> 00:18:22,414
而现在，我们正在开始阅读
我们不是写在飞行中的代码，

382
00:18:22,414 --> 00:18:25,080
而是我已经写了提前
或者你在一个问题集

383
00:18:25,080 --> 00:18:27,910
可能会收到有
被预先写入。

384
00:18:27,910 --> 00:18:30,040
一个很好的方式开始
阅读别人的代码

385
00:18:30,040 --> 00:18:31,400
为寻找主要功能。

386
00:18:31,400 --> 00:18:34,420
找出其中的条目
点是要运行的程序，

387
00:18:34,420 --> 00:18:36,580
然后从那里跟随它在逻辑上。

388
00:18:36,580 --> 00:18:40,190
>> 所以，这个方案显然版画
你的名字后面加上冒号。

389
00:18:40,190 --> 00:18:42,490
然后，我们使用的GetString
从CS50库

390
00:18:42,490 --> 00:18:46,050
得到一个字符串，或一个单词或词组
从设置在键盘的用户。

391
00:18:46,050 --> 00:18:48,390
再有就是这个
事情这里 -  PrintName。

392
00:18:48,390 --> 00:18:51,420
>> 现在PrintName不是
功能自带的三

393
00:18:51,420 --> 00:18:52,970
这不是标准的io.h.

394
00:18:52,970 --> 00:18:55,570
这不是在CS50.h.

395
00:18:55,570 --> 00:18:57,880
这是相当在同一个文件。

396
00:18:57,880 --> 00:19:01,000
请注意，如果我向下滚动
àbit--线25 27--

397
00:19:01,000 --> 00:19:05,330
它的评论只是一个漂亮的方式
用星星和斜线你的代码。

398
00:19:05,330 --> 00:19:07,320
这是一个多行
评价，而这仅仅是

399
00:19:07,320 --> 00:19:10,570
我的蓝色说明
这个函数的作用是什么。

400
00:19:10,570 --> 00:19:14,530
>> 由于线28到31，
我写了一个超级简单的功能

401
00:19:14,530 --> 00:19:16,280
他的名字是PrintName。

402
00:19:16,280 --> 00:19:19,560
这需要多少
论证会说什么？

403
00:19:19,560 --> 00:19:25,120
因此，人们argument--，因为有一
参数括号内上市。

404
00:19:25,120 --> 00:19:27,000
它的类型为String。

405
00:19:27,000 --> 00:19:30,240
这是说PrintName
是这样的黑盒子

406
00:19:30,240 --> 00:19:32,910
或函数，它接受
输入一个字符串。

407
00:19:32,910 --> 00:19:35,730
>> 而该字符串的名称
方便地将名称。

408
00:19:35,730 --> 00:19:37,840
不是S，而不是N，但名称。

409
00:19:37,840 --> 00:19:41,090
那么什么是PrintName办？

410
00:19:41,090 --> 00:19:42,210
这是不错的简单。

411
00:19:42,210 --> 00:19:45,390
正如一行代码
中的printf，但显然它

412
00:19:45,390 --> 00:19:47,950
打印出“你好，”某某。

413
00:19:47,950 --> 00:19:50,070
凡某某
来自说法。

414
00:19:50,070 --> 00:19:52,300
>> 现在，这是不是在这里一个巨大的创新。

415
00:19:52,300 --> 00:19:56,710
说真的，我已经采取了一个程序，可以
已被写入同一个代码行

416
00:19:56,710 --> 00:20:00,190
通过把这个在这里，
并改变了它的东西

417
00:20:00,190 --> 00:20:04,920
这涉及到一些六，七左右
代码行一路下来这里。

418
00:20:04,920 --> 00:20:08,190
>> 但它的执业
原则被称为抽象。

419
00:20:08,190 --> 00:20:12,550
一种封装的新内
函数，有一个名字，更好地

420
00:20:12,550 --> 00:20:14,590
但这个名字从字面上
称它做什么。

421
00:20:14,590 --> 00:20:16,880
我的意思是printf--这不是
尤其是描述性的。

422
00:20:16,880 --> 00:20:18,932
如果我想创建一个
拼图，或者如果我

423
00:20:18,932 --> 00:20:21,140
要创建一个函数
在打印一个人的名字，

424
00:20:21,140 --> 00:20:23,230
这样的美
是，我实际上可以

425
00:20:23,230 --> 00:20:27,170
给该函数的名称
这说明它的作用。

426
00:20:27,170 --> 00:20:29,844
>> 现在只需要在输入该
我随便叫的名字，

427
00:20:29,844 --> 00:20:32,760
但同样是精彩的描述
而不是被多一点

428
00:20:32,760 --> 00:20:36,140
一般像S。和
无效，现在，只表示

429
00:20:36,140 --> 00:20:38,330
这个函数不
把我带回点什么。

430
00:20:38,330 --> 00:20:41,127
它不喜欢的GetString的
从字面上递给我回一个字符串

431
00:20:41,127 --> 00:20:43,960
就像我们用纸片做
上周你的同学，

432
00:20:43,960 --> 00:20:45,990
而是它只是有一个副作用。

433
00:20:45,990 --> 00:20:48,080
它打印的东西在屏幕上。

434
00:20:48,080 --> 00:20:53,880
>> 所以在一天结束时，如果我
不要让功能-0，./function-0，

435
00:20:53,880 --> 00:20:55,450
我们会看到，它要求我的名字。

436
00:20:55,450 --> 00:20:58,150
I型大卫，这类型的我的名字。

437
00:20:58,150 --> 00:21:01,080
如果我再这样做了罗布，
它会说“你好，罗布。”

438
00:21:01,080 --> 00:21:04,280
因此，一个简单的想法，但也许
从这个推断精神

439
00:21:04,280 --> 00:21:06,750
随着你的计划得到
稍微复杂一点，

440
00:21:06,750 --> 00:21:10,290
你想写一大块
代码和调用代码 - 调用

441
00:21:10,290 --> 00:21:13,270
该代码 - 一些描述
名称如PrintName，

442
00:21:13,270 --> 00:21:15,600
C那样被提供给我们这种能力。

443
00:21:15,600 --> 00:21:17,660
>> 这里还有一个简单的例子。

444
00:21:17,660 --> 00:21:22,940
举例来说，如果我打开了一个
从今天呼吁return.c文件，

445
00:21:22,940 --> 00:21:24,270
请注意我在这里所做的。

446
00:21:24,270 --> 00:21:26,330
大部分的主要功能是printf的。

447
00:21:26,330 --> 00:21:30,360
我第一次随意初始化
变量名为x为数字2。

448
00:21:30,360 --> 00:21:34,110
然后，我打印出来的“X现在
％I“传递x的值。

449
00:21:34,110 --> 00:21:35,500
所以，我只是说那是什么。

450
00:21:35,500 --> 00:21:37,208
>> 现在，我只是大胆
自称与printf的。

451
00:21:37,208 --> 00:21:42,050
我魔方的值x，我
通过调用一个函数这样做

452
00:21:42,050 --> 00:21:45,590
所谓的魔方传球
在x作为参数，

453
00:21:45,590 --> 00:21:49,300
然后将输出保存
在变量X本身来说。

454
00:21:49,300 --> 00:21:51,340
所以我重挫x的值。

455
00:21:51,340 --> 00:21:53,380
我重写
X带的什么价值

456
00:21:53,380 --> 00:21:56,510
调用的结果
这个立方体功能。

457
00:21:56,510 --> 00:21:59,530
然后，我只是打印出一些
毛绒绒的东西在这里说，我所做的。

458
00:21:59,530 --> 00:22:01,600
>> 那么，什么话是立方体？

459
00:22:01,600 --> 00:22:03,510
注意什么是根本
这里不同。

460
00:22:03,510 --> 00:22:05,540
我已经给了函数
一个名字和以前一样。

461
00:22:05,540 --> 00:22:08,270
我指定一个名称的参数。

462
00:22:08,270 --> 00:22:11,650
这一次，这就是所谓的n，而不是名称，
但我可以把它叫做什么是我想要的。

463
00:22:11,650 --> 00:22:12,650
但是，这是不同的。

464
00:22:12,650 --> 00:22:14,080
这个东西在左边。

465
00:22:14,080 --> 00:22:16,290
以前是什么样的关键字？

466
00:22:16,290 --> 00:22:16,870
男生。

467
00:22:16,870 --> 00:22:18,580
现在，这显然INT。

468
00:22:18,580 --> 00:22:20,630
>> 那么，什么是可能的带走？

469
00:22:20,630 --> 00:22:24,090
之类的，而无效表示
虚无，这是事实。

470
00:22:24,090 --> 00:22:25,970
PrintName返回任何内容。

471
00:22:25,970 --> 00:22:27,942
它做了什么，但
它没有把我背

472
00:22:27,942 --> 00:22:30,650
东西，我可以把上
等号的左边

473
00:22:30,650 --> 00:22:32,460
就像我在这里的第22行完成。

474
00:22:32,460 --> 00:22:36,780
>> 所以，如果我说成线30，
那是什么可能暗示

475
00:22:36,780 --> 00:22:38,610
什么魔方确实给我吗？

476
00:22:38,610 --> 00:22:41,110
是吗？

477
00:22:41,110 --> 00:22:42,310
它返回一个整数。

478
00:22:42,310 --> 00:22:44,590
因此，递给我回来了，为
例如，一张纸

479
00:22:44,590 --> 00:22:46,580
在其撰写的答案。

480
00:22:46,580 --> 00:22:50,130
2立方，或3立方，或4个
cubed--不管我传递，

481
00:22:50,130 --> 00:22:51,540
而我怎么实现呢？

482
00:22:51,540 --> 00:22:54,810
那么，就n次n次Ñ
就是我怎么可能多维数据集中的值。

483
00:22:54,810 --> 00:22:57,110
如此反复，超级简单
的想法，但示范

484
00:22:57,110 --> 00:23:00,100
现在我们怎么能写功能
实际上我们有背

485
00:23:00,100 --> 00:23:02,380
这可能是感兴趣的值。

486
00:23:02,380 --> 00:23:05,740
>> 让我们来看看最后一个例子
这里所谓的功能之一。

487
00:23:05,740 --> 00:23:08,530
在这个例子中，它启动
以获得更引人注目。

488
00:23:08,530 --> 00:23:12,400
因此，在功能之一，这
program--最终通知

489
00:23:12,400 --> 00:23:14,920
调用一个名为GetPositiveInt功能。

490
00:23:14,920 --> 00:23:17,800
GetPositiveInt不是
在CS50库函数，

491
00:23:17,800 --> 00:23:20,400
但我们决定我们
希望它存在。

492
00:23:20,400 --> 00:23:24,550
>> 因此，如果我们在后面的文件中向下滚动，
请注意我是如何去落实有关

493
00:23:24,550 --> 00:23:26,560
得到正整数，而我
说这是更引人注目

494
00:23:26,560 --> 00:23:28,992
因为这是一个体面的
代码的行数。

495
00:23:28,992 --> 00:23:30,700
这不只是一个愚蠢的
小玩具程序。

496
00:23:30,700 --> 00:23:33,870
它实际上有一些错误检查
并做一些更有用。

497
00:23:33,870 --> 00:23:38,470
>> 所以，如果你从来没见过的演练
影片我们已经嵌入在PSET1，

498
00:23:38,470 --> 00:23:42,350
知道，这是一种类型的
循环在C中，在精神上类似于

499
00:23:42,350 --> 00:23:44,270
对各种事情划痕可以做。

500
00:23:44,270 --> 00:23:46,320
做说做到这一点。

501
00:23:46,320 --> 00:23:47,500
打印出来。

502
00:23:47,500 --> 00:23:51,860
然后继续前进，让N--
得到一个整数，并将其存储在N，

503
00:23:51,860 --> 00:23:55,760
并保持一而再，再而这样做
再次，只要n是小于1。

504
00:23:55,760 --> 00:23:58,720
>> 因此n是将要小于一
只有在人的不配合。

505
00:23:58,720 --> 00:24:01,980
如果他或她打字
在0或-1或-50，

506
00:24:01,980 --> 00:24:04,790
这个环是要保持
执行一遍又一遍。

507
00:24:04,790 --> 00:24:07,549
最终发现，我
简单的返回值。

508
00:24:07,549 --> 00:24:09,590
所以，现在我们有一个函数
这会一直很好

509
00:24:09,590 --> 00:24:14,040
如果CS50将实施
CS50.h和CS50.c你，

510
00:24:14,040 --> 00:24:16,520
但在这里，我们现在可以
实现这个自己。

511
00:24:16,520 --> 00:24:19,230
>> 但在一些关键的细节两点意见。

512
00:24:19,230 --> 00:24:24,390
埃德蒙顿为什么我宣布INT
N，你认为，第29行

513
00:24:24,390 --> 00:24:27,139
而不是仅仅做
这这里，这是

514
00:24:27,139 --> 00:24:28,930
用更一致
我们上周做？

515
00:24:28,930 --> 00:24:29,430
是吗？

516
00:24:29,430 --> 00:24:34,485

517
00:24:34,485 --> 00:24:35,110
一个好的想法。

518
00:24:35,110 --> 00:24:37,080
所以，如果我们把它
在这里，就好像我们

519
00:24:37,080 --> 00:24:39,110
继续一次又一次地宣布它。

520
00:24:39,110 --> 00:24:42,000
这本身是
没有问题的，本身

521
00:24:42,000 --> 00:24:43,940
因为我们只需要
的值一次，然后

522
00:24:43,940 --> 00:24:45,330
我们将得到一个新的反正。

523
00:24:45,330 --> 00:24:45,940
但一个好的想法。

524
00:24:45,940 --> 00:24:46,440
是吗？

525
00:24:46,440 --> 00:24:52,770

526
00:24:52,770 --> 00:24:53,330
>> 关闭。

527
00:24:53,330 --> 00:24:59,030
所以，因为我已经声明氮对
第29行的循环外，

528
00:24:59,030 --> 00:25:01,390
这是整个访问
这整个功能。

529
00:25:01,390 --> 00:25:05,400
没有其他的功能，因为
n是仍然这些卷曲的内

530
00:25:05,400 --> 00:25:06,470
牙套这里。

531
00:25:06,470 --> 00:25:07,940
So--肯定。

532
00:25:07,940 --> 00:25:12,430

533
00:25:12,430 --> 00:25:12,940
>> 没错。

534
00:25:12,940 --> 00:25:14,356
因此，这更是给了点。

535
00:25:14,356 --> 00:25:18,600
如果我们不是声明
n右此间线32条，

536
00:25:18,600 --> 00:25:22,340
这是有问题的，因为猜测
还有什么地方我需要访问它？

537
00:25:22,340 --> 00:25:25,620
上线34和
拇指简单的规则就是

538
00:25:25,620 --> 00:25:30,060
你只能使用一个变量
最近的大括号内

539
00:25:30,060 --> 00:25:31,420
在你宣称它。

540
00:25:31,420 --> 00:25:35,230
>> 不幸的是，34行
是一条线为时已晚，

541
00:25:35,230 --> 00:25:38,560
因为我已经关闭
第33行的大括号

542
00:25:38,560 --> 00:25:41,220
对应于该
大括号上线30。

543
00:25:41,220 --> 00:25:44,180
所以这是一个跟你说
这个变量int的作用范围，

544
00:25:44,180 --> 00:25:46,970
可以这么说，只有内
这些大括号。

545
00:25:46,970 --> 00:25:48,910
它只是没有人以外的存在。

546
00:25:48,910 --> 00:25:51,580
>> 所以，事实上，如果我这样做
错了，让我保存代码

547
00:25:51,580 --> 00:25:53,530
因为它is--正确书写。

548
00:25:53,530 --> 00:25:57,990
让我继续前进，不要让
函数-1，和notice--错误。

549
00:25:57,990 --> 00:26:03,502
使用未声明的标识符的n
在第35行，也就是在这里。

550
00:26:03,502 --> 00:26:05,210
如果我们向上滚动
进一步，另一个。

551
00:26:05,210 --> 00:26:08,750
使用未申报
标识符氮对线34。

552
00:26:08,750 --> 00:26:11,200
>> 所以编译器，锵，
已经注意到，它只是

553
00:26:11,200 --> 00:26:13,720
即使不存在
显然它的存在视觉。

554
00:26:13,720 --> 00:26:16,090
因此，一个简单的解决方法是宣布它在那里。

555
00:26:16,090 --> 00:26:18,790
>> 现在让我来滚动
该文件的顶部。

556
00:26:18,790 --> 00:26:21,080
什么跳出你的
是有一点不同

557
00:26:21,080 --> 00:26:23,070
从东西，我们看了上周？

558
00:26:23,070 --> 00:26:26,990
不仅我的名字，不仅做到
我有一些尖锐，包括向上顶，

559
00:26:26,990 --> 00:26:29,340
我有一些我
调用的原型。

560
00:26:29,340 --> 00:26:36,100
现在，这看起来非常像什么
我们只是看到了刚才的第27行。

561
00:26:36,100 --> 00:26:39,230
>> 因此，让我们从不同的推断
错误信息，为什么我这样做。

562
00:26:39,230 --> 00:26:42,050
让我继续前进，
删除这些行那里。

563
00:26:42,050 --> 00:26:44,240
因此，我们一无所知的原型。

564
00:26:44,240 --> 00:26:45,430
重拍此文件。

565
00:26:45,430 --> 00:26:46,890
使功能之一。

566
00:26:46,890 --> 00:26:48,090
而现在，该死的，四个错误。

567
00:26:48,090 --> 00:26:50,220
让我们向上滚动到第一个。

568
00:26:50,220 --> 00:26:55,070
>> 函数隐式声明
得到肯定int是在C99无效。

569
00:26:55,070 --> 00:26:57,780
C99仅仅意味着1999年
版本的语言的

570
00:26:57,780 --> 00:26:59,710
C，这就是我们的确使用。

571
00:26:59,710 --> 00:27:01,050
所以，这是什么意思？

572
00:27:01,050 --> 00:27:05,250
以及C--更具体ç
compilers--是非常愚蠢的计划。

573
00:27:05,250 --> 00:27:07,420
他们只知道你做了什么
告诉他们，这是

574
00:27:07,420 --> 00:27:08,960
实际上专题较上周。

575
00:27:08,960 --> 00:27:12,910
>> 问题是，如果我去
有关实施的名字在这里，

576
00:27:12,910 --> 00:27:17,640
而我所说的被调用的函数
GetPositiveInt这里线20条，

577
00:27:17,640 --> 00:27:22,520
该功能在技术上不
存在，直到编译器看到27行。

578
00:27:22,520 --> 00:27:25,450
不幸的是，编译器是
做事前，下，左，右，

579
00:27:25,450 --> 00:27:29,580
所以，因为它没有看到
实施GetPositiveInt的，

580
00:27:29,580 --> 00:27:32,400
但是看到你尝试
在这里使用它，

581
00:27:32,400 --> 00:27:35,810
它只是要bail--骂
你有一个错误message--也许

582
00:27:35,810 --> 00:27:38,440
隐蔽，并且实际上不
编译文件。

583
00:27:38,440 --> 00:27:41,940
>> 因此，所谓的原型了
这是无可否认的是多余的。

584
00:27:41,940 --> 00:27:47,870
从字面上看，我去了这里，我抄
贴这个，我把它在这里。

585
00:27:47,870 --> 00:27:51,020
虚空会比较合适，所以我们
从字面上复制，这一次粘贴。

586
00:27:51,020 --> 00:27:52,854
我简直复制和粘贴它。

587
00:27:52,854 --> 00:27:54,270
真的只是因为像面包屑。

588
00:27:54,270 --> 00:27:56,260
>> 有一点线索编译器。

589
00:27:56,260 --> 00:27:58,860
我不知道这是什么呢
然而，但我看好你

590
00:27:58,860 --> 00:28:00,260
它会存在也说不定。

591
00:28:00,260 --> 00:28:04,010
这就是为什么这个line--中
行16--以分号结束。

592
00:28:04,010 --> 00:28:05,486
它是多余的设计。

593
00:28:05,486 --> 00:28:05,986
是吗？

594
00:28:05,986 --> 00:28:11,340

595
00:28:11,340 --> 00:28:14,360
>> 如果没有你的链接库
到the--哦，好问题。

596
00:28:14,360 --> 00:28:17,350
夏普包含头文件包含。

597
00:28:17,350 --> 00:28:20,040
需要be--应该差不多
总是在最高层

598
00:28:20,040 --> 00:28:23,270
对于similar--的文件
正是由于同样的原因，是的。

599
00:28:23,270 --> 00:28:26,430
因为在标准
IO.H是名副其实的行

600
00:28:26,430 --> 00:28:30,560
像这样，但用的字的printf和
其参数和返回类型。

601
00:28:30,560 --> 00:28:33,310
所以做犀利包括了
在这里，你是什么字面上做

602
00:28:33,310 --> 00:28:36,380
是复制和粘贴的内容
别人的东西写了上面。

603
00:28:36,380 --> 00:28:39,660
从而cluing代码到
事实上，这些功能确实存在。

604
00:28:39,660 --> 00:28:40,160
是吗？

605
00:28:40,160 --> 00:28:47,520

606
00:28:47,520 --> 00:28:48,260
>> 当然可以。

607
00:28:48,260 --> 00:28:51,690
所以有一个非常聪明和正确的
解决办法是，你知道吗？

608
00:28:51,690 --> 00:28:53,760
我不知道什么是
原型是的，但我知道

609
00:28:53,760 --> 00:28:56,390
如果我知道，C是刚
哑和反思从上到下。

610
00:28:56,390 --> 00:28:57,820
好了，让我们给它想要的东西。

611
00:28:57,820 --> 00:29:01,650
让我们来削减该代码，粘贴起来
顶了，现在主要推楼下。

612
00:29:01,650 --> 00:29:03,470
这也将解决这个问题。

613
00:29:03,470 --> 00:29:07,409
>> 但是你可以很容易地拿出
一个场景，其中A需要调用B，

614
00:29:07,409 --> 00:29:10,075
也许B调用回答：这
一些所谓的递归，

615
00:29:10,075 --> 00:29:11,370
我们会回来的。

616
00:29:11,370 --> 00:29:13,911
它可能是也可能不是一个好
的事情，但你绝对可以

617
00:29:13,911 --> 00:29:15,110
打破这种溶液。

618
00:29:15,110 --> 00:29:17,690
>> 而且，我会
声称曲风，

619
00:29:17,690 --> 00:29:20,760
尤其是当你的程序
成为这个漫长而漫长，

620
00:29:20,760 --> 00:29:23,064
它只是超方便
把主要的顶部

621
00:29:23,064 --> 00:29:25,730
因为它的东西最
程序员要关心。

622
00:29:25,730 --> 00:29:28,150
因此，这是一个有点清洁，
可以说，这样做的方式

623
00:29:28,150 --> 00:29:30,380
我本来就
与原型甚至

624
00:29:30,380 --> 00:29:33,396
虽然它看起来有点
多余的第一眼。

625
00:29:33,396 --> 00:29:33,895
是吗？

626
00:29:33,895 --> 00:29:36,472

627
00:29:36,472 --> 00:29:37,680
对不起，你可以说它更响亮？

628
00:29:37,680 --> 00:29:45,650

629
00:29:45,650 --> 00:29:49,580
>> 如果开关的位置
实施和原型？

630
00:29:49,580 --> 00:29:51,270
所以这是一个很好的问题。

631
00:29:51,270 --> 00:29:53,780
如果重新申报下来
在这里，让我们看看会发生什么。

632
00:29:53,780 --> 00:29:55,530
所以，如果我把这个降
在这里，你说的。

633
00:29:55,530 --> 00:29:57,860

634
00:29:57,860 --> 00:29:58,360
哦，对不起。

635
00:29:58,360 --> 00:29:58,859
再大一点？

636
00:29:58,859 --> 00:30:02,000

637
00:30:02,000 --> 00:30:04,011
更响。

638
00:30:04,011 --> 00:30:04,760
哦，好问题。

639
00:30:04,760 --> 00:30:05,860
难道失效的功能？

640
00:30:05,860 --> 00:30:08,901
你知道，毕竟这些年来，我
从来没有把原型之后。

641
00:30:08,901 --> 00:30:13,810
因此，让我们做制作功能 -  1
以后这样做。

642
00:30:13,810 --> 00:30:15,279
>> [嘀咕]

643
00:30:15,279 --> 00:30:16,320
戴维·J·马兰：哦，等等。

644
00:30:16,320 --> 00:30:17,944
我们还是得把一切都往上顶。

645
00:30:17,944 --> 00:30:21,400
因此，让我们做到这一点在这里，如果我
正确理解你的问题。

646
00:30:21,400 --> 00:30:24,700
我把一切，包括
上述主要原型，

647
00:30:24,700 --> 00:30:28,180
但我把原型
下面的执行。

648
00:30:28,180 --> 00:30:33,190
>> 所以，如果我做一个，我越来越
回一个error--未使用的变量n。

649
00:30:33,190 --> 00:30:37,280

650
00:30:37,280 --> 00:30:37,860
哦，还有。

651
00:30:37,860 --> 00:30:38,360
谢谢。

652
00:30:38,360 --> 00:30:39,430
让我们来看看，我们摆脱了这一点。

653
00:30:39,430 --> 00:30:41,304
这是一个不同的错误，
所以让我们忽略了这一点。

654
00:30:41,304 --> 00:30:43,910
让我们真的很快重拍这个。

655
00:30:43,910 --> 00:30:48,100
>> 好了，数据的说法不
使用格式字符串

656
00:30:48,100 --> 00:30:52,310
N--哦，那是因为
我改变了这些在这里。

657
00:30:52,310 --> 00:30:55,885
好吧，我们知道答案是什么
会to--没事，我们开始吧。

658
00:30:55,885 --> 00:31:00,560
嗯，谢谢你的肯定。

659
00:31:00,560 --> 00:31:03,430
好吧，我会解决这个问题的代码
after--忽视这个特殊的bug

660
00:31:03,430 --> 00:31:08,300
因为这was--它的工作原理就是答案。

661
00:31:08,300 --> 00:31:11,560
>> 因此，它不会覆盖
你刚刚完成的。

662
00:31:11,560 --> 00:31:14,800
我怀疑编译器
被写入以这样的方式

663
00:31:14,800 --> 00:31:18,420
它无视你的原型
因为身体，可以这么说，

664
00:31:18,420 --> 00:31:20,922
的功能有已
已经实施了较高。

665
00:31:20,922 --> 00:31:23,380
我会以实际咨询
编译器的手册

666
00:31:23,380 --> 00:31:26,171
以了解是否有任何其他
言下之意，但乍一看

667
00:31:26,171 --> 00:31:29,290
只是尝试和实验，
似乎有任何影响。

668
00:31:29,290 --> 00:31:30,730
这个问题问得好。

669
00:31:30,730 --> 00:31:33,660
>> 现在让我们锐意进取，动
远离副作用

670
00:31:33,660 --> 00:31:36,660
是函数，这样做
视觉上的printf在屏幕上，

671
00:31:36,660 --> 00:31:38,090
但不返回值。

672
00:31:38,090 --> 00:31:41,550
和功能有回报
像我们价值观刚才看到几个。

673
00:31:41,550 --> 00:31:45,350
我们已经看到的范围这个概念，
我们会一次又一次地看到这一点。

674
00:31:45,350 --> 00:31:47,210
但是现在，再次，
用经验法则

675
00:31:47,210 --> 00:31:51,410
一个变量只能用于
的最近打开里面

676
00:31:51,410 --> 00:31:54,350
与封闭的大括号，因为我们
在那个特殊的例子中看到。

677
00:31:54,350 --> 00:31:56,910
>> 正如你所指出的，
有一个ability--

678
00:31:56,910 --> 00:32:00,040
你能解决其中的一些问题
通过将全局变量

679
00:32:00,040 --> 00:32:01,290
在文件的最上方。

680
00:32:01,290 --> 00:32:03,630
但在几乎所有情况下
我们看不惯的是，

681
00:32:03,630 --> 00:32:06,170
而事实上，即使不走
到了现在的解决方案。

682
00:32:06,170 --> 00:32:09,890
因此，现在的外卖是，
变量的作用域这个概念。

683
00:32:09,890 --> 00:32:13,430
>> 但是，现在让我们来看看另一个
实际上是在寻找干地

684
00:32:13,430 --> 00:32:15,810
在一些非常有趣的
实施细则。

685
00:32:15,810 --> 00:32:17,810
我们怎么可能代表的信息。

686
00:32:17,810 --> 00:32:20,370
我们已经看了这
在类的第一个星期。

687
00:32:20,370 --> 00:32:23,320
纵观二进制文件，并
提醒小数的自己。

688
00:32:23,320 --> 00:32:28,310
>> 但是从上周还记得C有
不同的数据类型和多束，

689
00:32:28,310 --> 00:32:30,600
但最有用的
现在可能是这些。

690
00:32:30,600 --> 00:32:36,030
一个CHAR或字符，这恰好
是一个字节或8位总。

691
00:32:36,030 --> 00:32:40,060
这就是说，尺寸
一个char的仅仅是一个字节。

692
00:32:40,060 --> 00:32:45,370
一个字节是8比特，所以这意味着
我们可以代表多少个字符。

693
00:32:45,370 --> 00:32:47,320
多少个字母或
键盘上的符号

694
00:32:47,320 --> 00:32:49,210
如果我们有一个字节或8位。

695
00:32:49,210 --> 00:32:51,546
回想零一周。

696
00:32:51,546 --> 00:32:53,420
如果你有8位，
多少总价值

697
00:32:53,420 --> 00:32:55,503
可以代表与
零和一的模式？

698
00:32:55,503 --> 00:32:58,170

699
00:32:58,170 --> 00:33:00,260
埃德蒙顿不止于此。

700
00:33:00,260 --> 00:33:03,490
所以，如果你总256
从零开始计数。

701
00:33:03,490 --> 00:33:07,120
所以，如果你有八个bits--所以如果我们
再有我们的二进制泡在这里，

702
00:33:07,120 --> 00:33:12,180
我们可以把这些灯泡上
和关闭在任何256个独特的图案。

703
00:33:12,180 --> 00:33:13,640
>> 现在，这是有点问题的。

704
00:33:13,640 --> 00:33:16,857
没有那么多的英语，
浪漫的语言，但可以肯定

705
00:33:16,857 --> 00:33:19,190
当你介绍，为
例如，亚洲语言，这

706
00:33:19,190 --> 00:33:22,580
比喜欢更符号
26个英文字母。

707
00:33:22,580 --> 00:33:24,390
实际上，我们可能需要
大于一个字节以上。

708
00:33:24,390 --> 00:33:28,240
幸好在
近年来社会

709
00:33:28,240 --> 00:33:31,040
使用采用了其它标准
每次充电多于一个字节。

710
00:33:31,040 --> 00:33:34,210
>> 不过，现在在C中，默认
仅仅是一个字节或8位。

711
00:33:34,210 --> 00:33:38,195
一个整数，同时，在4
字节，否则称为32位。

712
00:33:38,195 --> 00:33:41,320
这意味着什么是最大的可能
数，我们可以用一个int代表

713
00:33:41,320 --> 00:33:41,820
显然？

714
00:33:41,820 --> 00:33:44,426

715
00:33:44,426 --> 00:33:45,050
有十亿。

716
00:33:45,050 --> 00:33:46,760
所以它的四大十亿给予或采取。

717
00:33:46,760 --> 00:33:49,840
2至第32的功率，如果我们
不承担任何负数

718
00:33:49,840 --> 00:33:52,530
而只使用一切积极
号，这四个十亿

719
00:33:52,530 --> 00:33:53,730
给予或采取可能性。

720
00:33:53,730 --> 00:33:57,890
浮点型，同时，在不同类型的
数据类型C.它仍然是一个数目，

721
00:33:57,890 --> 00:33:58,990
但它是一个实数。

722
00:33:58,990 --> 00:34:00,660
东西带小数点。

723
00:34:00,660 --> 00:34:03,000
而事实证明，
C也可以用四个字节

724
00:34:03,000 --> 00:34:05,340
来表示浮点值。

725
00:34:05,340 --> 00:34:09,420
>> 不幸的是有多少浮动
点值是存在的世界？

726
00:34:09,420 --> 00:34:11,582
多少个实数有哪些？

727
00:34:11,582 --> 00:34:13,540
有一个无限
号，并为这一问题

728
00:34:13,540 --> 00:34:15,164
有一个整数无限次数。

729
00:34:15,164 --> 00:34:18,070
所以我们种已
在这里自己挖一个洞。

730
00:34:18,070 --> 00:34:21,780
由此显然computers--在
用C写的关于他们 - 至少计划

731
00:34:21,780 --> 00:34:24,110
只能算作高
four十亿而奋斗，

732
00:34:24,110 --> 00:34:26,260
和浮点值
只能明显

733
00:34:26,260 --> 00:34:28,330
有一定的精度有限的。

734
00:34:28,330 --> 00:34:30,810
只有这么多位数后
他们的小数点。

735
00:34:30,810 --> 00:34:32,822
>> 因为，当然，如果
你只有32位，

736
00:34:32,822 --> 00:34:36,030
我不知道我们要如何去
代表真正的numbers--可能

737
00:34:36,030 --> 00:34:37,409
与不同类型的图案。

738
00:34:37,409 --> 00:34:40,030
但是有一定的有限
这样的图案的数目，

739
00:34:40,030 --> 00:34:41,830
所以在这里也一样，这是有问题的。

740
00:34:41,830 --> 00:34:43,710
>> 现在我们可以稍微避免此问题。

741
00:34:43,710 --> 00:34:45,710
如果您不使用浮动，
你可以使用一个双

742
00:34:45,710 --> 00:34:50,230
在C中，它给你八个字节，这
是零的方式更可能的模式

743
00:34:50,230 --> 00:34:50,730
及的。

744
00:34:50,730 --> 00:34:55,199
但它仍然是有限的，这是怎么回事
如果你写的软件有问题

745
00:34:55,199 --> 00:34:57,670
图形或花哨
数学公式。

746
00:34:57,670 --> 00:35:00,410
所以，你可能真的想
以计数大于。

747
00:35:00,410 --> 00:35:05,640
长long--愚蠢named--
也是8个字节或64位，

748
00:35:05,640 --> 00:35:10,260
这是两次只要一个int，
它是一个长整型值。

749
00:35:10,260 --> 00:35:15,655
>> 玩转fact--如果一个int是4个字节，
多久是一个长期在C中一般？

750
00:35:15,655 --> 00:35:18,290

751
00:35:18,290 --> 00:35:21,560
另外四个字节，但
长长的8个字节，

752
00:35:21,560 --> 00:35:23,050
这是由于历史原因。

753
00:35:23,050 --> 00:35:26,450
>> 但现在的外卖
就是这样的数据有

754
00:35:26,450 --> 00:35:29,625
在computer--这是可以代表
与电物理设备，

755
00:35:29,625 --> 00:35:32,190
它一般驾驶
这些零和ones--

756
00:35:32,190 --> 00:35:34,320
同的精度有限的量。

757
00:35:34,320 --> 00:35:35,620
那么，有什么问题呢？

758
00:35:35,620 --> 00:35:37,480
>> 那么有一个问题
的整数溢出。

759
00:35:37,480 --> 00:35:39,780
不只是在C，但在
电脑一般。

760
00:35:39,780 --> 00:35:42,590
例如，如果此
是一个字节值得一bit--

761
00:35:42,590 --> 00:35:45,120
因此，如果这是8 bit--所有
这些都是一等一的。

762
00:35:45,120 --> 00:35:47,300
什么号码是这
较，如果我们假设

763
00:35:47,300 --> 00:35:50,730
它是二进制的所有正面的价值观？

764
00:35:50,730 --> 00:35:54,410
>> 255，这不是256，因为
零是最小的数字。

765
00:35:54,410 --> 00:35:56,760
所以255是最高的
之一，但问题

766
00:35:56,760 --> 00:36:00,330
是假设，我想
增加此变量

767
00:36:00,330 --> 00:36:04,030
，以8位总
如果我要增加它。

768
00:36:04,030 --> 00:36:07,160
>> 好吧，只要我添加
一到所有的这些的，

769
00:36:07,160 --> 00:36:10,500
你或许可以想像visually--刚
就像拿着一个用decimals--

770
00:36:10,500 --> 00:36:12,300
有什么地方要流向左侧。

771
00:36:12,300 --> 00:36:15,590
事实上，如果我加号
一到这一点，什么在二进制情况

772
00:36:15,590 --> 00:36:17,670
是，它溢出回零。

773
00:36:17,670 --> 00:36:21,730
>> 所以，如果你只use--不是一个整数，
但一个字节数的整数

774
00:36:21,730 --> 00:36:27,170
在程序中，只要default--
你到了250，251，252，253，254，

775
00:36:27,170 --> 00:36:32,710
255-- 0 255来后，
这可能不是什么

776
00:36:32,710 --> 00:36:34,790
用户会期望。

777
00:36:34,790 --> 00:36:39,620
>> 现在同时在浮点运算的世界，
你也有类似的问题。

778
00:36:39,620 --> 00:36:42,670
没有那么多的大number--
虽然这仍然是一个问题。

779
00:36:42,670 --> 00:36:45,360
但随着精度的量
你可以代表。

780
00:36:45,360 --> 00:36:49,490
因此，让我们来看看这个例子
这里也从今天的源代码 - 

781
00:36:49,490 --> 00:36:52,070
浮法0.c。

782
00:36:52,070 --> 00:36:54,280
>> 并注意到这是一个超级
简单的程序，

783
00:36:54,280 --> 00:36:56,580
显然应该打印出什么样的价值？

784
00:36:56,580 --> 00:37:00,777

785
00:37:00,777 --> 00:37:04,110
那你打赌这是怎么回事打印
即使有一点新的语法

786
00:37:04,110 --> 00:37:05,540
在这里吗？

787
00:37:05,540 --> 00:37:06,700
所以希望0.1。

788
00:37:06,700 --> 00:37:10,000
这样的十分之一，相当于
因为我在做1除以10。

789
00:37:10,000 --> 00:37:12,430
我存储的答案
在一个变量称为F。

790
00:37:12,430 --> 00:37:15,850
该变量是float类型，哪
就是我刚才提出了一个关键字存在。

791
00:37:15,850 --> 00:37:18,910
>> 我们还没有看到过，但
这是一种简洁的方式在printf中

792
00:37:18,910 --> 00:37:22,110
指定多少个数字，你
希望以后小数点看到的。

793
00:37:22,110 --> 00:37:25,020
所以，这个符号的意思只是
这里是一个占位符。

794
00:37:25,020 --> 00:37:27,900
这是一个浮点
值了，呵呵，顺便说一下，

795
00:37:27,900 --> 00:37:31,389
小数点与表现出来
小数点后一个数字。

796
00:37:31,389 --> 00:37:33,180
所以这是数
的显著数字，

797
00:37:33,180 --> 00:37:34,650
可以这么说，你可能想要的。

798
00:37:34,650 --> 00:37:40,450
>> 因此，让我继续做
使浮球-0，./float-0，

799
00:37:40,450 --> 00:37:46,660
显然1除以10是0.0。

800
00:37:46,660 --> 00:37:47,760
现在，这是为什么？

801
00:37:47,760 --> 00:37:51,380
>> 好了，电脑正在
我从字面上看，我已经写了1

802
00:37:51,380 --> 00:37:56,680
我写的10，并以此来猜测什么
对于这两个假定的数据类型

803
00:37:56,680 --> 00:37:58,440
值？

804
00:37:58,440 --> 00:38:00,970
一个int，它在技术上
东西有点不同。

805
00:38:00,970 --> 00:38:04,150
这通常是一个漫长的，但它
最终的积分值。

806
00:38:04,150 --> 00:38:06,030
不是一个浮点值。

807
00:38:06,030 --> 00:38:09,456
>> 这是说，如果这
是一个int，这是一个int，

808
00:38:09,456 --> 00:38:11,830
的问题是，计算机
不具有的能力

809
00:38:11,830 --> 00:38:13,680
即使存储小数点。

810
00:38:13,680 --> 00:38:16,430
所以当你做1分
10使用整数

811
00:38:16,430 --> 00:38:20,950
对于这两种分子和
分母，答案应该是0.1。

812
00:38:20,950 --> 00:38:24,930
但computer--因为
这些都是integers--

813
00:38:24,930 --> 00:38:27,430
不知道做什么用的0.1。

814
00:38:27,430 --> 00:38:30,010
>> 那么，什么是很清楚在做什么？

815
00:38:30,010 --> 00:38:33,120
它只是把它扔了，
而我所看到的最终

816
00:38:33,120 --> 00:38:38,830
0.0只是因为我坚持
printf的告诉我小数点后一位数。

817
00:38:38,830 --> 00:38:41,740
但问题是，如果
由一个整数除以一个整数，

818
00:38:41,740 --> 00:38:44,347
你会被定义get--
的C--的整数。

819
00:38:44,347 --> 00:38:46,680
而且它不会做
东西不错，方便

820
00:38:46,680 --> 00:38:49,040
像圆起来的
最近的一个向上或向下。

821
00:38:49,040 --> 00:38:51,860
这将截断
小数点后的一切。

822
00:38:51,860 --> 00:38:54,030
>> 所以只是凭直觉，
什么可能是一个修复？

823
00:38:54,030 --> 00:38:55,351
什么是这里的简单的解决办法？

824
00:38:55,351 --> 00:38:55,850
是吗？

825
00:38:55,850 --> 00:39:00,570

826
00:39:00,570 --> 00:39:01,100
没错。

827
00:39:01,100 --> 00:39:04,200
为什么我们不把这些作为
有效浮点值

828
00:39:04,200 --> 00:39:05,860
把他们变成浮筒或双打。

829
00:39:05,860 --> 00:39:10,500
现在，如果我这样做让花车-0，
或者，如果我编译的花车-1，

830
00:39:10,500 --> 00:39:12,570
这是相同的
什么只是建议。

831
00:39:12,570 --> 00:39:16,400
现在我做花车-0，现在我得到我的0.1。

832
00:39:16,400 --> 00:39:17,234
>> 现在，这是惊人的。

833
00:39:17,234 --> 00:39:19,441
但现在我该怎么办
东西有点不同。

834
00:39:19,441 --> 00:39:22,280
我很好奇，想看看什么是真正
正在进行的引擎盖下面，

835
00:39:22,280 --> 00:39:26,050
我要去把它打印出来
出到28位小数。

836
00:39:26,050 --> 00:39:29,730
我想真正看到
0.1000--的infinite--

837
00:39:29,730 --> 00:39:32,710
在0.1之后[听不清] 27零。

838
00:39:32,710 --> 00:39:34,740
>> 那么让我们来看看这是
我确实得到。

839
00:39:34,740 --> 00:39:39,430
请彩车-0相同的文件。

840
00:39:39,430 --> 00:39:41,150
./floats-0。

841
00:39:41,150 --> 00:39:44,380
让我们放大了戏剧性的答案。

842
00:39:44,380 --> 00:39:49,980
这一切的时候，你一直在思考
1除以10为10％，或0.1。

843
00:39:49,980 --> 00:39:50,810
它不是。

844
00:39:50,810 --> 00:39:53,210
至少到目前为止为
电脑的关注。

845
00:39:53,210 --> 00:39:57,060
>> 现在why--确定，这是完整的
谎言1除以10是0.1。

846
00:39:57,060 --> 00:39:59,710
但why--即不
外卖今天。

847
00:39:59,710 --> 00:40:04,010
那么，为什么在电脑认为，
不像我们大家在房间里，

848
00:40:04,010 --> 00:40:06,870
即1除以10是
实际上是疯狂的价值？

849
00:40:06,870 --> 00:40:10,620
什么是电脑做显然是？

850
00:40:10,620 --> 00:40:12,490
那是什么？

851
00:40:12,490 --> 00:40:13,785
>> 它不会溢出，本身。

852
00:40:13,785 --> 00:40:15,910
溢出通常是当
您环绕的值。

853
00:40:15,910 --> 00:40:18,970
这是这个问题的不精确
在浮点值

854
00:40:18,970 --> 00:40:22,220
在你只有32
或者甚至64位。

855
00:40:22,220 --> 00:40:25,230
但是，如果有一个无限
实numbers--数

856
00:40:25,230 --> 00:40:27,940
带小数点的数字
和数字thereafter--肯定

857
00:40:27,940 --> 00:40:29,380
你不能代表所有的人。

858
00:40:29,380 --> 00:40:32,870
所以电脑给
我们最接近的匹配

859
00:40:32,870 --> 00:40:37,090
到的值可以表示使用该
很多位，其实我想要的值，

860
00:40:37,090 --> 00:40:38,690
这是0.1。

861
00:40:38,690 --> 00:40:40,685
>> 不幸的是，如果
开始做数学，或者你

862
00:40:40,685 --> 00:40:44,360
开始涉及这些类型的浮动
在重要的programs--点值

863
00:40:44,360 --> 00:40:46,770
财务软件，
军用软件 - 什么

864
00:40:46,770 --> 00:40:49,090
其中知觉
可能是非常重要的。

865
00:40:49,090 --> 00:40:51,520
而你开始添加
这样的数字，并且开始

866
00:40:51,520 --> 00:40:54,050
运行软件
与真正的大投入

867
00:40:54,050 --> 00:40:56,890
或大量的时间和地段
年天或大量的，

868
00:40:56,890 --> 00:41:01,060
这些小小的失误
一定可以积少成多随着时间的推移。

869
00:41:01,060 --> 00:41:04,252
>> 现在，顺便说一句，如果你曾经
看过超人3或办公空间

870
00:41:04,252 --> 00:41:05,960
你可能还记得
如何将这些家伙偷了

871
00:41:05,960 --> 00:41:08,668
大量的资金从他们的计算机
使用浮点值

872
00:41:08,668 --> 00:41:11,290
并加入了少许
余，希望那部电影

873
00:41:11,290 --> 00:41:12,390
现在更有意义。

874
00:41:12,390 --> 00:41:14,930
这是他们
暗指在那部电影。

875
00:41:14,930 --> 00:41:16,710
事实上，最
公司不会看

876
00:41:16,710 --> 00:41:18,600
在一定次数后，
小数位，

877
00:41:18,600 --> 00:41:20,009
但这些都是仙分数。

878
00:41:20,009 --> 00:41:22,550
所以，你开始增加起来，
你开始赚了很多钱

879
00:41:22,550 --> 00:41:23,424
在您的银行帐户。

880
00:41:23,424 --> 00:41:25,160
这就是办公空间解释。

881
00:41:25,160 --> 00:41:28,220
>> 现在，不幸的是超越
办公空间，有

882
00:41:28,220 --> 00:41:31,794
有一些令人不安的合法
和显著影响

883
00:41:31,794 --> 00:41:33,710
这些种的
基本的设计决策，

884
00:41:33,710 --> 00:41:35,990
的原因，事实上1
我们使用C语言在使用过程中

885
00:41:35,990 --> 00:41:39,640
是这样，你真的有这个理由
最多的电脑如何工作的了解，

886
00:41:39,640 --> 00:41:42,440
软件是如何工作的，并没有
拿任何东西是理所当然的。

887
00:41:42,440 --> 00:41:45,820
>> 事实上不幸的是，即使有
这个基本的了解，

888
00:41:45,820 --> 00:41:47,370
我们人类犯错误。

889
00:41:47,370 --> 00:41:51,310
而我想我会分享的是
这八年分钟的视频在这里拍摄

890
00:41:51,310 --> 00:41:56,980
从现代奇迹的插曲，这是
教育展上是如何工作的

891
00:41:56,980 --> 00:42:00,370
该画两张图片
当不当使用

892
00:42:00,370 --> 00:42:02,540
和谅解
浮点值

893
00:42:02,540 --> 00:42:05,610
导致一些显著
不幸的结果。

894
00:42:05,610 --> 00:42:06,363
让我们一起来看看。

895
00:42:06,363 --> 00:42:07,029
[视频回放]

896
00:42:07,029 --> 00:42:11,290
 - 我们现在回到“工程
在现代奇迹灾害“。

897
00:42:11,290 --> 00:42:12,940
电脑。

898
00:42:12,940 --> 00:42:15,580
我们都来接受
往往令人沮丧的问题，

899
00:42:15,580 --> 00:42:20,960
得到了他们 - 臭虫，病毒和
小型软件价格glitches--

900
00:42:20,960 --> 00:42:23,100
支付的便利性。

901
00:42:23,100 --> 00:42:27,770
但在高科技和高速
军事和航天计划的应用，

902
00:42:27,770 --> 00:42:32,780
可以最小的问题
被放大成灾难。

903
00:42:32,780 --> 00:42:38,880
>> 1996年6月4日，科学家准备
发动无人机阿丽亚娜5型火箭。

904
00:42:38,880 --> 00:42:41,190
它携带的科学
卫星设计

905
00:42:41,190 --> 00:42:44,570
建立精确的如何
地球磁场的相互作用

906
00:42:44,570 --> 00:42:47,380
与太阳风。

907
00:42:47,380 --> 00:42:50,580
火箭是专为
欧洲航天局，

908
00:42:50,580 --> 00:42:54,400
和从它的设施升空
在法属圭亚那的海岸。

909
00:42:54,400 --> 00:42:57,520
>> -at约37秒进入
飞行中，他们首先

910
00:42:57,520 --> 00:42:59,070
发现了一些打算错了。

911
00:42:59,070 --> 00:43:02,240
该喷嘴被旋转
在某种程度上，他们真的不应该。

912
00:43:02,240 --> 00:43:06,550
大约40秒后进入飞行
明确车辆遇到了麻烦，

913
00:43:06,550 --> 00:43:08,820
而当他们做的
决定摧毁它。

914
00:43:08,820 --> 00:43:12,370
范围内安全官员，与
巨大的胆量，按下按钮

915
00:43:12,370 --> 00:43:18,030
并炸毁了火箭，才能够
成为危害公众安全。

916
00:43:18,030 --> 00:43:21,010
>>  - 这是少女
阿丽亚娜5号的航程，

917
00:43:21,010 --> 00:43:23,920
其破坏了
地方，因为这个安全漏洞

918
00:43:23,920 --> 00:43:25,932
嵌入火箭的软件。

919
00:43:25,932 --> 00:43:27,640
在-The问题
阿丽亚娜是，有

920
00:43:27,640 --> 00:43:30,500
是一个数字，需要
64位来表示，

921
00:43:30,500 --> 00:43:33,560
他们想转换
它以一个16位的数字。

922
00:43:33,560 --> 00:43:36,820
他们假定数
永远不会很大。

923
00:43:36,820 --> 00:43:40,940
大多数的这些数字中
64位数字是零。

924
00:43:40,940 --> 00:43:42,450
他们错了。

925
00:43:42,450 --> 00:43:45,000
>> 一-The无力
软件程序来接受

926
00:43:45,000 --> 00:43:49,460
所产生的那种数
另一种是在失败的根源。

927
00:43:49,460 --> 00:43:54,260
软件开发已经成为一个
的新技术非常昂贵的部分。

928
00:43:54,260 --> 00:43:57,060
阿丽亚娜火箭4有
是非常成功的。

929
00:43:57,060 --> 00:44:01,600
这么多的创造了软件
它也被用在阿丽亚娜5。

930
00:44:01,600 --> 00:44:04,790
>> -The基本问题
这是阿丽亚娜5。

931
00:44:04,790 --> 00:44:11,200
是faster--加速更快，
该软件并没有占到一点。

932
00:44:11,200 --> 00:44:14,910
>> 火箭-The破坏
是一个巨大的金融灾难。

933
00:44:14,910 --> 00:44:18,630
所有因分软件错误。

934
00:44:18,630 --> 00:44:21,160
但是，这不是第一次
实时数据转换问题

935
00:44:21,160 --> 00:44:24,770
困扰了现代火箭技术。

936
00:44:24,770 --> 00:44:28,020
>>  - 在1991年的开始
第一次海湾战争中，

937
00:44:28,020 --> 00:44:30,540
爱国者导弹
经历了相似类型

938
00:44:30,540 --> 00:44:32,465
一些转换问题。

939
00:44:32,465 --> 00:44:36,760
其结果是28 people-- 28
美国soldiers--被打死，

940
00:44:36,760 --> 00:44:39,010
约百人受伤。

941
00:44:39,010 --> 00:44:42,830
当爱国者，这本来是
防止进入的飞毛腿导弹，

942
00:44:42,830 --> 00:44:45,780
没有发射导弹。

943
00:44:45,780 --> 00:44:51,610
>>  - 当伊拉克入侵科威特，美国和
在1991年年初推出沙漠风暴，

944
00:44:51,610 --> 00:44:55,720
爱国者导弹部署
保护沙特阿拉伯和以色列

945
00:44:55,720 --> 00:44:59,180
来自伊拉克的飞毛腿导弹袭击。

946
00:44:59,180 --> 00:45:03,080
爱国者是美国中程
表面 - 空气系统

947
00:45:03,080 --> 00:45:06,530
由雷神公司制造。

948
00:45:06,530 --> 00:45:09,500
>> 爱国者的-The大小
拦截itself--

949
00:45:09,500 --> 00:45:14,705
它是关于大约20英尺长，
而它的重量约2000磅。

950
00:45:14,705 --> 00:45:19,090
它承载着约弹头，
我认为这是大约150磅。

951
00:45:19,090 --> 00:45:23,880
而弹头本身
高爆发力，这

952
00:45:23,880 --> 00:45:26,700
有他周围的碎片。

953
00:45:26,700 --> 00:45:31,630
因此，弹头的外壳是
设计为像一个大型铅弹。

954
00:45:31,630 --> 00:45:34,040
>> -The导弹进行
4每个集装箱，

955
00:45:34,040 --> 00:45:37,170
并通过一辆半挂车运送。

956
00:45:37,170 --> 00:45:44,880
>> -The爱国者反导系统
回到现在，至少20年。

957
00:45:44,880 --> 00:45:48,380
它最初的设计
作为防空导弹

958
00:45:48,380 --> 00:45:50,810
击落敌方飞机。

959
00:45:50,810 --> 00:45:54,410
在第一次海湾战争
当战争来了，

960
00:45:54,410 --> 00:45:59,650
陆军希望用它来
击落飞毛腿导弹，不是飞机。

961
00:45:59,650 --> 00:46:03,580
伊拉克空军
没有那么多的问题，

962
00:46:03,580 --> 00:46:06,590
但陆军担心飞毛腿导弹。

963
00:46:06,590 --> 00:46:10,120
因此，他们试图
升级爱国者。

964
00:46:10,120 --> 00:46:12,740
>> -Intercepting敌人
导弹在5马赫旅行

965
00:46:12,740 --> 00:46:15,670
将要被足够的挑战性。

966
00:46:15,670 --> 00:46:18,440
但是，当爱国者
被送往投入服务，

967
00:46:18,440 --> 00:46:22,580
军队并不知道
伊拉克修饰

968
00:46:22,580 --> 00:46:25,880
使他们的飞毛腿近
不可能的。

969
00:46:25,880 --> 00:46:30,690
>>  - 什么事是飞毛腿的
要来的是不稳定的。

970
00:46:30,690 --> 00:46:32,000
他们摇摇晃晃。

971
00:46:32,000 --> 00:46:37,210
这样做的原因是Iraqis--
为了得到600公里出

972
00:46:37,210 --> 00:46:41,680
300公里的范围内missile--的
把重量从前面的弹头，

973
00:46:41,680 --> 00:46:43,340
并提出了弹头更轻。

974
00:46:43,340 --> 00:46:48,490
所以，现在爱国者的苦思
在飞毛腿，而大部分的时间 - 的

975
00:46:48,490 --> 00:46:52,880
绝大多数的
时间 - 它只是由飞毛腿飞。

976
00:46:52,880 --> 00:46:57,120
>>  - 一旦爱国者系统运营商
实现了爱国者错过了目标，

977
00:46:57,120 --> 00:47:01,630
他们引爆了爱国者的战斗部
为避免可能出现的人员伤亡，如果它

978
00:47:01,630 --> 00:47:04,440
被允许倒在地上。

979
00:47:04,440 --> 00:47:08,700
>>  - 即是大多数人所看到的
在天空的大火球，

980
00:47:08,700 --> 00:47:14,180
和误解成
飞毛腿弹头的拦截。

981
00:47:14,180 --> 00:47:18,020
>>  - 虽然在夜晚的天空，爱国者
似乎是成功地破坏

982
00:47:18,020 --> 00:47:23,280
飞毛腿，在达兰可以有
不要误会，它的性能。

983
00:47:23,280 --> 00:47:27,930
有爱国者的雷达系统
轨道传入飞毛腿的损失

984
00:47:27,930 --> 00:47:30,260
从不因推出
一个软件缺陷。

985
00:47:30,260 --> 00:47:34,060

986
00:47:34,060 --> 00:47:38,880
>> 是谁最先发现的以色列人
该系统不再是上，

987
00:47:38,880 --> 00:47:41,130
更大的时间差异成为。

988
00:47:41,130 --> 00:47:44,770
由于嵌入式时钟
在系统的计算机。

989
00:47:44,770 --> 00:47:48,190
>>  - 关于前两周
悲剧发生在宰赫兰，

990
00:47:48,190 --> 00:47:50,720
以色列人报
国防部

991
00:47:50,720 --> 00:47:52,410
该系统是浪费时间。

992
00:47:52,410 --> 00:47:54,410
经过大约八个小时
磨合，他们发现

993
00:47:54,410 --> 00:47:57,690
该系统的变
明显地较不准确。

994
00:47:57,690 --> 00:48:01,850
国防部回应
告诉所有的爱国者电池

995
00:48:01,850 --> 00:48:04,800
不要离开系统
在很长一段时间。

996
00:48:04,800 --> 00:48:06,980
他们从来不说什么了很长时间了。

997
00:48:06,980 --> 00:48:09,140
8个小时，10个小时，上千小时。

998
00:48:09,140 --> 00:48:11,300
没有人知道。

999
00:48:11,300 --> 00:48:13,320
>> -The爱国者电池
驻扎在军营

1000
00:48:13,320 --> 00:48:18,310
在宰赫兰及内部缺陷
时钟已经对超过100小时

1001
00:48:18,310 --> 00:48:21,520
2月25日的夜晚。

1002
00:48:21,520 --> 00:48:25,792
>>  - 它跟踪的时间精度
的约十分之一秒。

1003
00:48:25,792 --> 00:48:27,950
第二，现在的十分之一
是一个有趣的数字

1004
00:48:27,950 --> 00:48:31,850
因为它不能表示
二进制确切地说，这

1005
00:48:31,850 --> 00:48:36,500
意味着它不能准确地表达
在任何现代数字计算机。

1006
00:48:36,500 --> 00:48:41,070
很难相信，但
用这个作为一个例子。

1007
00:48:41,070 --> 00:48:43,420
>> 让我们数的三分之一。

1008
00:48:43,420 --> 00:48:47,330
三分之一不能
正是以十进制表示。

1009
00:48:47,330 --> 00:48:52,060
三分之一是0.333
持续了无穷大。

1010
00:48:52,060 --> 00:48:56,420
有没有办法做到这一点与
绝对精度的小数。

1011
00:48:56,420 --> 00:48:59,530
这正是这类问题
发生在爱国者。

1012
00:48:59,530 --> 00:49:04,040
该系统运行更长的
更糟糕的一次错误成为。

1013
00:49:04,040 --> 00:49:08,840
>> -after运行100小时后，
在错误的时间只有大约三分之一

1014
00:49:08,840 --> 00:49:10,440
第二。

1015
00:49:10,440 --> 00:49:14,150
但在靶向方面
导弹在5马赫旅行，

1016
00:49:14,150 --> 00:49:18,560
这导致跟踪
的600多米的错误。

1017
00:49:18,560 --> 00:49:21,870
这将是一个致命的错误
对于战士在宰赫兰。

1018
00:49:21,870 --> 00:49:28,455
>>  - 什么事是飞毛腿发射是
通过预警卫星探测，

1019
00:49:28,455 --> 00:49:32,710
他们知道飞毛腿来了
在他们的大方向。

1020
00:49:32,710 --> 00:49:35,150
他们不知道有人来了。

1021
00:49:35,150 --> 00:49:38,210
这是现在到雷达
爱国者系统的组成部分

1022
00:49:38,210 --> 00:49:43,150
卫冕达兰定位和保持
跟踪来袭的敌方导弹。

1023
00:49:43,150 --> 00:49:44,561
>> -The雷达是非常聪明的。

1024
00:49:44,561 --> 00:49:46,560
它实际上跟踪
飞毛腿的位置

1025
00:49:46,560 --> 00:49:48,930
然后预测的地方
它很可能是

1026
00:49:48,930 --> 00:49:51,380
在下一次
雷达发出的脉冲输出。

1027
00:49:51,380 --> 00:49:53,040
这就是所谓的距离门。

1028
00:49:53,040 --> 00:49:57,620
>>  - 那么一旦爱国者
决定有足够的时间具有

1029
00:49:57,620 --> 00:50:02,400
传递回去检查下
位置，该检测对象

1030
00:50:02,400 --> 00:50:03,550
它可以追溯到。

1031
00:50:03,550 --> 00:50:07,820
因此，当它回到了错
地方，然后看见没有对象。

1032
00:50:07,820 --> 00:50:10,360
并且它决定，没有任何对象。

1033
00:50:10,360 --> 00:50:13,630
这有一个错误的检测
它的下降轨道。

1034
00:50:13,630 --> 00:50:16,970
>> -The传入飞毛腿消失
从雷达屏幕上，

1035
00:50:16,970 --> 00:50:20,200
几秒钟后，它
撞上了军营。

1036
00:50:20,200 --> 00:50:22,570
飞毛腿打死28。

1037
00:50:22,570 --> 00:50:26,110
这是最后一个发射
在第一次海湾战争。

1038
00:50:26,110 --> 00:50:31,920
可悲的是，更新后的软件
抵达黎明翌日。

1039
00:50:31,920 --> 00:50:34,870
该软件有漏洞
是固定的，封闭

1040
00:50:34,870 --> 00:50:39,150
在陷入困境的一章
爱国者导弹的历史。

1041
00:50:39,150 --> 00:50:40,030
>> [完视频回放]

1042
00:50:40,030 --> 00:50:41,488
>> 戴维·J·马兰：这就是它的CS50。

1043
00:50:41,488 --> 00:50:42,820
我们会看到你在星期三。

1044
00:50:42,820 --> 00:50:46,420

1045
00:50:46,420 --> 00:50:50,370
>> [音乐播放]

1046
00:50:50,370 --> 00:54:23,446