1
00:00:07,590 --> 00:00:09,920
[Powered by Google Translate] DAVID J.马兰：好吧，这是CS50，这是

2
00:00:09,920 --> 00:00:15,250
结束第1周，所以研究卡的总数

3
00:00:15,250 --> 00:00:18,640
同学，你今年是745。

4
00:00:18,640 --> 00:00:20,920
我们很高兴能有这么多的过程中，

5
00:00:20,920 --> 00:00:23,680
这学期，但即使这个过程是如此之大，

6
00:00:23,680 --> 00:00:26,090
认识到，它的这些事情，比如周五的午餐，

7
00:00:26,090 --> 00:00:29,020
办公时间，15人的部分，等等，

8
00:00:29,020 --> 00:00:30,590
真正的意思创造这更亲密

9
00:00:30,590 --> 00:00:31,140
环境。

10
00:00:31,140 --> 00:00:34,070
因此，即使我们可能会收集每周一次或两次，在这里

11
00:00:34,070 --> 00:00:36,420
桑德斯知道这么多你的经验，在此过程

12
00:00:36,420 --> 00:00:39,330
非常动手的同时，你的同学

13
00:00:39,330 --> 00:00:40,730
和师资队伍建设。

14
00:00:40,730 --> 00:00:43,960
>> 所以，在这里，我们走了，秋天2012年。

15
00:00:43,960 --> 00:00:47,530
所以，记得我们最后一次上记下结束

16
00:00:47,530 --> 00:00:50,460
不精确，谈论的数字表示。

17
00:00:50,460 --> 00:00:52,950
同时，我们也发生的故障之一，在

18
00:00:52,950 --> 00:00:54,920
现实世界中，当它来到误解

19
00:00:54,920 --> 00:00:55,890
计算机如何工作。

20
00:00:55,890 --> 00:00:58,590
那么，今天我们将重新审视这些想法另一个

21
00:00:58,590 --> 00:01:01,410
继续我们的讨论的CS50客户端的

22
00:01:01,410 --> 00:01:04,090
和C，这意味着什么真正的程序。

23
00:01:04,090 --> 00:01:06,430
但是，第一，只是一对夫妇的旋风公告。

24
00:01:06,430 --> 00:01:08,930
>> 节本周日开始的第一周始终是一个

25
00:01:08,930 --> 00:01:11,030
位的快速启动，因为我们刚刚在

26
00:01:11,030 --> 00:01:12,620
您的截面形式。

27
00:01:12,620 --> 00:01:14,450
我们正在做的是相同的，现在的教学研究员，现在

28
00:01:14,450 --> 00:01:16,410
他们知道他们的日程安排，所以我们的目标是，通过

29
00:01:16,410 --> 00:01:19,380
星期六的早上，跟进你与你的部分

30
00:01:19,380 --> 00:01:20,760
转让和TF。

31
00:01:20,760 --> 00:01:22,770
要认识到，他们就会开始第二天，周日

32
00:01:22,770 --> 00:01:24,510
周一或周二。

33
00:01:24,510 --> 00:01:27,730
然后，我们将容纳部分出现的变化，因为他们

34
00:01:27,730 --> 00:01:28,690
在未来的日子里。

35
00:01:28,690 --> 00:01:31,590
办公时间，同时，再次，今晚8日下午至11日，在

36
00:01:31,590 --> 00:01:33,740
安嫩伯格，以及明天晚上。

37
00:01:33,740 --> 00:01:36,150
即使问题集一般是由于上周四

38
00:01:36,150 --> 00:01:39,020
中午，意识到你有五迟花，

39
00:01:39,020 --> 00:01:42,430
因此，可用性，星期四办公时间

40
00:01:42,430 --> 00:01:45,930
你的现金在那些已故的日子，因此，提交

41
00:01:45,930 --> 00:01:47,070
上周五的东西。

42
00:01:47,070 --> 00:01:50,850
让我从头开始更多的乐趣之中，其中

43
00:01:50,850 --> 00:01:52,390
更低调的习题集。

44
00:01:52,390 --> 00:01:55,160
我会挂到那些迟交天数，在战略上，只

45
00:01:55,160 --> 00:01:57,380
在本学期后，当生活开始得到的方式

46
00:01:57,380 --> 00:01:59,470
期中考试和其他类。

47
00:01:59,470 --> 00:02:01,580
问题1，同时，将发布在球场上的

48
00:02:01,580 --> 00:02:06,080
本网站将在课程的步行路程，

49
00:02:06,080 --> 00:02:08,789
通过视频，这将被拍摄下来，在上周五下午2点30分

50
00:02:08,789 --> 00:02:11,890
然后在网上发布的第二天。

51
00:02:11,890 --> 00:02:13,880
>> 因此，我们于周一结束。

52
00:02:13,880 --> 00:02:15,450
我想 - 实际上，注意这里。

53
00:02:15,450 --> 00:02:18,870
由于类 - 因为，桑德斯并不完全借给

54
00:02:18,870 --> 00:02:22,220
本身以休闲Q＆A回，来回非常好，我们

55
00:02:22,220 --> 00:02:24,030
要尝试一些新今年，据此，

56
00:02:24,030 --> 00:02:26,160
如果你不舒服提高你的手或你只是

57
00:02:26,160 --> 00:02:28,800
宁可不要这样在一个房间里，举起你的手

58
00:02:28,800 --> 00:02:30,710
我们将有一定的教学研究员和CA

59
00:02:30,710 --> 00:02:33,260
在演讲的人员编制cs50.net/discuss。

60
00:02:33,260 --> 00:02:35,440
所以，如果你有一个问题，因为我完全

61
00:02:35,440 --> 00:02:37,510
一些不清楚的东西或你很好奇

62
00:02:37,510 --> 00:02:39,640
主题，尝试张贴在那里。

63
00:02:39,640 --> 00:02:42,670
标记，它与标签的演讲，我们将竭尽所能

64
00:02:42,670 --> 00:02:45,430
今天和下周 - 我们就会试试这个 - 到外地

65
00:02:45,430 --> 00:02:47,990
无论是电子，网络，或者如果它感觉就像是我们应该

66
00:02:47,990 --> 00:02:50,430
真正解决这个集体，教学研究员之一

67
00:02:50,430 --> 00:02:52,080
CA将提高他们的手，问

68
00:02:52,080 --> 00:02:53,480
匿名您的代表。

69
00:02:53,480 --> 00:02:55,650
所以，我们可以给它一个尝试，看看它的原理。

70
00:02:55,650 --> 00:02:58,540
但是，通过各种手段，不断举手，你想。

71
00:02:58,540 --> 00:03:11,420
>> 所以我们最后一次发现，10％的十分之一，

72
00:03:11,420 --> 00:03:13,840
事实上，0.1，就像你教多年以前。

73
00:03:13,840 --> 00:03:15,390
其实，这样的值。

74
00:03:15,390 --> 00:03:16,970
但是这还不是全部都是真实的，对不对？

75
00:03:16,970 --> 00:03:19,585
我们只是有这样的约束，在计算机，据此，如果你

76
00:03:19,585 --> 00:03:22,450
只有在有限的记忆体，RAM，或更多

77
00:03:22,450 --> 00:03:25,220
特别是位很好，有只有有限数量

78
00:03:25,220 --> 00:03:26,980
的事情，你可以代表。

79
00:03:26,980 --> 00:03:29,780
例如，如果我们的零的个数，我们要

80
00:03:29,780 --> 00:03:32,790
代表二进位，8位，位，

81
00:03:32,790 --> 00:03:34,710
又是一个0或1，我们可能会

82
00:03:34,710 --> 00:03:39,240
它表示为00000000。

83
00:03:39,240 --> 00:03:41,160
这是一个有点不必要的冗长。

84
00:03:41,160 --> 00:03:43,700
就像在现实世界中的十进位制，

85
00:03:43,700 --> 00:03:47,040
一般地，如果你想要写的编号为123，我们

86
00:03:47,040 --> 00:03:52,240
人类也许并不即使写00000123，

87
00:03:52,240 --> 00:03:53,940
功能，这是完全一样的。

88
00:03:53,940 --> 00:03:56,580
我们只是删除前导零，可以这么说。

89
00:03:56,580 --> 00:03:58,270
>> 在二进制中，我们可以做的是一样的。

90
00:03:58,270 --> 00:04:01,440
二进制零，零和二进制为零。

91
00:04:01,440 --> 00:04:02,870
你只需要一个单一的位。

92
00:04:02,870 --> 00:04:05,020
但同样，最常见的在世界上的度量单位

93
00:04:05,020 --> 00:04:07,820
的计算是字节，8个位。

94
00:04:07,820 --> 00:04:09,720
仅仅因为一个位，好看不中用。

95
00:04:09,720 --> 00:04:12,020
八位，而不是非常有用的，但至少，它更重要的是

96
00:04:12,020 --> 00:04:14,280
有用的度量比一个单一的单元。

97
00:04:14,280 --> 00:04:17,100
因此，用8位，我们通常会代表的二进制文件。

98
00:04:17,100 --> 00:04:20,459
所以，在这里，我们有数字零，一，二，那么，作为

99
00:04:20,459 --> 00:04:24,200
内特在我们的视频最后一个星期三，我们可以继续

100
00:04:24,200 --> 00:04:25,940
向上计数到7，8。

101
00:04:25,940 --> 00:04:27,860
然后，如果我们使用越来越多的位，我们

102
00:04:27,860 --> 00:04:29,880
可计数到无穷大。

103
00:04:29,880 --> 00:04:32,800
但是，如果你只有有限数量的这些位，因为是

104
00:04:32,800 --> 00:04:35,030
任何计算机系统中的情况下，甚至导弹

105
00:04:35,030 --> 00:04:36,670
系统，很好，你确实只有一个

106
00:04:36,670 --> 00:04:37,900
有限数量的精度。

107
00:04:37,900 --> 00:04:41,290
所以，如果你想代表的数字（如0.1），以及，

108
00:04:41,290 --> 00:04:43,410
电脑挑选。

109
00:04:43,410 --> 00:04:45,970
并且如果它仅具有有限数量的数字，它可以

110
00:04:45,970 --> 00:04:50,490
代表，它可以接近0.1，但它不能

111
00:04:50,490 --> 00:04:53,730
一定给你正是你想要的值。

112
00:04:53,730 --> 00:04:55,660
而这仅仅是一个电脑的挑战，

113
00:04:55,660 --> 00:04:57,090
引擎盖下的，令人欣慰的。

114
00:04:57,090 --> 00:04:59,110
>> 在本学期我们得更远，这些较低的水平

115
00:04:59,110 --> 00:05:02,310
变得不那么有趣的细节，但可以肯定的

116
00:05:02,310 --> 00:05:05,700
运用这些思想可以有一些非常现实的世界

117
00:05:05,700 --> 00:05:06,760
的后果。

118
00:05:06,760 --> 00:05:08,190
一个是一点乐趣。

119
00:05:08,190 --> 00:05:12,150
你们有多少人看到了惊人的电影的办公空间吗？

120
00:05:12,150 --> 00:05:13,620
如果你还没有，那是你的非官方

121
00:05:13,620 --> 00:05:14,370
功课的一周。

122
00:05:14,370 --> 00:05:16,730
但是，在办公空间中，研究人员在那部电影

123
00:05:16,730 --> 00:05:19,900
优势，正是这种想法，但他们实际上偷

124
00:05:19,900 --> 00:05:21,270
从另一部电影，你可能有

125
00:05:21,270 --> 00:05:22,760
可见，甚至几年前。

126
00:05:22,760 --> 00:05:24,920
因此，让我给你几秒钟的这个预告片

127
00:05:24,920 --> 00:05:27,470
这个惊人的电影，这是非常

128
00:05:27,470 --> 00:05:28,340
学术有关。

129
00:05:28,340 --> 00:05:30,310
>> [播放影片]

130
00:05:30,310 --> 00:05:32,240
其实，我被提拔。

131
00:05:32,240 --> 00:05:33,360
我可以编写一个病毒，它们会撕裂，

132
00:05:33,360 --> 00:05:34,460
将大的时间。

133
00:05:34,460 --> 00:05:35,770
那么，它是如何工作的？

134
00:05:35,770 --> 00:05:37,836
每当有一银行交易的兴趣是

135
00:05:37,836 --> 00:05:40,154
计算，每天有成千上万的计算机结束

136
00:05:40,154 --> 00:05:41,040
这些不足一仙。

137
00:05:41,040 --> 00:05:43,050
但我不会做任何违法的事情。

138
00:05:43,050 --> 00:05:46,730
非法？萨米尔，这是美国。

139
00:05:46,730 --> 00:05:48,010
你必须向上帝发誓。

140
00:05:48,010 --> 00:05:51,870
如果没有人知道这一点，但我们，所有的权利吗？没有家人，没有

141
00:05:51,870 --> 00:05:52,490
女朋友，没有人。

142
00:05:52,490 --> 00:05:53,882
[听不清]。

143
00:05:53,882 --> 00:05:57,594
不要担心，人，我不会告诉任何人，无论是。

144
00:05:57,594 --> 00:05:59,680
[电影结束]

145
00:05:59,680 --> 00:06:01,900
>> 好吧，也许我比大多数人更好地发现这部电影

146
00:06:01,900 --> 00:06:05,530
这里的人，但在任何情况下，他们的病毒

147
00:06:05,530 --> 00:06:06,400
努力创造 - 

148
00:06:06,400 --> 00:06:08,410
在电影中，随时会打电话给一些病毒，

149
00:06:08,410 --> 00:06:09,770
它通常不是真正的病毒。

150
00:06:09,770 --> 00:06:11,600
这只是有人写了一个程序，做一些事情。

151
00:06:11,600 --> 00:06:13,800
在这种情况下，球员试图写一个程序

152
00:06:13,800 --> 00:06:16,610
趁着他们的公司叫Innotech公司的

153
00:06:16,610 --> 00:06:19,740
计算系统，从而计算机，也一样，甚至当它

154
00:06:19,740 --> 00:06:21,350
说到钱，可不一定

155
00:06:21,350 --> 00:06:23,490
正是代表钱。

156
00:06:23,490 --> 00:06:27,630
因此，即使你可能有您的银行帐户0.10美元，

157
00:06:27,630 --> 00:06:31,060
0.10，好了，电脑实际上可能会认为你有

158
00:06:31,060 --> 00:06:33,560
这美分，在您的银行帐户。

159
00:06:33,560 --> 00:06:35,750
所以这些人是有志于做的 - 和他们

160
00:06:35,750 --> 00:06:38,240
偷的想法，事实证明超人III，其中

161
00:06:38,240 --> 00:06:41,210
理查德·普赖尔做同样的事情 - 他们基本上是

162
00:06:41,210 --> 00:06:44,880
编写程序，渴望采取一切尾随

163
00:06:44,880 --> 00:06:46,930
号，所有的微小的，微小的，微小的分数

164
00:06:46,930 --> 00:06:50,160
便士，及虹吸关闭，因此人类

165
00:06:50,160 --> 00:06:52,620
想，哦，这是唯一的0.10美元存在，但所有这些

166
00:06:52,620 --> 00:06:54,410
尾随数字，最终增加。

167
00:06:54,410 --> 00:06:57,490
因此，一个绝妙的主意，它事与愿违欢快的，

168
00:06:57,490 --> 00:06:58,250
尤其是电影。

169
00:06:58,250 --> 00:07:01,800
>> 但在现实世界中，也有更多的关于

170
00:07:01,800 --> 00:07:03,190
这些事情的影响。

171
00:07:03,190 --> 00:07:05,450
的原因之一潜入计算机领域的

172
00:07:05,450 --> 00:07:07,620
再次，是科学，其适用性不

173
00:07:07,620 --> 00:07:09,740
仅工程科学，但只是为了

174
00:07:09,740 --> 00:07:10,650
其他领域。

175
00:07:10,650 --> 00:07:14,760
因此，这是一个不太轻松的看看什么可以去错了，但

176
00:07:14,760 --> 00:07:17,630
这也是相当睁眼，我认为，当涉及到

177
00:07:17,630 --> 00:07:20,760
如何准确理解无所不在的技术，如

178
00:07:20,760 --> 00:07:22,870
计算机和编程这些天来，

179
00:07:22,870 --> 00:07:23,930
的软件的形式。

180
00:07:23,930 --> 00:07:26,500
因此，这下一个剪辑是刚刚约为6分钟，继续

181
00:07:26,500 --> 00:07:30,320
最后一次我们离开的地方，但让我们看看一点

182
00:07:30,320 --> 00:07:33,370
在这样一个对这些问题的深入。

183
00:07:33,370 --> 00:07:35,270
让我跳到我们离开的地方，

184
00:07:35,270 --> 00:07:37,780
这是在这里。

185
00:07:37,780 --> 00:07:41,580
我们有两个部分，约六分钟在这里。

186
00:07:41,580 --> 00:07:41,980
>> [播放电影]

187
00:07:41,980 --> 00:07:45,430
困扰现代火箭技术。

188
00:07:45,430 --> 00:07:49,280
在1991年，开始第一次海湾战争中，“爱国者”

189
00:07:49,280 --> 00:07:51,350
导弹经历了类似的种

190
00:07:51,350 --> 00:07:52,645
数字转换问题。

191
00:07:52,645 --> 00:07:57,460
而作为一个结果，20人，20名美国士兵被打死

192
00:07:57,460 --> 00:08:01,130
约100人受伤，“爱国者”，这是应该

193
00:08:01,130 --> 00:08:03,400
以防止传入的飞毛腿导弹，

194
00:08:03,400 --> 00:08:06,020
没有发射导弹。

195
00:08:06,020 --> 00:08:09,350
>> 在伊拉克入侵科威特，美国发动的沙漠

196
00:08:09,350 --> 00:08:13,530
风暴在1991年初，爱国者导弹

197
00:08:13,530 --> 00:08:16,970
从伊拉克部署，以保护沙特阿拉伯和以色列

198
00:08:16,970 --> 00:08:19,810
“飞毛腿”导弹的袭击。

199
00:08:19,810 --> 00:08:23,740
“爱国者”是美国的中程表面空气系统，

200
00:08:23,740 --> 00:08:26,370
由雷神公司制造。

201
00:08:26,370 --> 00:08:30,860
“爱国者”拦截器本身的大小，它是关于

202
00:08:30,860 --> 00:08:35,650
大约20英尺长，重约2000磅。

203
00:08:35,650 --> 00:08:38,809
它携带的弹头，约 - 我认为这是大约

204
00:08:38,809 --> 00:08:40,169
150磅。

205
00:08:40,169 --> 00:08:45,820
和弹头本身就是一种高爆炸药，

206
00:08:45,820 --> 00:08:48,120
它周围的碎片。

207
00:08:48,120 --> 00:08:51,870
像霰弹的弹头外壳的设计。

208
00:08:51,870 --> 00:08:54,920
该型导弹进行4每个容器

209
00:08:54,920 --> 00:08:57,850
半拖车运输。

210
00:08:57,850 --> 00:09:02,940
>> “爱国者”反导弹系统至少可以追溯到

211
00:09:02,940 --> 00:09:05,530
20年了。

212
00:09:05,530 --> 00:09:09,150
它最初被设计为防空导弹，以

213
00:09:09,150 --> 00:09:12,920
击落敌方飞机，在第一次海湾战争。

214
00:09:12,920 --> 00:09:17,700
当那场战争以来，陆军希望用它来拍摄

215
00:09:17,700 --> 00:09:19,880
跌飞毛腿“导弹，而不是飞机。

216
00:09:19,880 --> 00:09:24,860
空气伊拉克队就没有那么多的问题，但是陆军

217
00:09:24,860 --> 00:09:27,260
飞毛腿担心。

218
00:09:27,260 --> 00:09:30,810
因此，他们试图升级“爱国者”。

219
00:09:30,810 --> 00:09:33,770
拦截敌方导弹在5马赫的速度行驶会

220
00:09:33,770 --> 00:09:35,790
足够的挑战性。

221
00:09:35,790 --> 00:09:39,460
但是，在的爱国者被送往服务时，陆军

222
00:09:39,460 --> 00:09:43,730
不知道的伊拉克修改了他们的

223
00:09:43,730 --> 00:09:46,510
打飞毛腿导弹几乎是不可能的。

224
00:09:46,510 --> 00:09:50,040
>> 发生了什么事，是飞毛腿导弹，

225
00:09:50,040 --> 00:09:51,360
未来是不稳定的。

226
00:09:51,360 --> 00:09:52,266
他们摇晃。

227
00:09:52,266 --> 00:09:56,300
这样做的原因是伊拉克人，以获得600

228
00:09:56,300 --> 00:10:00,650
公里，有300公里的射程导弹，花

229
00:10:00,650 --> 00:10:02,423
重量的前弹头和

230
00:10:02,423 --> 00:10:03,990
弹头更轻。

231
00:10:03,990 --> 00:10:08,700
所以，现在的爱国者的努力来飞毛腿，和大多数

232
00:10:08,700 --> 00:10:11,192
的时候，绝大多数的时候，它会

233
00:10:11,192 --> 00:10:13,450
只是飞的飞毛腿。

234
00:10:13,450 --> 00:10:16,300
一旦运营商“爱国者”系统实现“爱国者”

235
00:10:16,300 --> 00:10:20,160
错过了它的目标，引爆的爱国者弹头。

236
00:10:20,160 --> 00:10:22,760
为了避免可能出现的伤亡，它被允许

237
00:10:22,760 --> 00:10:25,100
倒在地上。

238
00:10:25,100 --> 00:10:29,400
这是大多数人所看到的，大火球在天空中，

239
00:10:29,400 --> 00:10:34,930
拦截飞毛腿弹头和误解。

240
00:10:34,930 --> 00:10:37,490
>> 虽然，在夜空中，似乎是

241
00:10:37,490 --> 00:10:41,570
在宰赫兰，成功地摧毁了飞毛腿导弹，有可能是没有

242
00:10:41,570 --> 00:10:43,730
错误关于它的性能。

243
00:10:43,730 --> 00:10:46,370
在那里，爱国者的雷达系统失去一个曲目

244
00:10:46,370 --> 00:10:50,090
传入的​​飞毛腿从未发起因

245
00:10:50,090 --> 00:10:51,340
一个软件缺陷。

246
00:10:54,030 --> 00:10:57,050
这是以色列首次发现的时间越长

247
00:10:57,050 --> 00:11:02,000
系统上，更大的时间差成为，

248
00:11:02,000 --> 00:11:05,530
由于系统的计算机中的嵌入的时钟。

249
00:11:05,530 --> 00:11:09,060
在惨剧发生前大约两个星期，在宰赫兰，

250
00:11:09,060 --> 00:11:11,730
以色列国防部报告说，

251
00:11:11,730 --> 00:11:13,250
系统失去的时间。

252
00:11:13,250 --> 00:11:15,610
经过约8个小时的运行，他们发现，

253
00:11:15,610 --> 00:11:18,330
制度越来越明显不准确的。

254
00:11:18,330 --> 00:11:20,910
国防部回应，告诉所有的

255
00:11:20,910 --> 00:11:23,710
爱国者不会离开系统

256
00:11:23,710 --> 00:11:25,450
很长一段时间。

257
00:11:25,450 --> 00:11:28,010
他们从来不说，很长一段时间 -  8小时，10

258
00:11:28,010 --> 00:11:29,690
小时，千小时。

259
00:11:29,690 --> 00:11:31,940
没有人知道。

260
00:11:31,940 --> 00:11:35,020
>> 在宰赫兰的军营驻扎在爱国者

261
00:11:35,020 --> 00:11:39,030
有问题的内部时钟已经超过100小时

262
00:11:39,030 --> 00:11:42,240
二月25日的夜晚。

263
00:11:42,240 --> 00:11:46,580
它跟踪的约十分之一秒的精确度。

264
00:11:46,580 --> 00:11:48,830
现在的十分之一，二是因为一个有趣的数字

265
00:11:48,830 --> 00:11:52,660
它不能被以二进制表示，完全相同，这意味着

266
00:11:52,660 --> 00:11:54,940
它不能被正好在任何表达

267
00:11:54,940 --> 00:11:57,330
现代数字计算机。

268
00:11:57,330 --> 00:11:59,130
这是很难相信。

269
00:11:59,130 --> 00:12:01,720
但使用这个作为一个例子。

270
00:12:01,720 --> 00:12:04,090
>> 让我们来数的三分之一。

271
00:12:04,090 --> 00:12:07,950
，究竟有三分之一不能以十进制表示。

272
00:12:07,950 --> 00:12:12,710
三分之一是0.333是无限的。

273
00:12:12,710 --> 00:12:17,050
有没有办法做到这一点的绝对精度十进制的。

274
00:12:17,050 --> 00:12:19,340
这也正是同样的问题发生在

275
00:12:19,340 --> 00:12:20,190
“爱国者”。

276
00:12:20,190 --> 00:12:24,680
系统运行的时间越长，成为时间更糟糕的错误。

277
00:12:24,680 --> 00:12:28,640
运行100小时后，时间中的错误是只

278
00:12:28,640 --> 00:12:29,870
大约三分之一的第二个。

279
00:12:29,870 --> 00:12:34,790
但在5马赫的速度行驶在导弹的目标，

280
00:12:34,790 --> 00:12:39,140
这导致跟踪误差超过600米。

281
00:12:39,140 --> 00:12:42,510
在宰赫兰的士兵，这将是一个致命的错误。

282
00:12:42,510 --> 00:12:48,680
>> 现在的情况是飞毛腿发射检测预警

283
00:12:48,680 --> 00:12:52,440
卫星，他们知道，飞毛腿在他们的

284
00:12:52,440 --> 00:12:53,350
大方向。

285
00:12:53,350 --> 00:12:55,470
他们不知道有人来了。

286
00:12:55,470 --> 00:12:58,210
这是现在的爱国者的雷达组件

287
00:12:58,210 --> 00:13:01,920
系统，保卫达兰，定位和跟踪

288
00:13:01,920 --> 00:13:03,700
来袭的敌方导弹。

289
00:13:03,700 --> 00:13:05,390
该雷达是很聪明的。

290
00:13:05,390 --> 00:13:07,570
实际上，你会跟踪的位置，飞毛腿，然后

291
00:13:07,570 --> 00:13:10,340
预测它可能会是今后一段时间

292
00:13:10,340 --> 00:13:12,040
雷达发出一个脉冲。

293
00:13:12,040 --> 00:13:13,730
这是所谓的的范围内的栅极。

294
00:13:13,730 --> 00:13:18,820
然后，一旦决定有足够的时间已经过去了，去爱国者

295
00:13:18,820 --> 00:13:22,600
该检测到的备份和检查的下一个位置

296
00:13:22,600 --> 00:13:24,190
对象，它可以追溯到。

297
00:13:24,190 --> 00:13:27,940
因此，当去到错误的地方，然后看到没有

298
00:13:27,940 --> 00:13:31,000
反对，并决定，有没有对象。

299
00:13:31,000 --> 00:13:34,370
这是一个虚假的检测和下降的轨道。

300
00:13:34,370 --> 00:13:37,630
>> 传入的​​飞毛腿从雷达屏幕上消失。

301
00:13:37,630 --> 00:13:41,300
几秒钟后，砰的一声走进军营。飞毛腿

302
00:13:41,300 --> 00:13:44,730
杀害了28和发射过程中是最后一个

303
00:13:44,730 --> 00:13:46,450
第一次海湾战争。

304
00:13:46,450 --> 00:13:50,570
可悲的是，更新后的软件在宰赫兰

305
00:13:50,570 --> 00:13:52,060
次日。

306
00:13:52,060 --> 00:13:56,210
而软件漏洞已被固定，关闭中的一个章节

307
00:13:56,210 --> 00:13:58,370
多灾多难的历史的“爱国者”导弹。

308
00:14:01,790 --> 00:14:04,990
爱国者实际上是一个缩写为“相控阵跟踪

309
00:14:04,990 --> 00:14:08,516
拦截的目标。“

310
00:14:08,516 --> 00:14:13,390
>> 所有权利，更悲哀的结果不太

311
00:14:13,390 --> 00:14:14,430
了解这个世界。

312
00:14:14,430 --> 00:14:18,180
外卖，从电影，真的是该解决方案

313
00:14:18,180 --> 00:14:20,790
有被重新启​​动您的导弹防御系统

314
00:14:20,790 --> 00:14:21,770
每一次在一段时间内。

315
00:14:21,770 --> 00:14:24,280
如此反复，这门课程的目的之一，当然

316
00:14:24,280 --> 00:14:26,900
一种更谦逊的规模比这些应用程序，

317
00:14:26,900 --> 00:14:30,710
真正的开放究竟如何，你去了解每个人的眼睛

318
00:14:30,710 --> 00:14:34,380
使机器做你希望他们做什么，以及你如何去

319
00:14:34,380 --> 00:14:37,180
这样做是正确的，而沿途做

320
00:14:37,180 --> 00:14:38,810
好吧，优雅，等等。

321
00:14:38,810 --> 00:14:41,680
所以今天，让我们多一点点，这潜入，但

322
00:14:41,680 --> 00:14:44,210
所以，我们不要走的太快，特别是那些少

323
00:14:44,210 --> 00:14:46,590
舒适，而且还使我们能够保留的利益

324
00:14:46,590 --> 00:14:49,390
那些更舒适，让我们迅速开始位

325
00:14:49,390 --> 00:14:50,970
回顾一下其中的一些想法。

326
00:14:50,970 --> 00:14:53,710
再次，要求离开，无论是在个人或网上，如果你有

327
00:14:53,710 --> 00:14:56,320
的问题，所以我们可以让每个人都在同一页上。

328
00:14:56,320 --> 00:14:58,820
>> 因此，CS50电器，快速退后一步，

329
00:14:58,820 --> 00:15:02,360
什么，你自己的话怎么办？

330
00:15:02,360 --> 00:15:06,454
这是确定的，如果你不知道那些话，可能是还没有。

331
00:15:06,454 --> 00:15:07,830
[听不清]

332
00:15:07,830 --> 00:15:10,950
好了，所以通用接口 - 

333
00:15:10,950 --> 00:15:11,900
我们都可以共享。

334
00:15:11,900 --> 00:15:12,470
当然可以。

335
00:15:12,470 --> 00:15:14,840
因此，我们可以，例如，告诉你去一些

336
00:15:14,840 --> 00:15:16,910
网站，下载该软件适用于Mac OS。

337
00:15:16,910 --> 00:15:19,140
下载该软件适用于Windows，配置

338
00:15:19,140 --> 00:15:20,100
这条路上。

339
00:15:20,100 --> 00:15:22,370
但现实情况是，我们遇到无数的技术

340
00:15:22,370 --> 00:15:23,200
支持的问题。

341
00:15:23,200 --> 00:15:26,630
这些天，许多正在做什么的服务器端，

342
00:15:26,630 --> 00:15:28,490
在计算世界中，特别是当它涉及到

343
00:15:28,490 --> 00:15:31,460
Web开发和Web的应用程序，实际上是

344
00:15:31,460 --> 00:15:35,110
经常在Unix或Linux计算机上，而不是

345
00:15:35,110 --> 00:15:36,800
Mac或Windows电脑。

346
00:15:36,800 --> 00:15:39,240
>> 之间有利的一面，那么，这件事情被称为

347
00:15:39,240 --> 00:15:41,500
CS50设备是我们将所有具有相同的环境。

348
00:15:41,500 --> 00:15:43,670
因此，每个人都在同一页上，无论什么样的硬件，你

349
00:15:43,670 --> 00:15:46,650
来到校园，但也将涉足准确

350
00:15:46,650 --> 00:15:48,230
同样的环境下，你会使用朝

351
00:15:48,230 --> 00:15:51,080
学期结束，以及网络的发展，以及在

352
00:15:51,080 --> 00:15:53,580
其未来真实世界的应用。

353
00:15:53,580 --> 00:15:56,350
因此，更具体而言，CS50电器是免费的一块

354
00:15:56,350 --> 00:15:59,400
软件，可以让您运行其他操作系统，

355
00:15:59,400 --> 00:16:02,670
Linux操作系统，在这种情况下，在自己的计算机上，在一个窗口中。

356
00:16:02,670 --> 00:16:04,750
现在，你不能只是下载设备。

357
00:16:04,750 --> 00:16:08,170
你需要一个程序，播放或运行设备。

358
00:16:08,170 --> 00:16:11,220
而这一块的软件一般称为

359
00:16:11,220 --> 00:16:11,520
虚拟机管理程序。

360
00:16:11,520 --> 00:16:14,050
虚拟机管理程序的形式，如VMware的产品，

361
00:16:14,050 --> 00:16:15,820
虚拟保险箱，相似之处。

362
00:16:15,820 --> 00:16:18,390
所有的公司的各种软件，包括免费的和

363
00:16:18,390 --> 00:16:19,310
商业的一致好评。

364
00:16:19,310 --> 00:16:21,480
你会看到什么问题说明如何设置1

365
00:16:21,480 --> 00:16:23,440
获得免费的软件，用以

366
00:16:23,440 --> 00:16:25,000
执行CS50电器。

367
00:16:25,000 --> 00:16:28,060
一旦你，你就必须在你的Mac或PC上的一个窗口，

368
00:16:28,060 --> 00:16:30,710
一个桌面环境，看起来很喜欢这个，

369
00:16:30,710 --> 00:16:33,100
它在开始菜单一样的东西

370
00:16:33,100 --> 00:16:34,510
底部的左上角。

371
00:16:34,510 --> 00:16:38,030
它有一个Home文件夹，或主目录，在左上角

372
00:16:38,030 --> 00:16:40,280
在那里，一个垃圾桶，等等。

373
00:16:40,280 --> 00:16:43,450
因此，我们除了耻笑，因为我们去的必要的细节。

374
00:16:43,450 --> 00:16:46,430
>> 但现在让我们开始潜入C.

375
00:16:46,430 --> 00:16:49,200
因此，C是这样的编程语言，精神，

376
00:16:49,200 --> 00:16:52,390
从头开始，但远不如图形，但具有讽刺意味的​​是，远

377
00:16:52,390 --> 00:16:54,730
更强大的，一旦你得到它精明。

378
00:16:54,730 --> 00:16:58,970
因此，在C中，我们编写的程序编写源代码，这是

379
00:16:58,970 --> 00:17:01,640
这类似英语的语法，类似的袜子

380
00:17:01,640 --> 00:17:05,609
我们做了示范，最后一次，可让您

381
00:17:05,609 --> 00:17:07,910
表达自己相当精确，如果

382
00:17:07,910 --> 00:17:09,760
arcanely，到计算机。

383
00:17:09,760 --> 00:17:11,960
>> 那么，什么样的软件产品，你实际需要

384
00:17:11,960 --> 00:17:15,520
编写程序的语言，如C，根据我们的

385
00:17:15,520 --> 00:17:17,492
在周一的谈话吗？

386
00:17:17,492 --> 00:17:19,650
[听不清]

387
00:17:19,650 --> 00:17:21,079
OK，你只需要一个文本编辑器。

388
00:17:21,079 --> 00:17:22,890
你不需要任何特殊的软件

389
00:17:22,890 --> 00:17:24,460
本身编写程序。

390
00:17:24,460 --> 00:17:27,220
你只需要一个文本编辑器（如记事本），在Windows，

391
00:17:27,220 --> 00:17:30,450
文字编辑在Mac上，或所谓的gedit的，在世界上的

392
00:17:30,450 --> 00:17:32,020
Linux中，我们将在这里使用。

393
00:17:32,020 --> 00:17:33,750
就是这样，写的程序。

394
00:17:33,750 --> 00:17:35,480
>> 但写作只有一半的方程。

395
00:17:35,480 --> 00:17:36,630
然后，您需要运行它们。

396
00:17:36,630 --> 00:17:38,320
但是，为了运行程序 - 

397
00:17:38,320 --> 00:17:39,600
你不能运行的源代码。

398
00:17:39,600 --> 00:17:41,500
你，而不是必须做什么它？

399
00:17:41,500 --> 00:17:41,900
是啊。

400
00:17:41,900 --> 00:17:43,200
DAVID J.马兰：您需要

401
00:17:43,200 --> 00:17:44,130
编译它。

402
00:17:44,130 --> 00:17:49,010
而且，别人编译的源代码是指 - 

403
00:17:49,010 --> 00:17:50,260
[听不清]

404
00:17:52,300 --> 00:17:52,700
DAVID J.马兰：没错。

405
00:17:52,700 --> 00:17:54,430
把它转换成零和一。

406
00:17:54,430 --> 00:17:57,150
因为我们所有的人，这些天来，有电脑，有CPU的，

407
00:17:57,150 --> 00:18:00,350
几乎全部是由一家名为英特尔，

408
00:18:00,350 --> 00:18:03,320
英特尔内部，有你的这个大脑内

409
00:18:03,320 --> 00:18:04,990
计算机，称为CPU。

410
00:18:04,990 --> 00:18:07,570
，大脑做的事情之一是，它知道

411
00:18:07,570 --> 00:18:10,390
如何理解零和一的模式。

412
00:18:10,390 --> 00:18:13,240
它知道什么图案位代表另外，什么

413
00:18:13,240 --> 00:18:15,500
图案代表减法，什么图案

414
00:18:15,500 --> 00:18:18,890
位代表打印，并创建一个可听见的声音。

415
00:18:18,890 --> 00:18:22,450
>> 因此，在短期中，CPU，加上与操作系统，

416
00:18:22,450 --> 00:18:25,230
这是一块的CPU上运行的软件，

417
00:18:25,230 --> 00:18:26,050
可以这么说。

418
00:18:26,050 --> 00:18:29,850
总之，这两条都知道如何来运行程序，

419
00:18:29,850 --> 00:18:31,070
我们人类写。

420
00:18:31,070 --> 00:18:34,040
>> 所以，如果我去到CS50电器在这里，我需要打开

421
00:18:34,040 --> 00:18:35,660
一个文本编辑器，我可以访问

422
00:18:35,660 --> 00:18:36,560
一对夫妇的方式。

423
00:18:36,560 --> 00:18:39,060
我可以进入菜单，编程，

424
00:18:39,060 --> 00:18:40,230
然后我就可以选择 - 

425
00:18:40,230 --> 00:18:40,810
不，不是的菜单。

426
00:18:40,810 --> 00:18:43,860
我可以去配件/ gedit的打开

427
00:18:43,860 --> 00:18:45,090
我的小文本编辑器。

428
00:18:45,090 --> 00:18:48,030
或者更简单地说，我可以点击这个小图标在底部

429
00:18:48,030 --> 00:18:48,970
左上角。

430
00:18:48,970 --> 00:18:50,430
现在我这里的环境。

431
00:18:50,430 --> 00:18:52,590
这是非常让人联想到的，只有一个简单的文本编辑器

432
00:18:52,590 --> 00:18:53,820
一个或两个的差异。

433
00:18:53,820 --> 00:18:56,420
在顶部，光标闪烁，这是

434
00:18:56,420 --> 00:18:57,900
我可以开始写我的代码。

435
00:18:57,900 --> 00:19:00,415
在底部的这个东西叫做终端窗口。

436
00:19:00,415 --> 00:19:03,400
我可以做什么样的事情在这

437
00:19:03,400 --> 00:19:04,960
所谓的终端窗口？

438
00:19:04,960 --> 00:19:06,680
[听不清]

439
00:19:06,680 --> 00:19:07,890
>> 好吧，我会运行命令。

440
00:19:07,890 --> 00:19:10,300
周一上运行的一些命令，我​​们是一个小

441
00:19:10,300 --> 00:19:15,070
神秘第一，但“列表中的ls，cd命令更改目录，

442
00:19:15,070 --> 00:19:16,540
RM，删除。

443
00:19:16,540 --> 00:19:19,680
因此，这是一个老派的方式浏览您的

444
00:19:19,680 --> 00:19:22,310
电脑，只用你的键盘和文本命令，

445
00:19:22,310 --> 00:19:24,130
不大，一般，使用鼠标。

446
00:19:24,130 --> 00:19:25,960
但我们所看到的，用不了多久，这实际上是给了我们一个

447
00:19:25,960 --> 00:19:28,520
多一点力量，其中一个更精确一点

448
00:19:28,520 --> 00:19:29,600
表达自己。

449
00:19:29,600 --> 00:19:31,330
然后在左边，我们只是去看看，

450
00:19:31,330 --> 00:19:34,360
当我们开始写作软件，一个小小的总结

451
00:19:34,360 --> 00:19:36,350
程序，我们已经写在左上角。

452
00:19:36,350 --> 00:19:38,360
但我们会再次看到，在不久的。

453
00:19:38,360 --> 00:19:40,050
>> 因此，让我们在这里做一些比较简单的。

454
00:19:40,050 --> 00:19:43,440
首先，让我继续前进，到文件，保存，我只是

455
00:19:43,440 --> 00:19:45,970
点击jharvard，在左，

456
00:19:45,970 --> 00:19:48,930
再次，jharvard，我的主文件夹的名称，我

457
00:19:48,930 --> 00:19:52,110
所有的个人档案，我现在是约翰·哈佛，

458
00:19:52,110 --> 00:19:54,230
很快就会约翰·哈佛在这样的环境中。

459
00:19:54,230 --> 00:19:57,360
他有主目录，我的文档等等，

460
00:19:57,360 --> 00:19:58,900
我想保存，现在，这个文件中。

461
00:19:58,900 --> 00:20:01,520
所以，我会打电话给它的hello.c。然后，我会去

462
00:20:01,520 --> 00:20:05,770
进取，单击“保存”，现在我这里是一个标签

463
00:20:05,770 --> 00:20:09,440
名为hello.c，这么多喜欢另一种类型的编辑器。

464
00:20:09,440 --> 00:20:11,760
>> 所以，现在让我继续前进，开始编写程序。

465
00:20:11,760 --> 00:20:14,440
诠释的主要（无效）。

466
00:20:14,440 --> 00:20:18,150
然后，我只是做了最后一次，输出，打印的格式，

467
00:20:18,150 --> 00:20:22,120
（“你好，世界！”

468
00:20:22,120 --> 00:20:24,500
。）;

469
00:20:24,500 --> 00:20:25,630
几乎可以完成。

470
00:20:25,630 --> 00:20:27,130
但是，我错过了几个细节。

471
00:20:27,130 --> 00:20:30,210
从这项计划中，我真正需要的是缺少什么

472
00:20:30,210 --> 00:20:31,890
它实际上编译？

473
00:20:31,890 --> 00:20:32,130
是啊。

474
00:20:32,130 --> 00:20:33,980
[听不见的？

475
00:20:33,980 --> 00:20:35,770
>> DAVID J.马兰：是啊，所以我需要包括标准

476
00:20:35,770 --> 00:20:36,700
I / O库。

477
00:20:36,700 --> 00:20:39,470
因此，这需要去以上的主，所以我只是要

478
00:20:39,470 --> 00:20:40,790
它有一些空间。

479
00:20:40,790 --> 00:20:44,420
我要去，做＃包括<stdio.h>。

480
00:20:44,420 --> 00:20:46,570
注意尖括号。

481
00:20:46,570 --> 00:20:49,410
顺便说一句，gedit是一个小的用户友好，如果

482
00:20:49,410 --> 00:20:52,420
有时有点混乱，因为它试图帮助

483
00:20:52,420 --> 00:20:54,770
眼睛注意哪些行了什么。

484
00:20:54,770 --> 00:20:57,760
因此，事实上，我的光标旁边这个角度

485
00:20:57,760 --> 00:21:00,600
支架，请注意它是如何突出等角度

486
00:21:00,600 --> 00:21:01,920
支架加上这一个。

487
00:21:01,920 --> 00:21:03,770
而这只是为了引起我的注意这样的事实，我

488
00:21:03,770 --> 00:21:04,460
具有对称性。

489
00:21:04,460 --> 00:21:07,010
对称的编程通常是一件好事。

490
00:21:07,010 --> 00:21:10,270
同样，如果我将我的光标到最后，如何通知

491
00:21:10,270 --> 00:21:13,630
花括号，是的，我有一个开放的

492
00:21:13,630 --> 00:21:15,160
和封闭的，可以这么说。

493
00:21:15,160 --> 00:21:16,640
>> 好吧，我可以做一件事。

494
00:21:16,640 --> 00:21:20,090
这不是绝对必要的，但良好做法，说

495
00:21:20,090 --> 00:21:21,250
返回0。

496
00:21:21,250 --> 00:21:24,140
返回0为我们做什么呢？

497
00:21:24,140 --> 00:21:25,584
或者意味着什么？

498
00:21:25,584 --> 00:21:27,480
[听不清]

499
00:21:27,480 --> 00:21:28,300
DAVID J.马兰，但没有什么是错的。

500
00:21:28,300 --> 00:21:30,280
坦白地说，这是很难的大部分时间去错在

501
00:21:30,280 --> 00:21:31,250
编程这短暂的。

502
00:21:31,250 --> 00:21:33,930
所以，我只是超级明确的，一切都很好。

503
00:21:33,930 --> 00:21:36,740
我的人，当我运行这个程序时，可能永远都不会

504
00:21:36,740 --> 00:21:38,150
看到0。

505
00:21:38,150 --> 00:21:41,070
一般来说，这些数字被返回从主

506
00:21:41,070 --> 00:21:43,540
只有抚养他们的头的人

507
00:21:43,540 --> 00:21:44,360
出现错误。

508
00:21:44,360 --> 00:21:46,640
你会得到一个小的弹出提示说系统错误，一，

509
00:21:46,640 --> 00:21:48,760
两个，三个，或任何的数量是

510
00:21:48,760 --> 00:21:50,100
实际上返回。

511
00:21:50,100 --> 00:21:52,870
所以别的问题？

512
00:21:52,870 --> 00:21:55,300
[听不清]

513
00:21:55,300 --> 00:21:58,100
>> DAVID J.马兰：这是没有这么多的功能错误

514
00:21:58,100 --> 00:21:59,240
但一个审美的。

515
00:21:59,240 --> 00:22:02,340
我或许应该有一个换行符

516
00:22:02,340 --> 00:22:05,240
这个字符串结束，所以，我们实际上是将光标移动到

517
00:22:05,240 --> 00:22:08,340
下一行，并计划只是看起来有点漂亮。

518
00:22:08,340 --> 00:22:10,340
>> 所以，现在让我走我的终端窗口

519
00:22:10,340 --> 00:22:11,490
和放大。

520
00:22:11,490 --> 00:22:13,390
而这种事情在这里，这就是所谓的提示。

521
00:22:13,390 --> 00:22:16,760
它只是提醒我，我是谁，jharvard设备，

522
00:22:16,760 --> 00:22:18,850
器具是我在计算机的名称。

523
00:22:18,850 --> 00:22:22,380
括号中的波浪线，波浪线符号，

524
00:22:22,380 --> 00:22:24,160
代表着什么？

525
00:22:24,160 --> 00:22:25,590
观众：主目录。

526
00:22:25,590 --> 00:22:26,350
DAVID J.马兰：主目录。

527
00:22:26,350 --> 00:22:29,350
所以，这只是说，你是在一个速记符号

528
00:22:29,350 --> 00:22:32,780
您的个人文件夹中的所有文件的默认位置。

529
00:22:32,780 --> 00:22:36,080
所以，现在，在这里，我可以输入ls列表。

530
00:22:36,080 --> 00:22:40,020
我在这里看到的那一刻唯一的hello.c。

531
00:22:40,020 --> 00:22:41,770
这是很好的，因为我刚才写的。

532
00:22:41,770 --> 00:22:44,380
>> 因此，让我继续前进，不要让你好。

533
00:22:44,380 --> 00:22:46,830
请注意，我不打字使hello.c的。

534
00:22:46,830 --> 00:22:50,300
相反，我只需要输入该文件的基本名称，你好。

535
00:22:50,300 --> 00:22:53,690
做，因为我们看到在周一，也只是推断，我想

536
00:22:53,690 --> 00:22:54,920
c文件。

537
00:22:54,920 --> 00:22:56,820
所以现在我已经输入招呼。

538
00:22:56,820 --> 00:22:59,280
现在，我看到这个相当长的命令，并会继续

539
00:22:59,280 --> 00:23:00,480
看到这一遍又一遍。

540
00:23:00,480 --> 00:23:03,620
但要清楚，铛，这个词刚刚出现，

541
00:23:03,620 --> 00:23:05,340
这是实际的编译器。

542
00:23:05,340 --> 00:23:08,200
Make是一个生成实用程序。

543
00:23:08,200 --> 00:23:11,900
这只是一个更加用户友好的程序，节省了我，

544
00:23:11,900 --> 00:23:15,310
从长远来看，键入了令人难以置信的乏味的长

545
00:23:15,310 --> 00:23:17,020
这样的一个命令。

546
00:23:17,020 --> 00:23:18,950
所以，你可以手动运行铛。

547
00:23:18,950 --> 00:23:20,530
你可以输入，手动。

548
00:23:20,530 --> 00:23:21,580
只是变得非常乏味的。

549
00:23:21,580 --> 00:23:24,720
，所以一定要仅仅是一个程序，可以简化我们的生活，

550
00:23:24,720 --> 00:23:27,120
运行更复杂的命令给我们。

551
00:23:27,120 --> 00:23:29,410
>> 好吧，所以现在我应该有什么文件

552
00:23:29,410 --> 00:23:31,540
在当前目录？

553
00:23:31,540 --> 00:23:36,310
不只是hello.c的，但也打招呼。

554
00:23:36,310 --> 00:23:39,710
所以，如果我要运行你好，还记得我说点斜线，

555
00:23:39,710 --> 00:23:42,220
点手段去到当前文件夹，无论你

556
00:23:42,220 --> 00:23:46,060
，然后运行该程序名为hello的，而事实上，现在，

557
00:23:46,060 --> 00:23:48,080
我的Hello World。

558
00:23:48,080 --> 00:23:51,640
所有的权利，任何对工作流的问题或语法

559
00:23:51,640 --> 00:23:52,890
我们只是做了什么？

560
00:23:55,380 --> 00:23:57,040
>> 好吧，让我们再次上升了一个档次的东西。

561
00:23:57,040 --> 00:24:00,430
因此，这给人留下深刻印象，只写一个程序，只

562
00:24:00,430 --> 00:24:01,790
曾经说：“你好，世界。

563
00:24:01,790 --> 00:24:03,920
所以，我们改变了它，在星期一，说，你好，大卫。

564
00:24:03,920 --> 00:24:06,560
这是一个有点多个人，但只是作为硬编码为

565
00:24:06,560 --> 00:24:07,410
第一个版本。

566
00:24:07,410 --> 00:24:08,780
所以不是所有的引人注目。

567
00:24:08,780 --> 00:24:13,120
但是存在，在C，功能当然除了

568
00:24:13,120 --> 00:24:15,700
打印功能，可以让您的用户输入。

569
00:24:15,700 --> 00:24:17,990
的方式，我们这样做，有一天，情况如下。

570
00:24:17,990 --> 00:24:21,440
其实我之前打印出来的东西，我第一次

571
00:24:21,440 --> 00:24:22,410
从用户的东西。

572
00:24:22,410 --> 00:24:23,370
因此，让我再这样做。

573
00:24:23,370 --> 00:24:26,580
>> 字符串s，其中s是只是一个任意的名称，在这里，对于一个

574
00:24:26,580 --> 00:24:30,600
字符串，等于GetString的。

575
00:24:30,600 --> 00:24:32,070
那么，什么是GetString的？

576
00:24:32,070 --> 00:24:34,630
显然，它获取一个字符串，根据其名称。

577
00:24:34,630 --> 00:24:37,560
但究竟是什么，技术上呢？

578
00:24:37,560 --> 00:24:38,440
这是一个函数。

579
00:24:38,440 --> 00:24:41,790
所以这是一个使用C本身功能不来。

580
00:24:41,790 --> 00:24:43,660
CS50人员写了这个。

581
00:24:43,660 --> 00:24:46,940
因此，对于使用这个，你不能只包括stdio.h中，

582
00:24:46,940 --> 00:24:49,630
您还需要包括什么？

583
00:24:49,630 --> 00:24:50,060
是啊。

584
00:24:50,060 --> 00:24:54,210
因此，cs50.h，这仅仅是一个文件，我们几年前写的。

585
00:24:54,210 --> 00:24:57,130
我们把它安装在你一起家电

586
00:24:57,130 --> 00:24:58,490
所有的标准文件。

587
00:24:58,490 --> 00:25:00,500
因此，在这些最初的几个星期之类的，我们将使用

588
00:25:00,500 --> 00:25:02,820
这只是为了简化的过程中，做的非常基本的

589
00:25:02,820 --> 00:25:04,600
之类的东西获取用户输入。

590
00:25:04,600 --> 00:25:07,370
因为在几个星期内我们会看到，在获取用户输入

591
00:25:07,370 --> 00:25:10,180
像C语言实际上是出奇的复杂，

592
00:25:10,180 --> 00:25:14,360
特别是因为你不事先知道的，通常情况下，如何

593
00:25:14,360 --> 00:25:17,030
太多的东西，用户要输入英寸

594
00:25:17,030 --> 00:25:20,340
当你不知道多少数据，你不

595
00:25:20,340 --> 00:25:22,380
我知道如何分配多少内存。

596
00:25:22,380 --> 00:25:25,480
如果你真的有对抗性的用户是谁试图

597
00:25:25,480 --> 00:25:28,180
入侵到你的系统，你的电脑崩溃，好了，

598
00:25:28,180 --> 00:25:31,600
一般的攻击方法是，就像我一样

599
00:25:31,600 --> 00:25:34,950
周一，键入一个长序列的随机字符，

600
00:25:34,950 --> 00:25:37,020
按下回车键，看什么打破。

601
00:25:37,020 --> 00:25:40,800
因为一般来说，如果程序中断，这暗示

602
00:25:40,800 --> 00:25:42,650
，潜在的安全漏洞。

603
00:25:42,650 --> 00:25:45,250
这当然暗示了你，程序员，做了

604
00:25:45,250 --> 00:25:49,050
错误，但更危险的是，你可能已经做了

605
00:25:49,050 --> 00:25:52,430
与安全相关的错误，而且通常我们会看到，

606
00:25:52,430 --> 00:25:54,840
机被攻破这一天，

607
00:25:54,840 --> 00:25:56,620
在世界上的网页和方案，

608
00:25:56,620 --> 00:25:58,070
命令行，像这样。

609
00:25:58,070 --> 00:25:58,350
>> 好的。

610
00:25:58,350 --> 00:26:00,460
因此，字符串s = GetString的。

611
00:26:00,460 --> 00:26:03,380
所以更具体，第6行做什么吗？

612
00:26:03,380 --> 00:26:05,640
因此，在右边的功能得到字符串，

613
00:26:05,640 --> 00:26:06,890
需要多少个参数？

614
00:26:09,458 --> 00:26:09,900
好吧。

615
00:26:09,900 --> 00:26:10,400
所以，没有。

616
00:26:10,400 --> 00:26:11,360
一点点神智检查。

617
00:26:11,360 --> 00:26:15,380
再次，是一个参数，只是输入到函数改变

618
00:26:15,380 --> 00:26:17,250
在某种程度上，它的默认行为。

619
00:26:17,250 --> 00:26:19,540
但是，在这种情况下，我并不想改变

620
00:26:19,540 --> 00:26:20,650
GetString的行为。

621
00:26:20,650 --> 00:26:22,430
我只想得到一个字符串。

622
00:26:22,430 --> 00:26:25,190
所以，我什么也没有括号中的，然后我把一个

623
00:26:25,190 --> 00:26:27,550
分号demarking的代码行的末尾。

624
00:26:27,550 --> 00:26:29,840
现在，等号，不等于，本身。

625
00:26:29,840 --> 00:26:32,690
这意味着分配，这意味着把任何得到

626
00:26:32,690 --> 00:26:36,060
无论是在左边上的右内侧输出。

627
00:26:36,060 --> 00:26:39,400
>> 因此，在左边，我们说，我们已经宣布一个

628
00:26:39,400 --> 00:26:41,630
字符串调用。

629
00:26:41,630 --> 00:26:44,240
更特别的是，我们已经分配内存里面的

630
00:26:44,240 --> 00:26:46,340
我们可以把位序列

631
00:26:46,340 --> 00:26:46,850
字符。

632
00:26:46,850 --> 00:26:49,400
但今天，我们已拨出

633
00:26:49,400 --> 00:26:51,450
或宣布一个字符串。

634
00:26:51,450 --> 00:26:51,790
好的。

635
00:26:51,790 --> 00:26:54,760
所以，现在一旦我这样做，我想插入的价值

636
00:26:54,760 --> 00:26:56,535
，而不是大卫的价值。

637
00:26:56,535 --> 00:27:00,200
因此，这是错误的，为什么呢？

638
00:27:03,060 --> 00:27:04,870
因此，这只是字面上的硬编码的小号。

639
00:27:04,870 --> 00:27:06,870
这是说“你好，”这是不是我想要的。

640
00:27:06,870 --> 00:27:07,790
所以，我可以做到这一点。

641
00:27:07,790 --> 00:27:10,330
百分号是一个占位符，但现在我需要

642
00:27:10,330 --> 00:27:12,520
打印第二个参数传入。

643
00:27:12,520 --> 00:27:15,160
回想一下，函数的参数分离

644
00:27:15,160 --> 00:27:20,300
逗号，所以这里的一个逗号后，我把这个字母s。

645
00:27:20,300 --> 00:27:23,740
在这方面，S是可变的，和printf，

646
00:27:23,740 --> 00:27:25,550
在收到这两个输入 - 

647
00:27:25,550 --> 00:27:29,440
上的字符串的左侧，而在右边的变量名称s  - 

648
00:27:29,440 --> 00:27:32,750
它会堵塞后者成为前者对我们来说，

649
00:27:32,750 --> 00:27:34,600
只是打印出一个漂亮的美丽的字符串，其中包含

650
00:27:34,600 --> 00:27:36,770
不管它是什么，我们键入。

651
00:27:36,770 --> 00:27:37,560
>> 所以，让我们来试试这个。

652
00:27:37,560 --> 00:27:38,860
要继续前进，放大了出来，回到

653
00:27:38,860 --> 00:27:40,250
我的终端窗口。

654
00:27:40,250 --> 00:27:41,840
在底部放大了。

655
00:27:41,840 --> 00:27:44,070
重新输入使招呼。

656
00:27:44,070 --> 00:27:45,870
铛似乎已经重新运行。

657
00:27:45,870 --> 00:27:49,280
我要键入。/你好，回车。

658
00:27:49,280 --> 00:27:52,145
似乎没有发生，但在此提示

659
00:27:52,145 --> 00:27:55,700
我可以键入一些东西，像内特，输入，而现在我们有

660
00:27:55,700 --> 00:27:56,380
你好，内特。

661
00:27:56,380 --> 00:27:59,600
，我还可以再与Rob，等等。

662
00:27:59,600 --> 00:28:03,410
所以希望现在这个程序的行为，我打算。

663
00:28:03,410 --> 00:28:05,720
>> 现在，不是所有的用户友好。

664
00:28:05,720 --> 00:28:07,930
我不知道什么是对我的期望。

665
00:28:07,930 --> 00:28:09,620
因此，我们可以肯定清理了一点点。

666
00:28:09,620 --> 00:28:13,270
让我回到了这里，而不是只是潜水，

667
00:28:13,270 --> 00:28:16,480
要求用户为一个字符串，让我明确地告诉

668
00:28:16,480 --> 00:28:17,750
用户，我期待的是什么。

669
00:28:17,750 --> 00:28:21,610
所以printf（“请输入一个字符串：”

670
00:28:21,610 --> 00:28:24,080
）;

671
00:28:24,080 --> 00:28:25,510
所以这里不变量。

672
00:28:25,510 --> 00:28:26,750
没有百分号。

673
00:28:26,750 --> 00:28:28,550
只是简单的英语短语。

674
00:28:28,550 --> 00:28:34,030
现在让我去的底部，然后重新运行我的程序。

675
00:28:34,030 --> 00:28:35,380
但似乎什么都没有发生了变化。

676
00:28:35,380 --> 00:28:37,350
为什么呢？

677
00:28:37,350 --> 00:28:38,380
我必须重新编译它。

678
00:28:38,380 --> 00:28:39,570
所以容易犯的错误。

679
00:28:39,570 --> 00:28:41,700
但是，你不仅要保存该文件，但

680
00:28:41,700 --> 00:28:43,260
重新编译程序。

681
00:28:43,260 --> 00:28:46,640
所以，如果我重新运行make您好，现在铛运行。

682
00:28:46,640 --> 00:28:51,800
现在，我可以运行。/打招呼。现在我看到“输入一个字符串：”。

683
00:28:51,800 --> 00:28:52,050
好吧。

684
00:28:52,050 --> 00:28:53,440
现在，这是一个有点更加人性化。

685
00:28:53,440 --> 00:28:55,850
内特，输入，你好，内特。

686
00:28:55,850 --> 00:28:57,310
>> 好吧，让我们再试一次，并开始思考

687
00:28:57,310 --> 00:28:58,080
关于角落的情况下。

688
00:28:58,080 --> 00:29:00,520
所以就像在刮，我们鼓励你或正在

689
00:29:00,520 --> 00:29:03,180
鼓励在规范中那种认为什么可以去

690
00:29:03,180 --> 00:29:06,610
错了，如果你没有预料到用户可能做的一切。

691
00:29:06,610 --> 00:29:08,050
因此，错误，可能会随之而来。

692
00:29:08,050 --> 00:29:09,710
因此，输入一个字符串 - 

693
00:29:09,710 --> 00:29:11,130
这里一个角落的情况是什么？

694
00:29:11,130 --> 00:29:13,320
有一个场景，我的程序员，可能不会有什么

695
00:29:13,320 --> 00:29:16,070
预期？

696
00:29:16,070 --> 00:29:17,600
是啊。

697
00:29:17,600 --> 00:29:17,920
好吧。

698
00:29:17,920 --> 00:29:22,060
那么，如果我输入一个像这样的数字呢？

699
00:29:22,060 --> 00:29:22,500
好的。

700
00:29:22,500 --> 00:29:24,490
因此，它仍然有效。

701
00:29:24,490 --> 00:29:25,880
Gramatically是没有意义的。

702
00:29:25,880 --> 00:29:27,180
但至少在程序的工作原理。

703
00:29:27,180 --> 00:29:28,650
>> 什么是另一个角落的情况吗？

704
00:29:28,650 --> 00:29:29,610
我没想到的东西。

705
00:29:29,610 --> 00:29:31,590
是吗？

706
00:29:31,590 --> 00:29:31,940
好吧。

707
00:29:31,940 --> 00:29:34,950
所以，我们可以做一些事情是一个非常，非常大的数字。

708
00:29:34,950 --> 00:29:37,270
因此，让我们在这里做。

709
00:29:37,270 --> 00:29:40,880
让我们我缩小为第二，我要强调。

710
00:29:40,880 --> 00:29:42,250
无法复制并粘贴到这里。

711
00:29:42,250 --> 00:29:42,470
好的。

712
00:29:42,470 --> 00:29:44,440
所以我不能复制和粘贴在这个终端窗口，因此，我们将

713
00:29:44,440 --> 00:29:46,950
它只是模拟。

714
00:29:46,950 --> 00:29:51,340
让我放大了，要包装。

715
00:29:51,340 --> 00:29:52,700
我不打算这样做太长时间，因为它不会

716
00:29:52,700 --> 00:29:54,440
实际上打破了这一计划。

717
00:29:54,440 --> 00:29:55,260
但它可能。

718
00:29:55,260 --> 00:29:55,830
输入。

719
00:29:55,830 --> 00:29:56,580
但事实并非如此。

720
00:29:56,580 --> 00:29:57,050
好的。

721
00:29:57,050 --> 00:29:58,440
但它是一个真正的角落的情况。

722
00:29:58,440 --> 00:30:01,610
唯一的正确行为的原因，这样一来

723
00:30:01,610 --> 00:30:05,820
说话，是因为CS50功能的GetString实际上是

724
00:30:05,820 --> 00:30:08,040
引擎盖下的设计，我们将在几个星期内看到，

725
00:30:08,040 --> 00:30:11,570
自动分配越来越多的RAM，越来越多的

726
00:30:11,570 --> 00:30:14,330
从操作系统的内存，当它发现，哇，

727
00:30:14,330 --> 00:30:16,670
你真的输入在相当长的东西。

728
00:30:16,670 --> 00:30:18,500
现在，这是一个善意的谎言一点点。

729
00:30:18,500 --> 00:30:22,020
如果我们确实暂停相当长的一段时间，我输入了

730
00:30:22,020 --> 00:30:24,640
在键盘上像5十亿个字符

731
00:30:24,640 --> 00:30:28,060
在这里，真的打复制 - 粘贴了不少，我们很可能

732
00:30:28,060 --> 00:30:29,730
可能会导致程序崩溃。

733
00:30:29,730 --> 00:30:32,130
只是有点难以模拟，用有限

734
00:30:32,130 --> 00:30:33,740
的时间量。

735
00:30:33,740 --> 00:30:37,320
>> 另一个角落的情况下，我们可以尝试什么？

736
00:30:37,320 --> 00:30:38,730
是吗？

737
00:30:38,730 --> 00:30:39,020
是啊。

738
00:30:39,020 --> 00:30:40,360
那么，为什么我们不回答什么？

739
00:30:40,360 --> 00:30:43,130
因此，我们必须采取一些行动，因为否则

740
00:30:43,130 --> 00:30:45,060
该方案的，要整天坐在那里闪烁。

741
00:30:45,060 --> 00:30:46,860
但是，如果我只需要敲击回车 - 

742
00:30:46,860 --> 00:30:48,780
好了，现在，看起来还是错误的。

743
00:30:48,780 --> 00:30:51,670
没出事，但也许现在有一个机会，

744
00:30:51,670 --> 00:30:54,190
开始实施更严格的程序

745
00:30:54,190 --> 00:30:55,290
实际检查。

746
00:30:55,290 --> 00:30:57,640
而且，如果该字符串，这句话，我的字

747
00:30:57,640 --> 00:31:00,890
输入的长度为0，好，也许我应该喊的

748
00:31:00,890 --> 00:31:03,770
用户，或者告诉他或她再次输入一个字符串，从而使

749
00:31:03,770 --> 00:31:06,560
我们得到正确的行为是什么样子，而不是

750
00:31:06,560 --> 00:31:08,570
只是我的一部分的完整的监督。

751
00:31:08,570 --> 00:31:11,130
>> 问题在后面呢？

752
00:31:11,130 --> 00:31:11,970
十进制数。

753
00:31:11,970 --> 00:31:13,120
因此，我们可以尝试了。

754
00:31:13,120 --> 00:31:16,840
1.10000005。

755
00:31:16,840 --> 00:31:19,470
好像，只是工作其实没关系。

756
00:31:19,470 --> 00:31:21,160
这实际上是预期。

757
00:31:21,160 --> 00:31:24,550
尽管我们可能已经输入了数字，则或

758
00:31:24,550 --> 00:31:28,200
数字越大所说，意识到，当我们输入用户

759
00:31:28,200 --> 00:31:31,070
输入和我们使用的是GetString函数，不

760
00:31:31,070 --> 00:31:34,380
无论什么我打字看起来像数字。

761
00:31:34,380 --> 00:31:36,720
回想一下，根据ASCII，一切都在您的

762
00:31:36,720 --> 00:31:39,920
键盘可以被映射到一个数值，

763
00:31:39,920 --> 00:31:41,480
字符，一个字符。

764
00:31:41,480 --> 00:31:44,490
因此，在这种情况下，即使我可能会输入一个数字，

765
00:31:44,490 --> 00:31:48,190
计算机将想起来了，可以这么说，作为一个字符串 - 

766
00:31:48,190 --> 00:31:49,870
的东西，看起来像一个数字，但

767
00:31:49,870 --> 00:31:51,090
实际上不是一个数字。

768
00:31:51,090 --> 00:31:53,450
但是，这实际上是一个完美的SEGUE，因为现在我们可以

769
00:31:53,450 --> 00:31:55,450
其实过渡到编写程序，

770
00:31:55,450 --> 00:31:56,730
使用其他数据类型。

771
00:31:56,730 --> 00:32:01,840
>> 因此，除了使用字符，或者更确切地说，除了使用字符串，

772
00:32:01,840 --> 00:32:04,510
认识到，我们在C具有其他数据类型，以及在

773
00:32:04,510 --> 00:32:05,230
其他语言。

774
00:32:05,230 --> 00:32:08,480
一个char，顾名思义，仅仅是一个单个字符。

775
00:32:08,480 --> 00:32:12,150
一个浮点数浮点值，而这只是一个花哨的

776
00:32:12,150 --> 00:32:14,470
说实数的方式 - 有小数点的东西，

777
00:32:14,470 --> 00:32:17,410
在它与点的左和/或右的一些数字。

778
00:32:17,410 --> 00:32:21,370
int是一个整数，它只是一个数字123。

779
00:32:21,370 --> 00:32:24,170
而现在更有趣的事情，如双。

780
00:32:24,170 --> 00:32:28,540
我们说什么了双是最后一次吗？

781
00:32:28,540 --> 00:32:30,050
它是64，正确的。

782
00:32:30,050 --> 00:32:33,560
而通常一个浮点数是32位 - 

783
00:32:33,560 --> 00:32:37,340
所以它的这个长在内存中，它使用32个零和的，

784
00:32:37,340 --> 00:32:40,530
代表值 - 双是名副其实的两倍，

785
00:32:40,530 --> 00:32:43,810
意味着你可以代表更大的数字，

786
00:32:43,810 --> 00:32:45,810
你能代表更精确的数字。

787
00:32:45,810 --> 00:32:48,690
所以，你可以有更多的数字小数点后的，但

788
00:32:48,690 --> 00:32:51,520
在视频中说的家伙，即使是简单的东西

789
00:32:51,520 --> 00:32:55,360
概念上有1/3不能代表正是由

790
00:32:55,360 --> 00:32:58,330
电脑，因为最终你用完位，和

791
00:32:58,330 --> 00:33:02,510
因此，你只能做0.33333333所以很多时候，在

792
00:33:02,510 --> 00:33:05,050
这点，你刚才说我的代表

793
00:33:05,050 --> 00:33:08,120
空间，我要的只是收工，并代表它

794
00:33:08,120 --> 00:33:10,200
有些不准确。

795
00:33:10,200 --> 00:33:11,110
很长很长 - 

796
00:33:11,110 --> 00:33:13,880
愚蠢的名字，但它是因为有一个数据类型被称为

797
00:33:13,880 --> 00:33:19,350
而巧合的是32位，就像一个经常在C

798
00:33:19,350 --> 00:33:21,670
int是32位，但很长很长的

799
00:33:21,670 --> 00:33:23,560
一般为64位。

800
00:33:23,560 --> 00:33:25,740
因此，它只是意味着你可以代表大

801
00:33:25,740 --> 00:33:26,990
超过这个数字。

802
00:33:26,990 --> 00:33:27,410
>> 好的。

803
00:33:27,410 --> 00:33:29,390
所以，如果我们真的要开始代表的东西，我们

804
00:33:29,390 --> 00:33:31,030
可能需要更复杂的类型，并

805
00:33:31,030 --> 00:33:32,340
这就是为什么我们有字符串。

806
00:33:32,340 --> 00:33:36,450
因此，在的CS50库，文件名为cs50.h，我们

807
00:33:36,450 --> 00:33:41,110
实际上宣布的数据类型，可以这么说，叫串，

808
00:33:41,110 --> 00:33:42,710
但字符串实际上并不存在。

809
00:33:42,710 --> 00:33:44,780
再次，这是这些层我们要剥离

810
00:33:44,780 --> 00:33:47,490
早在一两个星期，把它扔掉，和实际

811
00:33:47,490 --> 00:33:49,640
看看下面的罩实际上是一个字符串，

812
00:33:49,640 --> 00:33:50,840
它是如何派代表出席了会议。

813
00:33:50,840 --> 00:33:53,520
我们也去看看布尔值。

814
00:33:53,520 --> 00:33:56,040
>> 那么什么是一个布尔值的背景下，从头开始吗？

815
00:33:59,154 --> 00:34:00,300
这是真还是假。

816
00:34:00,300 --> 00:34:03,900
因此，它只是一个值是真还是假，开启或关闭，或

817
00:34:03,900 --> 00:34:06,140
0，但是你要查看的世界。

818
00:34:06,140 --> 00:34:09,739
因此，在C，这要感谢的CS​​50库，这反过来又

819
00:34:09,739 --> 00:34:12,179
包括引擎盖下方的另一个库，我们有

820
00:34:12,179 --> 00:34:14,909
访问的数据类型，被称为布尔值，

821
00:34:14,909 --> 00:34:18,730
从字面上让我们到指定的值true或false

822
00:34:18,730 --> 00:34:20,219
在一个程序中的事情。

823
00:34:20,219 --> 00:34:23,880
>> 所以，让我们继续在这里写一个小程序，

824
00:34:23,880 --> 00:34:26,330
涉及数字，而不是做一些事情。

825
00:34:26,330 --> 00:34:29,840
因此，让我回去CS50电器，让我继续前进，

826
00:34:29,840 --> 00:34:32,770
创建一个新的文件，这里所说的 - 

827
00:34:32,770 --> 00:34:35,460
让我们只说简单的东西，像math.c.

828
00:34:38,270 --> 00:34:38,710
好的。

829
00:34:38,710 --> 00:34:41,600
而现在我的程序上去的，我

830
00:34:41,600 --> 00:34:42,510
通常要做的 - 

831
00:34:42,510 --> 00:34:44,780
＃<stdio.h>中，这样我就可以使用

832
00:34:44,780 --> 00:34:46,860
printf的，诠释的主要（无效） - 

833
00:34:46,860 --> 00:34:49,270
我们会回来，最终，诠释意味着什么

834
00:34:49,270 --> 00:34:52,389
在这里，在这里的意思是什么无效，但就目前而言，只是知道，

835
00:34:52,389 --> 00:34:54,270
你要启动这样的程序。

836
00:34:54,270 --> 00:34:56,280
现在，我要继续前进，说的东西一点点

837
00:34:56,280 --> 00:35:02,110
不同的 -  printf（“请给我一个数字：

838
00:35:02,110 --> 00:35:03,570
。）;

839
00:35:03,570 --> 00:35:09,220
然后，我该怎么办廉政n =调用getInt，因为它

840
00:35:09,220 --> 00:35:12,770
原来调用getInt是另一个函数，在CS50库

841
00:35:12,770 --> 00:35:14,060
除了getString。

842
00:35:14,060 --> 00:35:17,340
而现在，我会做一些愚蠢的，像“感谢

843
00:35:17,340 --> 00:35:25,760
的％d“，为十进制整数，然后逗号N，

844
00:35:25,760 --> 00:35:26,620
然后返回0。

845
00:35:26,620 --> 00:35:28,940
所以，再一次，返回0，有没有做我的

846
00:35:28,940 --> 00:35:30,080
询问用户。

847
00:35:30,080 --> 00:35:33,620
只是表示，大概，是在年底。

848
00:35:33,620 --> 00:35:36,290
>> 所以，让我去到我的终端窗口。

849
00:35:36,290 --> 00:35:39,590
让我的类型进行数学，输入。

850
00:35:39,590 --> 00:35:41,360
东西是错误的。

851
00:35:41,360 --> 00:35:44,620
使数学不工作。

852
00:35:44,620 --> 00:35:46,170
这是第一个错误消息。

853
00:35:46,170 --> 00:35:46,570
为什么呢？

854
00:35:46,570 --> 00:35:49,720
有点神秘，但是 - 

855
00:35:49,720 --> 00:35:50,060
是啊。

856
00:35:50,060 --> 00:35:51,240
所以cs50.h.

857
00:35:51,240 --> 00:35:53,900
如此反复，特别是早期，你会写你的第一个

858
00:35:53,900 --> 00:35:56,590
程序的pset 1节，于办公时间内，

859
00:35:56,590 --> 00:35:59,050
坦率地说，这将是压倒性的，有时这些事是什么

860
00:35:59,050 --> 00:36:00,000
实际上说。

861
00:36:00,000 --> 00:36:01,890
不过，你就会意识到非常快，他们开始下降

862
00:36:01,890 --> 00:36:06,120
据此，这意味着你离开到桶

863
00:36:06,120 --> 00:36:08,290
＃包括的文件的顶部。

864
00:36:08,290 --> 00:36:10,960
铛，编译器，通知你的

865
00:36:10,960 --> 00:36:14,090
说，而美丽的，隐含的声明

866
00:36:14,090 --> 00:36:15,990
函数调用getInt是无效的。

867
00:36:15,990 --> 00:36:16,310
>> 好的。

868
00:36:16,310 --> 00:36:17,520
那么，是什么意思呢？

869
00:36:17,520 --> 00:36:22,080
它只是意味着你已经隐式声明的调用getInt在

870
00:36:22,080 --> 00:36:24,850
这个意义上，你没有明确宣布它。

871
00:36:24,850 --> 00:36:27,300
要明确地声明int，你必须教

872
00:36:27,300 --> 00:36:28,740
铛它的存在。

873
00:36:28,740 --> 00:36:32,020
非常简单的解决方案就是教

874
00:36:32,020 --> 00:36:34,780
包括本其他的的文件，cs50.h，

875
00:36:34,780 --> 00:36:35,850
文件的开头。

876
00:36:35,850 --> 00:36:40,380
因为从字面上看，哪些＃include是告诉铛

877
00:36:40,380 --> 00:36:44,030
几乎去找到该文件名为cs50.h，复印，

878
00:36:44,030 --> 00:36:48,150
对我来说，它会自动粘贴到我的程序的顶部，

879
00:36:48,150 --> 00:36:50,850
然后将其转换的源代码，零和的。

880
00:36:50,850 --> 00:36:52,850
但是，这显然是非常乏味的，如果我们人类有

881
00:36:52,850 --> 00:36:55,370
去复制和粘贴这些大文件的时间，

882
00:36:55,370 --> 00:36:58,540
所以＃包括所有的情况下自动

883
00:36:58,540 --> 00:37:01,550
弄脏我的代码用别人的库。

884
00:37:01,550 --> 00:37:06,370
图书馆是另一个文件包含的功能和

885
00:37:06,370 --> 00:37:08,340
其他的东西，别人写的，我们是

886
00:37:08,340 --> 00:37:10,270
利用我们自己的利益。

887
00:37:10,270 --> 00:37:10,580
>> 好的。

888
00:37:10,580 --> 00:37:11,200
让我们再试一次。

889
00:37:11,200 --> 00:37:12,250
使数学。

890
00:37:12,250 --> 00:37:13,120
输入。

891
00:37:13,120 --> 00:37:13,530
好。

892
00:37:13,530 --> 00:37:14,880
因此，这似乎发挥了作用。

893
00:37:14,880 --> 00:37:18,330
因此，让我现在运行的数学/数学。

894
00:37:18,330 --> 00:37:21,100
输入给了我一个号码，123。

895
00:37:21,100 --> 00:37:22,620
感谢为123。

896
00:37:22,620 --> 00:37:24,490
现在，让我们尝试另一个角落的情况。

897
00:37:24,490 --> 00:37:26,530
一个字符串是非常慷慨的，因为

898
00:37:26,530 --> 00:37:27,620
字符串可以是任何东西。

899
00:37:27,620 --> 00:37:28,910
可以像数字，看起来像

900
00:37:28,910 --> 00:37:30,600
字符，看起来都像是单词。

901
00:37:30,600 --> 00:37:31,900
但是，int类型是int。

902
00:37:31,900 --> 00:37:34,370
所以，现在如果我困难的用户，它说：“给我

903
00:37:34,370 --> 00:37:38,730
一个数字，“如果我尝试做一些事情（如0.1）？

904
00:37:38,730 --> 00:37:41,510
嗯，这是一个数字，这是符合

905
00:37:41,510 --> 00:37:44,180
语法我在这里使用，但引擎盖下的，我的

906
00:37:44,180 --> 00:37:45,610
当然，使用函数调用getInt。

907
00:37:45,610 --> 00:37:46,610
>> 因此，让我们看看会发生什么。

908
00:37:46,610 --> 00:37:48,250
回车键，然后重试。

909
00:37:48,250 --> 00:37:48,560
好的。

910
00:37:48,560 --> 00:37:50,570
让我是困难的，只需要敲击回车再次。

911
00:37:50,570 --> 00:37:51,700
输入，回车。

912
00:37:51,700 --> 00:37:53,890
因此，现在看来，调用getInt多一点

913
00:37:53,890 --> 00:37:55,240
强大的比GetString的。

914
00:37:55,240 --> 00:37:58,540
我们的工作人员，在这样一种方式，如果我们注意到实施

915
00:37:58,540 --> 00:38:02,100
你有没有给我们一个int  - 一个int是一个十进制数

916
00:38:02,100 --> 00:38:04,785
包含零的人，三三两两，三，四，五，六人木球赛，

917
00:38:04,785 --> 00:38:05,540
七，八，九。

918
00:38:05,540 --> 00:38:06,310
就是这样。

919
00:38:06,310 --> 00:38:08,810
没有小数点，没有人物，没有标点符号。

920
00:38:08,810 --> 00:38:10,390
看来，我们有合作。

921
00:38:10,390 --> 00:38:13,680
所以，让我来试试四，五，六，让我通过。

922
00:38:13,680 --> 00:38:16,760
所以，真的，是肛这里，我可能会说：“给我

923
00:38:16,760 --> 00:38:20,310
为了传达给用户一个整数“

924
00:38:20,310 --> 00:38:22,620
正是我打算。

925
00:38:22,620 --> 00:38:24,090
>> 现在，让我们觉得引擎盖下的。

926
00:38:24,090 --> 00:38:27,930
我们不打算在，如何cs50.h实施今天，

927
00:38:27,930 --> 00:38:29,080
该库。

928
00:38:29,080 --> 00:38:33,600
但是，如果它口口声声说重试，重试，重试，什么编程

929
00:38:33,600 --> 00:38:36,970
构建我大概用下面的罩

930
00:38:36,970 --> 00:38:39,000
实现了吗？

931
00:38:39,000 --> 00:38:39,980
因此，只要一个循环，对不对？

932
00:38:39,980 --> 00:38:41,930
其中一个最简单的想法，我们从头看到。

933
00:38:41,930 --> 00:38:45,050
永远的建设，重复建设。

934
00:38:45,050 --> 00:38:47,320
据推测，在这个程序中，引擎盖下的，即使

935
00:38:47,320 --> 00:38:49,470
虽然它的C语言编写的，而不是从头开始，它在做什么

936
00:38:49,470 --> 00:38:54,300
什么叫如果用户永远不

937
00:38:54,300 --> 00:38:58,710
输入整数，说重试，重试，重试，重试，所以

938
00:38:58,710 --> 00:39:01,220
最后，当我们这么做的时候得到一个整数，那么你

939
00:39:01,220 --> 00:39:02,970
跳出这个循环。

940
00:39:02,970 --> 00:39:05,610
>> 那么，还有什么其他的功能，我们可以使用在这里在CS50的图书馆？

941
00:39:05,610 --> 00:39:07,880
好了，种明显的，至少基础上，

942
00:39:07,880 --> 00:39:09,570
数据类型，我们现在知道存在。

943
00:39:09,570 --> 00:39:12,900
我们实施GetString时，调用getInt，但在整个

944
00:39:12,900 --> 00:39:15,680
这个词的第一个星期，你也可以使用getFloat先把及

945
00:39:15,680 --> 00:39:18,870
为了得到精确的GetDouble和GetLongLong

946
00:39:18,870 --> 00:39:20,030
数据类型，你想要的。

947
00:39:20,030 --> 00:39:24,030
因为这里的关键细节是，不像某些语言中，

948
00:39:24,030 --> 00:39:26,630
Python和Ruby等，在那里你不一定要

949
00:39:26,630 --> 00:39:29,730
声明变量的数据类型 - 

950
00:39:29,730 --> 00:39:32,390
你不必告诉计算机什么样的东西

951
00:39:32,390 --> 00:39:34,000
你要放入变量 - 

952
00:39:34,000 --> 00:39:36,640
C，你必须要非常精确。

953
00:39:36,640 --> 00:39:40,060
所以，如果你想有一个变量n，一大块存储

954
00:39:40,060 --> 00:39:42,900
在这种情况下，恰好是32位的，按照惯例，你

955
00:39:42,900 --> 00:39:45,660
必须告诉电脑，这些位是

956
00:39:45,660 --> 00:39:47,840
要存储一个数字 - 

957
00:39:47,840 --> 00:39:50,630
不是一个字符，而不是一个字符串，而不是一个float。

958
00:39:50,630 --> 00:39:52,620
这解决了问题，我们有效地

959
00:39:52,620 --> 00:39:53,760
跑进上周。

960
00:39:53,760 --> 00:39:57,050
如果我们使用的是零和的数字，不只是代表

961
00:39:57,050 --> 00:40:00,770
电话号码，但由于BS和CS，如何在世界上是一个

962
00:40:00,770 --> 00:40:03,460
电脑要知道，这种模式实际使用的位

963
00:40:03,460 --> 00:40:07,650
表示数字65，而不是代表

964
00:40:07,650 --> 00:40:09,860
字母A，巧合的是，根据

965
00:40:09,860 --> 00:40:13,440
ASCII，记得，相当于65？

966
00:40:13,440 --> 00:40:16,550
>> 因此，这些数据类型提供了上下文到电脑上，所以

967
00:40:16,550 --> 00:40:18,810
它知道，如果这些位应该被解释为

968
00:40:18,810 --> 00:40:23,660
int或一个字符串。

969
00:40:23,660 --> 00:40:26,500
如有任何疑问，然后，在此吗？

970
00:40:26,500 --> 00:40:28,149
是吗？

971
00:40:34,780 --> 00:40:35,270
DAVID J.马兰：好问题。

972
00:40:35,270 --> 00:40:39,140
如果我们采取了stdio.h中，我们保存文件 - 

973
00:40:39,140 --> 00:40:44,360
让我去到终端窗口，并运行数学，放大

974
00:40:44,360 --> 00:40:45,530
在进入 - 

975
00:40:45,530 --> 00:40:47,700
现在，我得到一个不同的错误，因为我含蓄地

976
00:40:47,700 --> 00:40:49,650
声明现在什么功能？

977
00:40:49,650 --> 00:40:50,700
printf的。

978
00:40:50,700 --> 00:40:52,970
所以，现在我已经创建了一个新的问题，它的解决方案是

979
00:40:52,970 --> 00:40:53,890
本质上是相同的。

980
00:40:53,890 --> 00:40:55,365
我需要把回来。

981
00:40:55,365 --> 00:40:56,615
观众：[听不清]

982
00:41:03,534 --> 00:41:04,030
DAVID J.马兰：哦。

983
00:41:04,030 --> 00:41:04,850
所以，如果我拿出 - 

984
00:41:04,850 --> 00:41:05,360
好吧，是的。

985
00:41:05,360 --> 00:41:08,960
所以，如果我删除的标准I / O库包含

986
00:41:08,960 --> 00:41:12,020
在这里，然后你说，如果我摆脱的printf，得到

987
00:41:12,020 --> 00:41:13,450
摆脱了printf？

988
00:41:13,450 --> 00:41:13,810
是。

989
00:41:13,810 --> 00:41:18,450
这应该工作，因为我不再使用任何 - 哎呦。

990
00:41:18,450 --> 00:41:20,110
我只是撒了谎？

991
00:41:20,110 --> 00:41:21,650
哦，好吧。

992
00:41:21,650 --> 00:41:25,640
这是不行的，因为我们刚刚推出了一个新的错误。

993
00:41:25,640 --> 00:41:28,390
这是一个小更不言自明。

994
00:41:28,390 --> 00:41:29,440
>> 有什么问题吗？

995
00:41:29,440 --> 00:41:30,680
未使用的变量n。

996
00:41:30,680 --> 00:41:34,040
因此，这个错误是由于我们配置了

997
00:41:34,040 --> 00:41:36,640
家电特别是迂腐，要真正大喊大叫

998
00:41:36,640 --> 00:41:39,060
你的每一个可能的错误，即使它的种

999
00:41:39,060 --> 00:41:41,950
这样一个非致命的错误 - 是不是真的这么大的

1000
00:41:41,950 --> 00:41:44,820
处理，我分配一个int，提出了一些，然后

1001
00:41:44,820 --> 00:41:46,030
只是做了什么呢？

1002
00:41:46,030 --> 00:41:47,020
因此，在功能上，没有。

1003
00:41:47,020 --> 00:41:50,410
这并不是要打破计划。

1004
00:41:50,410 --> 00:41:51,490
这只是一种愚蠢的，对不对？

1005
00:41:51,490 --> 00:41:54,220
有没有要求数量，存储的值

1006
00:41:54,220 --> 00:41:56,370
在一个变量中，如果你永远也不会做任何事情

1007
00:41:56,370 --> 00:41:58,000
有了它，无论它打印或保存。

1008
00:41:58,000 --> 00:42:00,270
因此，在这种情况下，锵确认一样多，并

1009
00:42:00,270 --> 00:42:02,010
它说未使用的变量n。

1010
00:42:02,010 --> 00:42:05,380
>> 因此，我们可以解决这个问题，如果我们真正想要的。

1011
00:42:05,380 --> 00:42:07,250
但是，这是不是一种好的编程。

1012
00:42:07,250 --> 00:42:09,310
所以，我可以做到这一点 - 

1013
00:42:09,310 --> 00:42:12,060
在这里，让我清楚的画面，使数学。

1014
00:42:12,060 --> 00:42:13,090
该工程。

1015
00:42:13,090 --> 00:42:18,110
我现在可以运行我的数学程序，需要输入 - 

1016
00:42:18,110 --> 00:42:18,700
嗯，这是不好的。

1017
00:42:18,700 --> 00:42:23,450
接受输入，那就是，在这种情况下，所有它。

1018
00:42:23,450 --> 00:42:25,220
>> 因此，实际上，让我们尝试另外一个角落的情况，我们

1019
00:42:25,220 --> 00:42:26,300
没想到的早期。

1020
00:42:26,300 --> 00:42:28,220
在这种情况下 - 在这里，让我们回到一个，这是一个

1021
00:42:28,220 --> 00:42:29,500
对用户来说更加友好。

1022
00:42:29,500 --> 00:42:32,580
让我回到这里，再次运行make数学。

1023
00:42:32,580 --> 00:42:34,190
哎呀，我做了什么错了吗？

1024
00:42:34,190 --> 00:42:35,400
得到进一步回滚。

1025
00:42:35,400 --> 00:42:36,390
好吧。

1026
00:42:36,390 --> 00:42:38,490
现在我们又回到了原来的状态，所有

1027
00:42:38,490 --> 00:42:39,990
是希望。

1028
00:42:39,990 --> 00:42:43,360
而现在，如果我遇到数学，123似乎工作。

1029
00:42:43,360 --> 00:42:46,010
但是，这不是一个真正的有效的证据，只是说

1030
00:42:46,010 --> 00:42:47,930
好吧，这工作的。

1031
00:42:47,930 --> 00:42:49,120
789的作品。

1032
00:42:49,120 --> 00:42:50,100
提交时间。

1033
00:42:50,100 --> 00:42:51,870
因为有其他角落的情况下。

1034
00:42:51,870 --> 00:42:55,040
一个字符串，没有真正给我们太多的麻烦通过键入

1035
00:42:55,040 --> 00:42:56,510
一大堆的字符。

1036
00:42:56,510 --> 00:42:59,580
但是，如果我输入？

1037
00:42:59,580 --> 00:43:04,850
击中了一大堆，这里的很多 - 

1038
00:43:04,850 --> 00:43:06,300
所有权利，它变得有点无聊，所以我要

1039
00:43:06,300 --> 00:43:10,040
停在这里，我要按下回车键。

1040
00:43:10,040 --> 00:43:11,290
>> 你到底发生了什么？

1041
00:43:14,110 --> 00:43:17,680
所以，这其实是可以解释的。

1042
00:43:17,680 --> 00:43:18,920
所以没有把它作为二进制吗？

1043
00:43:18,920 --> 00:43:21,130
一个好的想法，但没有，这是不是事实，即它把它

1044
00:43:21,130 --> 00:43:22,815
二进制，因为事实上，这仅仅是一个怎样的

1045
00:43:22,815 --> 00:43:23,080
巧合。

1046
00:43:23,080 --> 00:43:23,930
我们可以做到这一点。

1047
00:43:23,930 --> 00:43:26,530
因此，有没有，这是二进位制

1048
00:43:26,530 --> 00:43:27,420
可能是足够的了。

1049
00:43:27,420 --> 00:43:28,780
输入。

1050
00:43:28,780 --> 00:43:30,140
所以这是没有问题的。

1051
00:43:30,140 --> 00:43:31,390
还有什么呢？

1052
00:43:34,650 --> 00:43:35,400
没错。

1053
00:43:35,400 --> 00:43:37,830
>> 所以想返回一个int实际上是什么。

1054
00:43:37,830 --> 00:43:40,970
这是32位解释

1055
00:43:40,970 --> 00:43:42,090
为一个数字。

1056
00:43:42,090 --> 00:43:44,730
如果您有32位，这意味着每个比特可以

1057
00:43:44,730 --> 00:43:46,690
是0或1，0或1。

1058
00:43:46,690 --> 00:43:49,090
因此，这意味着有两种可能性，该位，

1059
00:43:49,090 --> 00:43:51,140
这两种可能性，这两种可能性

1060
00:43:51,140 --> 00:43:52,570
位 - 所以这是2倍，2倍 - 

1061
00:43:52,570 --> 00:43:55,480
所以这是2的32次幂的总数

1062
00:43:55,480 --> 00:43:58,960
排列零和的，如果你有32

1063
00:43:58,960 --> 00:44:01,400
占位符，0或1，在你的面前。

1064
00:44:01,400 --> 00:44:04,250
所以，如果我有2到32个，数学，那是什么？

1065
00:44:07,080 --> 00:44:07,840
因此，这是一个很大。

1066
00:44:07,840 --> 00:44:09,910
这是4亿元，给予或采取。

1067
00:44:09,910 --> 00:44:13,510
和4亿美元似乎并没有被打印出来在这里。

1068
00:44:13,510 --> 00:44:16,290
事实上，这看起来更接近至2亿美元。

1069
00:44:16,290 --> 00:44:17,970
但是，这是不是一个巧合。

1070
00:44:17,970 --> 00:44:21,590
事实上，电脑已经误解了我的大量，

1071
00:44:21,590 --> 00:44:24,260
我巨大的，然后我巨大的二进制补码序列，序列

1072
00:44:24,260 --> 00:44:26,880
大约2亿元，是如何解释的呢？

1073
00:44:30,250 --> 00:44:32,180
有一个上限的int。

1074
00:44:32,180 --> 00:44:34,970
有一个肯定，你可以代表的最大值。

1075
00:44:34,970 --> 00:44:36,370
但它通常为4亿元，对不对？

1076
00:44:36,370 --> 00:44:39,100
如果是2到32的约4亿美元，这似乎是

1077
00:44:39,100 --> 00:44:40,350
这是最大的数。

1078
00:44:42,420 --> 00:44:45,240
因此，没有余数，但一个好的想法。

1079
00:44:45,240 --> 00:44:46,340
负数。

1080
00:44:46,340 --> 00:44:49,570
所以，如果你有4亿的事情，你可以

1081
00:44:49,570 --> 00:44:52,970
代表这些不同排列的32 0

1082
00:44:52,970 --> 00:44:55,600
1秒，以及，它会随时原因，我们人类可能要

1083
00:44:55,600 --> 00:44:57,110
不只是代表正整数

1084
00:44:57,110 --> 00:44:58,240
但负整数。

1085
00:44:58,240 --> 00:45:00,410
事实上，这是假设的C。

1086
00:45:00,410 --> 00:45:03,550
因此，32位，你可以代表大致负2

1087
00:45:03,550 --> 00:45:06,630
十亿一路正2亿元。

1088
00:45:06,630 --> 00:45:08,750
因此，在这种情况下，我们真正看到的仅仅是

1089
00:45:08,750 --> 00:45:13,600
附带的能力，我们的整数，并且，因此我们有

1090
00:45:13,600 --> 00:45:15,860
可以说，溢出了整数。

1091
00:45:15,860 --> 00:45:19,180
我们试图把它塞进更多的位比实际上可以适合。

1092
00:45:19,180 --> 00:45:22,960
所以，最终的结果是，我们基本上都为1的位。

1093
00:45:22,960 --> 00:45:25,280
我们所有的位翻转，我们一直在努力，代表

1094
00:45:25,280 --> 00:45:27,630
最大的可能，但它显然不是近

1095
00:45:27,630 --> 00:45:30,960
大到足以代表两件事情，我刚刚输入的字词。

1096
00:45:30,960 --> 00:45:31,730
是吗？

1097
00:45:31,730 --> 00:45:32,980
观众：[听不清]

1098
00:45:37,230 --> 00:45:37,830
>> DAVID J.马兰：好问题。

1099
00:45:37,830 --> 00:45:40,080
为什么我们不能只是表示该负

1100
00:45:40,080 --> 00:45:41,500
签名只是一个字符吗？

1101
00:45:41,500 --> 00:45:44,200
所以，我们绝对可以，我们可以然后保存

1102
00:45:44,200 --> 00:45:45,470
一个附加位。

1103
00:45:45,470 --> 00:45:49,100
但你仍然要代表破折号，和

1104
00:45:49,100 --> 00:45:50,700
这要花费你至少东西，

1105
00:45:50,700 --> 00:45:52,220
想必位。

1106
00:45:52,220 --> 00:45:55,610
所以，是的，我们可以为我们的数32位，但现在

1107
00:45:55,610 --> 00:45:57,610
我们需要另一位用于我们的破折号

1108
00:45:57,610 --> 00:45:58,810
符号，减号。

1109
00:45:58,810 --> 00:46:01,470
所以，现在我们有33位的值，我们可以这样做，但它的

1110
00:46:01,470 --> 00:46:02,570
只是没有办法做这项工作。

1111
00:46:02,570 --> 00:46:05,140
我们做了一个判断调用年前，32位是排序的

1112
00:46:05,140 --> 00:46:06,170
在这里的度量单位。

1113
00:46:06,170 --> 00:46:08,120
因此，我们将使用这些位有效

1114
00:46:08,120 --> 00:46:12,950
代表消极，31位代表的数量。

1115
00:46:12,950 --> 00:46:15,550
其他问题吗？

1116
00:46:15,550 --> 00:46:15,670
好的。

1117
00:46:15,670 --> 00:46:16,030
这是一个很大。

1118
00:46:16,030 --> 00:46:17,930
我们为什么不继续在这里我们五分钟的休息时间吗？

1119
00:46:23,580 --> 00:46:24,270
>> 好的。

1120
00:46:24,270 --> 00:46:31,250
所以，再一次，不要过分强调数学的应用

1121
00:46:31,250 --> 00:46:33,840
的节目，就让我们把她的一个例子

1122
00:46:33,840 --> 00:46:36,590
在我们进入其他结构，只是因为它

1123
00:46:36,590 --> 00:46:39,430
将一些常见的障碍点上的一些说明

1124
00:46:39,430 --> 00:46:41,520
当它涉及到编写程序的基本。

1125
00:46:41,520 --> 00:46:44,360
在这种情况下，这样做的算术表达式，有一些

1126
00:46:44,360 --> 00:46:48,010
有趣的语法的相关性。

1127
00:46:48,010 --> 00:46:50,430
>> 因此，这只是一个公式，我们可以将

1128
00:46:50,430 --> 00:46:52,690
温度从华氏摄氏度。

1129
00:46:52,690 --> 00:46:54,600
如果你不记得，这仅仅是一个公式。

1130
00:46:54,600 --> 00:46:58,870
因此，如果我们插在华氏32度，这是

1131
00:46:58,870 --> 00:47:02,850
冻结，这将是32减去32是0，而事实上，

1132
00:47:02,850 --> 00:47:05,130
0摄氏度也冻结。

1133
00:47:05,130 --> 00:47:08,210
这么快的完整性检查 - 这是熟悉的公式。

1134
00:47:08,210 --> 00:47:10,880
让我去到设备，但是，并开始

1135
00:47:10,880 --> 00:47:13,920
写一个程序称为一样，F2C“华氏

1136
00:47:13,920 --> 00:47:15,920
摄氏点C“。

1137
00:47:15,920 --> 00:47:18,930
在这里的顶部，我要开始用＃include

1138
00:47:18,930 --> 00:47:22,190
stdio.h中，我要诠释的主要（无效），并

1139
00:47:22,190 --> 00:47:24,680
再次，我们将在未来回来整数意味着什么

1140
00:47:24,680 --> 00:47:26,820
有无效意味着什么。

1141
00:47:26,820 --> 00:47:28,770
现在让我继续前进，执行一个程序，

1142
00:47:28,770 --> 00:47:31,170
基本上没有我们这个转换。

1143
00:47:31,170 --> 00:47:36,830
>> 因此我们知道printf，比方说，华氏温度。

1144
00:47:36,830 --> 00:47:40,140
然后让我继续前进，从用户的价值。

1145
00:47:40,140 --> 00:47:43,120
我应该得到什么样的价值，如果我想从用户

1146
00:47:43,120 --> 00:47:45,620
他们给我一个华氏温度？

1147
00:47:45,620 --> 00:47:48,090
是吗？

1148
00:47:48,090 --> 00:47:50,090
你会建议什么？

1149
00:47:50,090 --> 00:47:50,410
是啊。

1150
00:47:50,410 --> 00:47:51,960
因此，浮动的感觉相当合理的。

1151
00:47:51,960 --> 00:47:53,950
再次，我们有几个选项，

1152
00:47:53,950 --> 00:47:55,310
迄今为止，我们已经看到了。

1153
00:47:55,310 --> 00:48:00,100
我们有些事如char，双，浮点型，整型，很长很长，

1154
00:48:00,100 --> 00:48:01,150
布尔，字符串。

1155
00:48:01,150 --> 00:48:03,510
所以这些，的浮动感觉很合理的。

1156
00:48:03,510 --> 00:48:06,340
我们可以用一个双，正确的，因为如果我们真的要

1157
00:48:06,340 --> 00:48:07,580
代表一个人的温度 - 

1158
00:48:07,580 --> 00:48:10,730
98.60000  - 

1159
00:48:10,730 --> 00:48:12,990
要做到这一点，我们可以使用64位，但感觉像

1160
00:48:12,990 --> 00:48:14,200
矫枉过正的温度。

1161
00:48:14,200 --> 00:48:16,380
因此，让我们一起去浮动。

1162
00:48:16,380 --> 00:48:18,100
现在，我需要一个变量。

1163
00:48:18,100 --> 00:48:20,500
只是为了让事情简单，我会打电话给它f，但我

1164
00:48:20,500 --> 00:48:23,370
可以很正确地调用它的温度，

1165
00:48:23,370 --> 00:48:24,600
但无论是好的。

1166
00:48:24,600 --> 00:48:27,610
因此，浮动f = getFloat先把。

1167
00:48:27,610 --> 00:48:30,220
只要我现在已经决定了，不过，我使用getFloat先把

1168
00:48:30,220 --> 00:48:33,340
需要做一个修正。

1169
00:48:33,340 --> 00:48:33,720
是啊。

1170
00:48:33,720 --> 00:48:37,460
因此，我们需要＃包括<cs50.h>的，否则编译器

1171
00:48:37,460 --> 00:48:39,000
要骂我们。

1172
00:48:39,000 --> 00:48:41,720
现在，我有一个浮动，让我继续做

1173
00:48:41,720 --> 00:48:42,460
转换。

1174
00:48:42,460 --> 00:48:44,980
>> 因此，首先让我还养成早睡早起的习惯在这里

1175
00:48:44,980 --> 00:48:46,310
评论我的代码。

1176
00:48:46,310 --> 00:48:49,820
所以，再一次，评论的人，只是一个符号

1177
00:48:49,820 --> 00:48:52,600
不是程序本身的一部分，但它一个，帮助您

1178
00:48:52,600 --> 00:48:55,010
明白你做了什么，第二天早上，或下

1179
00:48:55,010 --> 00:48:57,570
月，它可以帮助你的教学同胞知道你做了什么

1180
00:48:57,570 --> 00:48:59,230
或者你打算做什么，所以它的

1181
00:48:59,230 --> 00:49:00,950
通常是非常好的做法。

1182
00:49:00,950 --> 00:49:02,940
每隔几行代码，写评论

1183
00:49:02,940 --> 00:49:04,490
你或你的同事。

1184
00:49:04,490 --> 00:49:08,460
所以在这里，我会说，“询问用户的温度。”

1185
00:49:08,460 --> 00:49:10,890
不必是一个完整的句子，只是一个简单的短语。

1186
00:49:10,890 --> 00:49:14,270
但在C注释背后的想法是，你的每一个

1187
00:49:14,270 --> 00:49:17,980
意见应赋予你 - 或说，，TF或同事的 - 

1188
00:49:17,980 --> 00:49:21,290
撇去你的程序，不知道它究竟是什么

1189
00:49:21,290 --> 00:49:24,650
这么多的阅读代码，但通过阅读注释，

1190
00:49:24,650 --> 00:49:26,220
应该是简洁明了。

1191
00:49:26,220 --> 00:49:29,030
好了，所以现在让我继续说，“转换

1192
00:49:29,030 --> 00:49:32,660
华氏摄氏度。“所以我要继续做，

1193
00:49:32,660 --> 00:49:34,340
比方说，浮动Ç。

1194
00:49:34,340 --> 00:49:36,610
我们将保持摄氏浮点值。

1195
00:49:36,610 --> 00:49:37,630
>> ，让我带刺在此。

1196
00:49:37,630 --> 00:49:40,350
其计算公式为，再次在这里。

1197
00:49:40,350 --> 00:49:45,510
5/9次F零下32。

1198
00:49:45,510 --> 00:49:46,360
因此，让我们做到这一点。

1199
00:49:46,360 --> 00:49:50,450
因此，5除以9，减 - 

1200
00:49:50,450 --> 00:49:52,330
哎呦，我把事情搞糟了。

1201
00:49:52,330 --> 00:49:53,070
时报。

1202
00:49:53,070 --> 00:49:56,550
因此，5/9倍f零下32。

1203
00:49:56,550 --> 00:49:59,650
所以F减去32，分号。

1204
00:49:59,650 --> 00:50:02,000
而现在，在这里，我要继续前进

1205
00:50:02,000 --> 00:50:03,220
并说，打印结果。

1206
00:50:03,220 --> 00:50:05,160
而这部分很简单。 printf的。

1207
00:50:05,160 --> 00:50:07,980
我该如何去打印此？

1208
00:50:07,980 --> 00:50:16,890
好吧，我可以说，“在摄氏这个数字是％f \ n”，

1209
00:50:16,890 --> 00:50:18,060
只是一些美学。

1210
00:50:18,060 --> 00:50:20,450
什么样的价值，我想在这里插入printf的

1211
00:50:20,450 --> 00:50:21,360
第二个参数？

1212
00:50:21,360 --> 00:50:21,650
好吧。

1213
00:50:21,650 --> 00:50:22,540
因此，只要C。

1214
00:50:22,540 --> 00:50:24,760
因此，我们将从这里开始，然后就返回0。

1215
00:50:24,760 --> 00:50:25,960
再次，它具有与数学无关。

1216
00:50:25,960 --> 00:50:27,610
它只是意味着一切都很好。

1217
00:50:27,610 --> 00:50:31,210
>> 现在，这是正确的，这个程序吗？

1218
00:50:31,210 --> 00:50:31,520
好的。

1219
00:50:31,520 --> 00:50:33,630
所以，我犯了一些错误。

1220
00:50:33,630 --> 00:50:35,980
即使你不知道是什么程序，您可以排序

1221
00:50:35,980 --> 00:50:37,120
的推断回到小学

1222
00:50:37,120 --> 00:50:38,740
可能的错误在这里。

1223
00:50:38,740 --> 00:50:40,050
第一个是什么？

1224
00:50:40,050 --> 00:50:41,256
观众：[听不清]

1225
00:50:41,256 --> 00:50:41,660
DAVID J.马兰：是的。

1226
00:50:41,660 --> 00:50:42,940
因此，我们漏掉括号内。

1227
00:50:42,940 --> 00:50:45,420
这是故意的，我没有括号的基调

1228
00:50:45,420 --> 00:50:48,130
滑动这里，因为这里实际上这个概念的，

1229
00:50:48,130 --> 00:50:51,590
操作，或优先级，使某些操作 - 

1230
00:50:51,590 --> 00:50:52,890
乘法 - 

1231
00:50:52,890 --> 00:50:56,000
有较高的结合，具有较高的优先级，比东西

1232
00:50:56,000 --> 00:50:58,050
如加法或减法。

1233
00:50:58,050 --> 00:51:00,550
因此，我们所做的这几年，只是为了清晰准确

1234
00:51:00,550 --> 00:51:02,840
首先应该做的是什么数学运算。

1235
00:51:02,840 --> 00:51:05,010
所以，我也许应该模仿的正是这一点。

1236
00:51:05,010 --> 00:51:08,990
否则，电脑大概要尝试做

1237
00:51:08,990 --> 00:51:13,090
类似9鸿沟5，再乘以F，然后减去

1238
00:51:13,090 --> 00:51:14,850
32从整个事情。

1239
00:51:14,850 --> 00:51:16,480
这不，事实上，我们想要做的是什么。

1240
00:51:16,480 --> 00:51:17,340
因此，让我们括号。

1241
00:51:17,340 --> 00:51:20,860
让我们添加我的括号，括号在这里。

1242
00:51:20,860 --> 00:51:22,670
让我们把这个在这里。

1243
00:51:22,670 --> 00:51:25,130
在这里，我只注意到另一个错误，我一路走来。

1244
00:51:25,130 --> 00:51:25,680
是吗？

1245
00:51:25,680 --> 00:51:26,930
观众：[听不清]

1246
00:51:29,632 --> 00:51:30,130
>> DAVID J.马兰啊。

1247
00:51:30,130 --> 00:51:30,470
好。

1248
00:51:30,470 --> 00:51:32,400
所以，我们其实有相同的整数

1249
00:51:32,400 --> 00:51:34,020
从之前的分工问题。

1250
00:51:34,020 --> 00:51:35,800
我纠正这个问题，让我们来看看是什么症状。

1251
00:51:35,800 --> 00:51:36,990
但是我们要纠正一个

1252
00:51:36,990 --> 00:51:37,680
这里的其他错误。

1253
00:51:37,680 --> 00:51:38,015
是吗？

1254
00:51:38,015 --> 00:51:39,540
观众：[听不清]

1255
00:51:39,540 --> 00:51:40,070
DAVID J.马兰：是的。

1256
00:51:40,070 --> 00:51:43,130
所以，我做了愚蠢的错误，但非常重要的。

1257
00:51:43,130 --> 00:51:45,870
电脑是不会视而不见，只是让

1258
00:51:45,870 --> 00:51:48,770
我用大写F，当我宣布变量

1259
00:51:48,770 --> 00:51:51,360
作为一个小写f，在第8行。

1260
00:51:51,360 --> 00:51:54,470
因此，我需要纠正在第11行我的资本，哪一个

1261
00:51:54,470 --> 00:51:56,820
刚才是一个大写F误。

1262
00:51:56,820 --> 00:51:57,610
这里怎么样？

1263
00:51:57,610 --> 00:51:59,980
这应该是小写的呢？

1264
00:51:59,980 --> 00:52:02,260
这是应该的，但是这是一个巧合。

1265
00:52:02,260 --> 00:52:05,070
，％f有没有做的变量。

1266
00:52:05,070 --> 00:52:07,980
因此，只要是超清晰，让我继续前进，

1267
00:52:07,980 --> 00:52:10,710
重命名，简单地说，“温度”。让我重新命名

1268
00:52:10,710 --> 00:52:15,050
此“温度”。让我不能重命名。

1269
00:52:15,050 --> 00:52:18,180
因为，再次，％f全球范围内的意思，“浮点值。”

1270
00:52:18,180 --> 00:52:19,950
有没有做我的变量。

1271
00:52:19,950 --> 00:52:23,080
但“温度”的地方只是一个小罗嗦，

1272
00:52:23,080 --> 00:52:25,370
所以，我要回到我的小写字母“f”。

1273
00:52:25,370 --> 00:52:27,890
>> 现在，让我继续我的窗前。

1274
00:52:27,890 --> 00:52:29,190
请F2C  - 

1275
00:52:29,190 --> 00:52:31,200
这是，再次，我的任意名称

1276
00:52:31,200 --> 00:52:32,590
给这个文件。

1277
00:52:32,590 --> 00:52:33,690
似乎已经编译。

1278
00:52:33,690 --> 00:52:35,080
让我跑F2C。

1279
00:52:35,080 --> 00:52:35,780
输入。

1280
00:52:35,780 --> 00:52:37,786
华氏温度 - 让我们做一个简单的一个。

1281
00:52:37,786 --> 00:52:39,370
32。

1282
00:52:39,370 --> 00:52:40,910
OK，纠正。

1283
00:52:40,910 --> 00:52:45,910
但是，如果我现在做的212沸腾 - 

1284
00:52:45,910 --> 00:52:46,630
该死的。

1285
00:52:46,630 --> 00:52:47,030
好的。

1286
00:52:47,030 --> 00:52:50,780
所以，这显然不是正确的，如果你的TF尝试

1287
00:52:50,780 --> 00:52:51,800
至少两个值。

1288
00:52:51,800 --> 00:52:53,340
那么，是什么问题呢？

1289
00:52:53,340 --> 00:52:55,970
好了，你已经把你的手指上是什么问题。

1290
00:52:55,970 --> 00:52:57,600
但是，为什么是这样呢？

1291
00:52:57,600 --> 00:53:00,630
在这里，当我在做数学5分9。

1292
00:53:00,630 --> 00:53:02,190
因此，从理论上讲，是完全正确的。

1293
00:53:02,190 --> 00:53:03,690
完全一致的公式。

1294
00:53:03,690 --> 00:53:05,940
但是，计算机只能做正是你

1295
00:53:05,940 --> 00:53:06,760
告诉他们做什么。

1296
00:53:06,760 --> 00:53:08,940
我们有效地在这里告诉计算机

1297
00:53:08,940 --> 00:53:12,320
除以整数5的整数9

1298
00:53:12,320 --> 00:53:13,670
给我的结果。

1299
00:53:13,670 --> 00:53:16,230
问题是，但是，如果你做除法数据

1300
00:53:16,230 --> 00:53:20,220
类型，输出是输入的相同的数据类型。

1301
00:53:20,220 --> 00:53:23,670
因此，如果两个输入是这两种类型为int，输出将

1302
00:53:23,670 --> 00:53:25,110
是一个int。

1303
00:53:25,110 --> 00:53:28,770
因此，5除以9点东西。

1304
00:53:28,770 --> 00:53:32,320
但是，什么是最接近的整数点东西吗？

1305
00:53:32,320 --> 00:53:33,630
因此，它实际上是0。

1306
00:53:33,630 --> 00:53:36,620
所以，当我们讨论星期一，一切都小数点后

1307
00:53:36,620 --> 00:53:37,940
点被截断。

1308
00:53:37,940 --> 00:53:39,495
它只是被丢弃。

1309
00:53:39,495 --> 00:53:42,760
所以这是一个完全错误的，因为我可能也只是

1310
00:53:42,760 --> 00:53:44,700
乘0这里的一切。

1311
00:53:44,700 --> 00:53:46,550
>> 现在，我可以在一对夫妇的方式来解决这个问题。

1312
00:53:46,550 --> 00:53:48,080
我能做到这一点。

1313
00:53:48,080 --> 00:53:50,490
5.0除以9.0。

1314
00:53:50,490 --> 00:53:52,110
从技术上讲，我什至不需要做的。

1315
00:53:52,110 --> 00:53:55,780
它足以使一个浮动的数字之一 - 

1316
00:53:55,780 --> 00:53:58,290
或双 - 通过把小数点这里。

1317
00:53:58,290 --> 00:54:01,740
因为发生的事情是，当你将整数

1318
00:54:01,740 --> 00:54:04,670
一个浮点数或双，计算机的实现

1319
00:54:04,670 --> 00:54:06,830
哦，其中之一是更加精确。

1320
00:54:06,830 --> 00:54:09,420
我宁可让你更精确的比侧

1321
00:54:09,420 --> 00:54:10,310
您所想。

1322
00:54:10,310 --> 00:54:12,700
因此，将转换的结果 - 

1323
00:54:12,700 --> 00:54:16,240
将一个浮点值，以及返回的结果。

1324
00:54:16,240 --> 00:54:17,330
因此，这将工作。

1325
00:54:17,330 --> 00:54:18,060
这将工作。

1326
00:54:18,060 --> 00:54:20,010
还有另外一个机制，我们将看到在

1327
00:54:20,010 --> 00:54:21,390
更详细的下周。

1328
00:54:21,390 --> 00:54:24,690
作为程序员，实际上，你可以告诉电脑

1329
00:54:24,690 --> 00:54:27,930
实际处理一个数据类型

1330
00:54:27,930 --> 00:54:29,260
虽然它是另一个。

1331
00:54:29,260 --> 00:54:30,990
>> 所以，我可以真正做到这一点。

1332
00:54:30,990 --> 00:54:35,280
在括号中，我可以这样说（浮动），开

1333
00:54:35,280 --> 00:54:36,350
括号，关闭括号。

1334
00:54:36,350 --> 00:54:39,050
这是所谓的“铸造”。同样，

1335
00:54:39,050 --> 00:54:39,940
在此下周。

1336
00:54:39,940 --> 00:54:42,280
但是，这仅仅是一个纲领性的方式告诉

1337
00:54:42,280 --> 00:54:45,910
电脑，是的，我知道9是一个整数或长。

1338
00:54:45,910 --> 00:54:47,700
我不知道这是一个浮点值。

1339
00:54:47,700 --> 00:54:49,420
但把它作为这样呢。

1340
00:54:49,420 --> 00:54:52,000
因此，投的数据类型转换成

1341
00:54:52,000 --> 00:54:53,310
从一个到另一个。

1342
00:54:53,310 --> 00:54:55,790
坦率地说，这只是一个小的丑陋，所以我会建议我们去

1343
00:54:55,790 --> 00:54:58,830
只是转换回原来的建议

1344
00:54:58,830 --> 00:55:00,770
这些东西手动浮点值。

1345
00:55:00,770 --> 00:55:02,890
因为现在只是超级清楚是怎么回事，和

1346
00:55:02,890 --> 00:55:04,280
它不是所有的分心。

1347
00:55:04,280 --> 00:55:06,710
>> 现在让我们回去到我的终端窗口中。

1348
00:55:06,710 --> 00:55:07,990
请F2C。

1349
00:55:07,990 --> 00:55:09,430
让我去，继续运行。

1350
00:55:09,430 --> 00:55:12,340
而且，顺便说一句，你感到厌倦，输入这些命令

1351
00:55:12,340 --> 00:55:14,910
一遍又一遍，认识到计算机，如Linux，

1352
00:55:14,910 --> 00:55:16,010
往往是很聪明的。

1353
00:55:16,010 --> 00:55:18,890
如果我撞了上去，我们可以通过我的整个历史

1354
00:55:18,890 --> 00:55:20,380
命令，向上和向下。

1355
00:55:20,380 --> 00:55:23,840
因此，在这种情况下，在这里，我可以去运行F2C。

1356
00:55:23,840 --> 00:55:25,830
我被大声训斥，因为我只是做了一秒钟前。

1357
00:55:25,830 --> 00:55:27,030
这已经是最新的。

1358
00:55:27,030 --> 00:55:30,720
所以，现在我可以再次运行F2C。

1359
00:55:30,720 --> 00:55:33,260
让我们尝试32华氏度。

1360
00:55:33,260 --> 00:55:36,720
现在，让我们尝试212华氏度。

1361
00:55:36,720 --> 00:55:37,250
>> 唷。

1362
00:55:37,250 --> 00:55:38,250
似乎工作。

1363
00:55:38,250 --> 00:55:41,760
现在，这是很好的，但是感觉有点任意的，

1364
00:55:41,760 --> 00:55:44,890
我显示小数点后六位数字。

1365
00:55:44,890 --> 00:55:45,070
对吗？

1366
00:55:45,070 --> 00:55:47,830
如果你人在电视上的天气，你的doofus的

1367
00:55:47,830 --> 00:55:49,150
如果你正在读的温度

1368
00:55:49,150 --> 00:55:50,070
这个精确度。

1369
00:55:50,070 --> 00:55:51,270
所以，让我们简化这。

1370
00:55:51,270 --> 00:55:53,880
因此，让我们其实在这里，我的printf。

1371
00:55:53,880 --> 00:55:55,490
是的，我想自由浮动。

1372
00:55:55,490 --> 00:55:57,570
不过，我想现在指定的精度。

1373
00:55:57,570 --> 00:55:59,070
我是一个小的简洁。

1374
00:55:59,070 --> 00:56:03,090
我说，给我一个点后的小数位。

1375
00:56:03,090 --> 00:56:07,590
因此，而不是说％F，我会说％.1 F。

1376
00:56:07,590 --> 00:56:09,760
而这只是给我一个位置

1377
00:56:09,760 --> 00:56:11,410
小数点后。

1378
00:56:11,410 --> 00:56:11,700
好的。

1379
00:56:11,700 --> 00:56:12,570
让我们再试一次。

1380
00:56:12,570 --> 00:56:15,590
让我重新编译后运行。

1381
00:56:15,590 --> 00:56:18,160
现在我输入32，我得到一个

1382
00:56:18,160 --> 00:56:19,310
更简洁的价值。

1383
00:56:19,310 --> 00:56:22,480
我可以输入，现在，212，和得到一个更简洁

1384
00:56:22,480 --> 00:56:23,260
价值。

1385
00:56:23,260 --> 00:56:25,190
还有其他的事情可以做，用printf。

1386
00:56:25,190 --> 00:56:27,950
实际上，你可以指定数目应该有多宽。

1387
00:56:27,950 --> 00:56:30,900
如果你想，有填充就可以了，所以你可以用鼠标右键调整或

1388
00:56:30,900 --> 00:56:32,360
左对齐所有的数字或

1389
00:56:32,360 --> 00:56:33,400
尝试为中心的东西。

1390
00:56:33,400 --> 00:56:35,340
因此，实现有小动作就做什么。

1391
00:56:35,340 --> 00:56:38,420
但他们只是归结为格式代码，

1392
00:56:38,420 --> 00:56:39,600
像我们有。

1393
00:56:39,600 --> 00:56:41,090
>> 因此，在这个问题的优先方面。

1394
00:56:41,090 --> 00:56:43,820
这是一个很无聊的表中去，通过有条不紊。

1395
00:56:43,820 --> 00:56:46,780
但认识到，纷纷拿出了作者的C

1396
00:56:46,780 --> 00:56:50,190
规则，指定运营商有更高的

1397
00:56:50,190 --> 00:56:53,680
优先，更多的结合力，比其他人。

1398
00:56:53,680 --> 00:56:55,890
因此而小学的时候，我们一般知道这是

1399
00:56:55,890 --> 00:56:58,930
乘法和除法，加法和减法，

1400
00:56:58,930 --> 00:56:59,950
然后一些其他的东西。

1401
00:56:59,950 --> 00:57:01,720
在编程的世界中，有一个更

1402
00:57:01,720 --> 00:57:03,360
更长的事情的清单。

1403
00:57:03,360 --> 00:57:05,150
这是不是现在值得记忆的东西。

1404
00:57:05,150 --> 00:57:07,310
用不了多久，你会得到驯化。

1405
00:57:07,310 --> 00:57:10,690
但就像小学的时候，括号一般解决

1406
00:57:10,690 --> 00:57:12,990
问题的优先级，超清晰的

1407
00:57:12,990 --> 00:57:15,620
计算机和人类一样的目的是什么。

1408
00:57:15,620 --> 00:57:17,770
因此，考虑这只是一个小的小抄。

1409
00:57:17,770 --> 00:57:21,690
但最重要的那些细节，我们不会去一段时间。

1410
00:57:21,690 --> 00:57:21,900
>> 好的。

1411
00:57:21,900 --> 00:57:24,120
现在，让我们建立和远离这些无聊的小

1412
00:57:24,120 --> 00:57:25,460
数学的例子。

1413
00:57:25,460 --> 00:57:27,500
仍然使用相同的基本面，但启动

1414
00:57:27,500 --> 00:57:29,960
表达自己有点像刮。

1415
00:57:29,960 --> 00:57:31,660
因此，在从头开始，我们这些布尔表达式。

1416
00:57:31,660 --> 00:57:34,890
而在英语中，布尔表达式是什么？

1417
00:57:34,890 --> 00:57:35,580
TRUE或FALSE。

1418
00:57:35,580 --> 00:57:38,300
这件事情的计算结果为true或false。

1419
00:57:38,300 --> 00:57:39,060
1或0。

1420
00:57:39,060 --> 00:57:39,870
“开”或“关”。

1421
00:57:39,870 --> 00:57:41,000
无论你怎么称呼它。

1422
00:57:41,000 --> 00:57:43,210
现在在刮，的拼图看起来像这样的。

1423
00:57:43,210 --> 00:57:45,850
这相结合，在底部有三个，

1424
00:57:45,850 --> 00:57:47,980
拼图。

1425
00:57:47,980 --> 00:57:48,980
一个结合 - 

1426
00:57:48,980 --> 00:57:51,710
的东西，有空白和空白。

1427
00:57:51,710 --> 00:57:53,970
然后它里面的布尔表达式。

1428
00:57:53,970 --> 00:57:56,460
所以，你可以窝的布尔表达式，以获得更多的

1429
00:57:56,460 --> 00:57:59,360
复杂的布尔表达式。

1430
00:57:59,360 --> 00:58:03,930
例如，如果它是星期六，它是很好的

1431
00:58:03,930 --> 00:58:06,180
天气，然后到外面去。

1432
00:58:06,180 --> 00:58:07,500
什么的任意那样。

1433
00:58:07,500 --> 00:58:10,090
所以，你可以加入了一个布尔表达式来

1434
00:58:10,090 --> 00:58:12,780
真值较大，其答案是基于

1435
00:58:12,780 --> 00:58:13,800
较小的。

1436
00:58:13,800 --> 00:58:15,770
>> 现在，在C，幸运的是，这个映射

1437
00:58:15,770 --> 00:58:16,720
其实很简单。

1438
00:58:16,720 --> 00:58:18,820
括号把事情说清楚在这里。

1439
00:58:18,820 --> 00:58:21,700
&&是什么意思“和”。所以，这就是

1440
00:58:21,700 --> 00:58:24,700
我们要转换这些块从白手起家到C.

1441
00:58:24,700 --> 00:58:27,590
的条件下，我们看到了从无到有，在左手

1442
00:58:27,590 --> 00:58:31,150
侧有，我可以将它们堆叠同样C.如果x小于

1443
00:58:31,150 --> 00:58:32,970
除y，然后做到这一点。

1444
00:58:32,970 --> 00:58:35,100
否则，如果x是大于y，那么这样做。

1445
00:58:35,100 --> 00:58:38,030
否则在逻辑上他们必须是平等的，所以说

1446
00:58:38,030 --> 00:58:39,140
他们是平等的。

1447
00:58:39,140 --> 00:58:41,210
所以，我们现在可以开始构建这些东西。

1448
00:58:41,210 --> 00:58:42,170
>> 因此，让我们做一个实例。

1449
00:58:42,170 --> 00:58:45,550
让我打开了一个文件，该文件了课程网站，

1450
00:58:45,550 --> 00:58:47,270
我写的提前。

1451
00:58:47,270 --> 00:58:50,540
这就是所谓的nonswitch.c。

1452
00:58:50,540 --> 00:58:52,270
我们会看到为什么在短短的时刻。

1453
00:58:52,270 --> 00:58:54,770
因此，在这个文件 -  nonswitch.c  - 

1454
00:58:54,770 --> 00:58:56,830
第一次认识到，有一大堆的

1455
00:58:56,830 --> 00:58:58,460
在上面的意见。

1456
00:58:58,460 --> 00:59:00,110
这只是解释的文件名，它是什么

1457
00:59:00,110 --> 00:59:01,260
，等等。

1458
00:59:01,260 --> 00:59:04,390
它显然说明了如何使用布尔AND-ING  - 

1459
00:59:04,390 --> 00:59:06,220
交接两个表达式。

1460
00:59:06,220 --> 00:59:07,670
>> 因此，让我们来看看这个程序是如何工作的。

1461
00:59:07,670 --> 00:59:10,840
我包括我的两个的文件，cs50.h和stdio.h中。

1462
00:59:10,840 --> 00:59:13,180
如果我向下滚动，现在的程序，它是一个小

1463
00:59:13,180 --> 00:59:15,730
比我们之前写的，但非常可读。

1464
00:59:15,730 --> 00:59:18,360
所以，我第一次打印的用户，第18行，

1465
00:59:18,360 --> 00:59:20,460
“给我一个1和10之间的整数。”所以

1466
00:59:20,460 --> 00:59:21,530
这是正确的。

1467
00:59:21,530 --> 00:59:23,410
现在，我得到的整数。

1468
00:59:23,410 --> 00:59:25,380
但认识到，调用getInt  - 很简单。

1469
00:59:25,380 --> 00:59:26,510
它只是将一个int。

1470
00:59:26,510 --> 00:59:28,830
这将确保，它并获得一个int，而不是一个

1471
00:59:28,830 --> 00:59:30,060
字符串或浮点数。

1472
00:59:30,060 --> 00:59:32,390
但它不会做任何形式的边界检查。

1473
00:59:32,390 --> 00:59:34,750
这不是要过滤的号码之间的

1474
00:59:34,750 --> 00:59:35,630
一定范围内。

1475
00:59:35,630 --> 00:59:37,730
因此，我们必须实施自己。

1476
00:59:37,730 --> 00:59:40,680
所以就像在刮，在那里我可以做一个结合的

1477
00:59:40,680 --> 00:59:43,560
两个表达式，我可以做的，在C如下。

1478
00:59:43,560 --> 00:59:48,660
如果n大于或等于1，和n是小于和

1479
00:59:48,660 --> 00:59:52,220
或等于3，我会很随意法令，

1480
00:59:52,220 --> 00:59:53,830
数是一个小数目。

1481
00:59:53,830 --> 00:59:56,730
只是为了一份声明。

1482
00:59:56,730 --> 01:00:00,210
否则，如果n为4和6，打印“你选择了一个中等

1483
01:00:00,210 --> 01:00:03,440
号“。否则，如果n为7和10之间，打印”你挑了

1484
01:00:03,440 --> 01:00:06,390
大的数字。“ELSE PRINT”你挑一个无效的号码。“

1485
01:00:06,390 --> 01:00:07,900
因为从逻辑上讲，后面如果我们

1486
01:00:07,900 --> 01:00:09,230
用尽了我们的范围。

1487
01:00:09,230 --> 01:00:12,400
>> 因此，认识到这一点倒不怎么写大于或

1488
01:00:12,400 --> 01:00:15,000
等于在上数学课。

1489
01:00:15,000 --> 01:00:15,160
对吗？

1490
01:00:15,160 --> 01:00:17,430
您通常像这样绘制，与线下。

1491
01:00:17,430 --> 01:00:19,250
但是，我的键盘上有没有这样的关键。

1492
01:00:19,250 --> 01:00:22,390
因此，在C的符号用于表示大于或

1493
01:00:22,390 --> 01:00:25,770
等于是两个字符，和符号为小于

1494
01:00:25,770 --> 01:00:29,100
或等于两个字符。

1495
01:00:29,100 --> 01:00:29,330
好的。

1496
01:00:29,330 --> 01:00:31,910
所以，如果我运行这个程序，你大概可以猜出这是什么

1497
01:00:31,910 --> 01:00:32,650
要做的事情。

1498
01:00:32,650 --> 01:00:36,180
如果我先走，使nonswitch，Enter键。

1499
01:00:36,180 --> 01:00:38,130
然后运行nonswitch。

1500
01:00:38,130 --> 01:00:39,530
给我1和10之间的一个数。

1501
01:00:39,530 --> 01:00:40,870
我要去给它11。

1502
01:00:40,870 --> 01:00:42,280
我拿起一个无效的数字。

1503
01:00:42,280 --> 01:00:44,090
让我试试3号。

1504
01:00:44,090 --> 01:00:45,990
我拿起一个小数目。

1505
01:00:45,990 --> 01:00:48,360
所以相当简单。

1506
01:00:48,360 --> 01:00:52,230
>> 如果我想改变这个程序的行为，

1507
01:00:52,230 --> 01:00:54,250
做的东西有点不同呢？

1508
01:00:54,250 --> 01:00:57,620
让我继续前进，说这句话。

1509
01:00:57,620 --> 01:00:59,480
让我摆脱这一切。

1510
01:00:59,480 --> 01:01:03,780
如果让我说（N = 42）。

1511
01:01:03,780 --> 01:01:08,730
然后我要继续前进，并说打印“你选

1512
01:01:08,730 --> 01:01:16,340
正确的答案。“不然，我们要继续前进，并说，

1513
01:01:16,340 --> 01:01:18,460
printf（“请你选

1514
01:01:18,460 --> 01:01:21,170
错误的答案。“）;好了。

1515
01:01:21,170 --> 01:01:22,040
只是因为。

1516
01:01:22,040 --> 01:01:23,890
>> 现在，有几点我们可以在这里提出。

1517
01:01:23,890 --> 01:01:26,570
一，我没有键入符号，你会认为这是

1518
01:01:26,570 --> 01:01:27,390
最合理的。

1519
01:01:27,390 --> 01:01:30,110
当我要检查平等，原来你不使用

1520
01:01:30,110 --> 01:01:30,910
等号。

1521
01:01:30,910 --> 01:01:34,000
您可以使用等于等号。

1522
01:01:34,000 --> 01:01:36,440
而原因可能是，只是凭直觉呢？

1523
01:01:36,440 --> 01:01:37,030
是啊。

1524
01:01:37,030 --> 01:01:39,330
观众：[听不清]

1525
01:01:39,330 --> 01:01:39,615
DAVID J.马兰：正确。

1526
01:01:39,615 --> 01:01:41,630
已经用于分配等号。

1527
01:01:41,630 --> 01:01:43,020
有人真的没有想到。

1528
01:01:43,020 --> 01:01:45,820
所以现在，当它涉及到平等的测试中，我们必须

1529
01:01:45,820 --> 01:01:48,850
更加明确，并说等于平等的。

1530
01:01:48,850 --> 01:01:52,110
一个很常见的错误是做到这一点。

1531
01:01:52,110 --> 01:01:54,800
而且，如果在办公时间或下周的某个时候或在

1532
01:01:54,800 --> 01:01:58,340
接下来的两个星期，你做这样的事情，然后

1533
01:01:58,340 --> 01:02:00,920
它奋斗了10年，20分钟，试图找出

1534
01:02:00,920 --> 01:02:03,330
该死的错误是什么，认识到，你是其中的一个

1535
01:02:03,330 --> 01:02:04,470
谁犯了这个错误的人。

1536
01:02:04,470 --> 01:02:06,030
因此，超级容易做。

1537
01:02:06,030 --> 01:02:08,240
但现在的目标是抵挡这样的错误。

1538
01:02:08,240 --> 01:02:11,840
这可以评估，因为这是真正的意思吗？

1539
01:02:11,840 --> 01:02:15,010
如果n得到42。

1540
01:02:15,010 --> 01:02:18,250
因此，动词的人使用，口头，以表达对

1541
01:02:18,250 --> 01:02:21,800
分配的概念是“得到”。因此，如果n得到42。

1542
01:02:21,800 --> 01:02:24,060
因此，这意味着到n分配42。

1543
01:02:24,060 --> 01:02:26,250
现在我有一个布尔表达式中括号，

1544
01:02:26,250 --> 01:02:30,230
此条件下的内部，它的数值是42。

1545
01:02:30,230 --> 01:02:30,390
对吗？

1546
01:02:30,390 --> 01:02:32,690
因为如果你评估它从内到外，总

1547
01:02:32,690 --> 01:02:34,100
答案，现在是42。

1548
01:02:34,100 --> 01:02:37,360
>> 所以，如果我问你的问题，“如果（42），”什么是

1549
01:02:37,360 --> 01:02:38,410
真正在说什么？

1550
01:02:38,410 --> 01:02:40,990
那么，布尔表达式只能是真或假。

1551
01:02:40,990 --> 01:02:42,010
1或0。

1552
01:02:42,010 --> 01:02:43,010
“开”或“关”。

1553
01:02:43,010 --> 01:02:45,240
因此，我们似乎在这里，有一个角落的情况下，让所有的

1554
01:02:45,240 --> 01:02:50,060
突然，我说：“如果（42）”。这不是一个布尔值。

1555
01:02:50,060 --> 01:02:54,500
因此，电脑做什么，但是，它基本上等同于

1556
01:02:54,500 --> 01:02:58,620
任何不为0的解释是正确的。

1557
01:02:58,620 --> 01:02:59,340
1。

1558
01:02:59,340 --> 01:02:59,690
在。

1559
01:02:59,690 --> 01:03:01,510
它们是等价的所有功能。

1560
01:03:01,510 --> 01:03:05,070
只有值为0，或关键字假的，因为我们会

1561
01:03:05,070 --> 01:03:07,860
最终看到的，实际上是错误的。

1562
01:03:07,860 --> 01:03:15,040
因此，“（42）”，实际上是真实的，因为它是非零。

1563
01:03:15,040 --> 01:03:18,620
因此，为了更精确地在这里，一个布尔值是真的不

1564
01:03:18,620 --> 01:03:20,680
的真或假，但在本

1565
01:03:20,680 --> 01:03:24,650
情况下，如果是0或非零。

1566
01:03:24,650 --> 01:03:26,330
因此，虚假或不假。

1567
01:03:26,330 --> 01:03:28,640
这使我们能够涵盖所有的

1568
01:03:28,640 --> 01:03:30,980
在括号表达式中的可能性。

1569
01:03:30,980 --> 01:03:33,840
因此，我们需要非常仔细，说 - 

1570
01:03:33,840 --> 01:03:35,620
（N = 42）。

1571
01:03:35,620 --> 01:03:39,100
很简单，因为我们需要指定测试的平等，

1572
01:03:39,100 --> 01:03:40,930
不分配的值。

1573
01:03:40,930 --> 01:03:42,830
>> 在这里值得一提的是什么？

1574
01:03:42,830 --> 01:03:46,030
这些花括号实际上是没有必要的。

1575
01:03:46,030 --> 01:03:48,650
我一直在做，只是为了在这里挑剔挑剔。

1576
01:03:48,650 --> 01:03:51,350
但是，当你有一个条件，只有一行

1577
01:03:51,350 --> 01:03:55,100
代码的方便，程序员并不需要使用

1578
01:03:55,100 --> 01:03:56,030
大括号。

1579
01:03:56,030 --> 01:03:59,370
总之，只是缩进，出于美观的考虑，

1580
01:03:59,370 --> 01:04:01,050
然后再编写一行代码。

1581
01:04:01,050 --> 01:04:04,160
只有当你想要写的两行代码 - 

1582
01:04:04,160 --> 01:04:08,230
例如，否则输出（“细则”）。如果你想做的事

1583
01:04:08,230 --> 01:04:09,540
的是，这被打破了。

1584
01:04:09,540 --> 01:04:11,700
您可以缩进想要的一切，但事实上，你有

1585
01:04:11,700 --> 01:04:14,600
输入的两行代码，而无需使用花括号

1586
01:04:14,600 --> 01:04:16,860
意味着这个程序将无法正常运行或可能

1587
01:04:16,860 --> 01:04:18,530
甚至没有正确编译。

1588
01:04:18,530 --> 01:04:21,040
所以现在，说实话，我认为最好的习惯是

1589
01:04:21,040 --> 01:04:24,460
使用大括号，你会发现，他们

1590
01:04:24,460 --> 01:04:25,750
超清晰是怎么回事。

1591
01:04:25,750 --> 01:04:29,410
>> 另外，顺便说一句 - 特别是如果你在那些谁使用

1592
01:04:29,410 --> 01:04:31,700
推荐的书籍或在线资源 - 

1593
01:04:31,700 --> 01:04:33,480
意识到有这个概念的风格

1594
01:04:33,480 --> 01:04:34,130
编程。

1595
01:04:34,130 --> 01:04:37,280
有些人喜欢把花括号

1596
01:04:37,280 --> 01:04:38,720
在这里上线。

1597
01:04:38,720 --> 01:04:41,520
有些人喜欢做可笑的事情，

1598
01:04:41,520 --> 01:04:43,830
我喜欢把它们放在这里。

1599
01:04:43,830 --> 01:04:45,140
有没有错误的答案，当涉及到

1600
01:04:45,140 --> 01:04:46,710
风格，但是这是错误的。

1601
01:04:46,710 --> 01:04:47,700
但是，有些人做到这一点。

1602
01:04:47,700 --> 01:04:49,160
[笑]

1603
01:04:49,160 --> 01:04:51,760
DAVID J.马兰：所以我现在提到这一点，仅仅是因为作为

1604
01:04:51,760 --> 01:04:54,400
你读的书籍或网上的事情，你会得到

1605
01:04:54,400 --> 01:04:55,990
从不同的老师，不同的消息

1606
01:04:55,990 --> 01:04:56,730
不同的作者。

1607
01:04:56,730 --> 01:04:58,640
而刚刚意识到这一点，在功能上，他们

1608
01:04:58,640 --> 01:05:00,740
一般等价的，但是一致的。

1609
01:05:00,740 --> 01:05:02,850
因此，在这种情况下，我们将标准化的花

1610
01:05:02,850 --> 01:05:04,650
括号这里排队的左边。

1611
01:05:04,650 --> 01:05:04,910
>> 好的。

1612
01:05:04,910 --> 01:05:07,040
因此，让我们继续前进，现在和运行它，看看会发生什么

1613
01:05:07,040 --> 01:05:07,780
这一计划。

1614
01:05:07,780 --> 01:05:09,970
请nonswitch。

1615
01:05:09,970 --> 01:05:11,040
然后运行nonswitch。

1616
01:05:11,040 --> 01:05:13,900
给我一个介于0和 - 所以这是不相关的

1617
01:05:13,900 --> 01:05:16,480
了，但我只是随意说42。

1618
01:05:16,480 --> 01:05:17,850
我选择了正确的答案。

1619
01:05:17,850 --> 01:05:20,430
现在好了，让我们借此在不同的方向。

1620
01:05:20,430 --> 01:05:22,070
原来，有一些其他语法

1621
01:05:22,070 --> 01:05:23,480
可以在程序中使用。

1622
01:05:23,480 --> 01:05:27,310
这里有一个新的语法，在功能上是相同的，

1623
01:05:27,310 --> 01:05:30,680
但只是介绍了另一种方式表达自己。

1624
01:05:30,680 --> 01:05:32,830
因此，这是什么所谓的“switch语句”。和

1625
01:05:32,830 --> 01:05:34,820
switch语句如下。

1626
01:05:34,820 --> 01:05:37,580
它需要在括号中的数值要

1627
01:05:37,580 --> 01:05:38,860
“开关”。

1628
01:05:38,860 --> 01:05:41,490
你想不同的表现，根据其值。

1629
01:05:41,490 --> 01:05:44,360
因此，这意味着开关n的值。

1630
01:05:44,360 --> 01:05:45,480
这是什么意思？

1631
01:05:45,480 --> 01:05:50,530
好了，如果n为1或2或3，继续前进，并打印出“您

1632
01:05:50,530 --> 01:05:52,680
挑一个大数目“，然后打破。

1633
01:05:52,680 --> 01:05:55,720
突破的原因是，C工作

1634
01:05:55,720 --> 01:05:59,790
尽快找到相匹配的情况下，它开始执行

1635
01:05:59,790 --> 01:06:01,610
它下面的所有的代码。

1636
01:06:01,610 --> 01:06:04,580
所以，如果我有，我在这里做的第27行，一行代码

1637
01:06:04,580 --> 01:06:05,360
被执行。

1638
01:06:05,360 --> 01:06:07,520
如果我在这里增加一条生产线，它就会被执行。

1639
01:06:07,520 --> 01:06:09,350
另一条线，它就会被执行。

1640
01:06:09,350 --> 01:06:12,460
该方案只停止执行下面的是什么

1641
01:06:12,460 --> 01:06:14,680
当我明确的适用case语句

1642
01:06:14,680 --> 01:06:17,210
说“分手”。所以是错误的。

1643
01:06:17,210 --> 01:06:19,220
右，在这种情况下，作为一个结果。

1644
01:06:19,220 --> 01:06:22,130
壳体4或5或6，同样地，将

1645
01:06:22,130 --> 01:06:23,160
打印出的信息。

1646
01:06:23,160 --> 01:06:24,410
在这种情况下，介质编号。

1647
01:06:24,410 --> 01:06:25,200
打破。

1648
01:06:25,200 --> 01:06:28,160
案例7，8，9，10，它会打印出“你选择了一个大

1649
01:06:28,160 --> 01:06:28,950
号“。突破。

1650
01:06:28,950 --> 01:06:31,290
再有就是名副其实的关键字被称为“默认”

1651
01:06:31,290 --> 01:06:34,090
这是有效像“别人”的建设。

1652
01:06:34,090 --> 01:06:36,010
因此，新的语法，但在智力上，

1653
01:06:36,010 --> 01:06:37,060
没有在所有新来的。

1654
01:06:37,060 --> 01:06:38,280
这就像擦除。

1655
01:06:38,280 --> 01:06:41,040
如果，否则的话，否则的话，代码块。

1656
01:06:41,040 --> 01:06:44,560
>> 所以这是这个程序的切换版本。

1657
01:06:44,560 --> 01:06:46,280
但是请注意，我们这样做，是这里的数字。

1658
01:06:46,280 --> 01:06:49,040
让我打开了第二个版本，只是为了显示

1659
01:06:49,040 --> 01:06:50,670
更具体一点的东西。

1660
01:06:50,670 --> 01:06:52,840
所以，在这里，我们有档次。

1661
01:06:52,840 --> 01:06:55,540
原来，你可以使用交换机，不只是整数，但在

1662
01:06:55,540 --> 01:06:56,340
字符。

1663
01:06:56,340 --> 01:06:58,930
不是所有的数据类型，但至少在字符。

1664
01:06:58,930 --> 01:07:02,670
所以在这里，我们可以做这样的事情，如果C的值，

1665
01:07:02,670 --> 01:07:06,230
使用者输入，在第19行中，通过使用GetChar函数，

1666
01:07:06,230 --> 01:07:09,410
是资本或小写字母a，让我们把它解释为一个档次，

1667
01:07:09,410 --> 01:07:11,340
并说，他们拿起一个优异的成绩。

1668
01:07:11,340 --> 01:07:14,690
顺着switch语句，我们还有其他的

1669
01:07:14,690 --> 01:07:17,950
为“B”和“C”，以及等等的情况下。

1670
01:07:17,950 --> 01:07:19,780
但是，现在让我们圆了另一件事情。

1671
01:07:19,780 --> 01:07:21,130
再次，种飞行

1672
01:07:21,130 --> 01:07:22,200
一些这些实施例。

1673
01:07:22,200 --> 01:07:26,990
但它确实使我们可以将它们应用，现在 - 

1674
01:07:26,990 --> 01:07:28,880
真的，只是他们现在翻译 - 

1675
01:07:28,880 --> 01:07:32,220
为C。

1676
01:07:32,220 --> 01:07:33,310
>> 所以，让我继续这样做。

1677
01:07:33,310 --> 01:07:34,830
我要打开一个新的文件。

1678
01:07:34,830 --> 01:07:39,430
我要去做包括<stdio.h>。

1679
01:07:39,430 --> 01:07:42,770
然后我要诠释的主要（无效）。

1680
01:07:42,770 --> 01:07:46,390
让我将此文件保存为一个loop.c.

1681
01:07:46,390 --> 01:07:48,280
只是作为一个例子。

1682
01:07:48,280 --> 01:07:49,910
我要继续前进并执行以下操作。

1683
01:07:49,910 --> 01:07:54,180
我想写一个非常繁琐的程序。

1684
01:07:54,180 --> 01:07:56,170
因此，10。

1685
01:07:56,170 --> 01:07:58,862
让我们这样做。

1686
01:07:58,862 --> 01:07:59,320
9。

1687
01:07:59,320 --> 01:08:00,360
好的。

1688
01:08:00,360 --> 01:08:02,120
只要你开始做这在编程中，你

1689
01:08:02,120 --> 01:08:03,490
可能做错了什么。

1690
01:08:03,490 --> 01:08:04,950
但我们会从这里开始了。

1691
01:08:04,950 --> 01:08:05,430
哎呀。

1692
01:08:05,430 --> 01:08:06,950
这实际上是错误的。

1693
01:08:06,950 --> 01:08:08,230
7。

1694
01:08:08,230 --> 01:08:09,440
6。

1695
01:08:09,440 --> 01:08:10,750
5。

1696
01:08:10,750 --> 01:08:11,200
4。

1697
01:08:11,200 --> 01:08:12,450
没有什么会发生什么，当我们到达0。

1698
01:08:12,450 --> 01:08:13,290
3。

1699
01:08:13,290 --> 01:08:14,590
2。

1700
01:08:14,590 --> 01:08:15,630
1。

1701
01:08:15,630 --> 01:08:16,020
好吧。

1702
01:08:16,020 --> 01:08:17,560
0。

1703
01:08:17,560 --> 01:08:18,689
删除。

1704
01:08:18,689 --> 01:08:19,029
>> 好的。

1705
01:08:19,029 --> 01:08:20,029
因此，返回0。

1706
01:08:20,029 --> 01:08:22,010
因此，这一计划显然会做什么，很

1707
01:08:22,010 --> 01:08:23,310
不厌其烦地说，这是要做的。

1708
01:08:23,310 --> 01:08:24,060
这将打印所有这些

1709
01:08:24,060 --> 01:08:25,290
值，由上到下。

1710
01:08:25,290 --> 01:08:27,140
因此，让我做循环。

1711
01:08:27,140 --> 01:08:28,640
然后 - 哎呦。

1712
01:08:28,640 --> 01:08:29,700
使环路。

1713
01:08:29,700 --> 01:08:31,479
我是在错误的目录。

1714
01:08:31,479 --> 01:08:33,300
现在让我跑环。

1715
01:08:33,300 --> 01:08:34,140
输入。

1716
01:08:34,140 --> 01:08:34,620
呜呼。

1717
01:08:34,620 --> 01:08:35,270
很不错的。

1718
01:08:35,270 --> 01:08:36,279
不错，长的节目。

1719
01:08:36,279 --> 01:08:38,109
>> 所有的权利，但现在让我们做到这一点。

1720
01:08:38,109 --> 01:08:40,810
就像在刮，当你开始使用一个循环

1721
01:08:40,810 --> 01:08:43,149
建设，而不是仅仅复制和粘贴所有的

1722
01:08:43,149 --> 01:08:45,580
拼图，让我介绍一下这件事情。

1723
01:08:45,580 --> 01:08:48,609
因此，在C，有不同的循环结构，

1724
01:08:48,609 --> 01:08:50,540
其中一个看起来是这样的。

1725
01:08:50,540 --> 01:08:55,069
一个“for”循环有三样东西，用两个分号分隔。

1726
01:08:55,069 --> 01:08:57,770
然后，身体内部的循环，所以说 - 

1727
01:08:57,770 --> 01:08:59,390
花括号里面的东西 - 

1728
01:08:59,390 --> 01:09:01,010
我们可以做一些事情一遍又一遍。

1729
01:09:01,010 --> 01:09:02,310
所以我就在屏幕上，这是

1730
01:09:02,310 --> 01:09:03,300
从字面上评论。

1731
01:09:03,300 --> 01:09:05,380
/ /在这里的意思来评论。

1732
01:09:05,380 --> 01:09:06,180
这是不是代码。

1733
01:09:06,180 --> 01:09:08,890
这仅仅是英文说明，对我来说，人的。

1734
01:09:08,890 --> 01:09:11,300
>> 所以，初始化，条件和更新。

1735
01:09:11,300 --> 01:09:12,770
那么，让我们来看看它是如何工作的。

1736
01:09:12,770 --> 01:09:15,520
这让我重写程序如下。

1737
01:09:15,520 --> 01:09:16,399
对于 - 

1738
01:09:16,399 --> 01:09:18,029
所以这里是我的循环 - 

1739
01:09:18,029 --> 01:09:19,439
INT I  - 

1740
01:09:19,439 --> 01:09:21,330
来了一个变量命名为“i”的 - 

1741
01:09:21,330 --> 01:09:23,140
得到初始化为10。

1742
01:09:23,140 --> 01:09:25,260
因此，有我的初始化。

1743
01:09:25,260 --> 01:09:29,450
我想要做的这个循环中，只要“我”是大于或等于

1744
01:09:29,450 --> 01:09:30,899
等于0。

1745
01:09:30,899 --> 01:09:32,880
这个循环的每一次迭代的，我想

1746
01:09:32,880 --> 01:09:34,979
做我 - 。

1747
01:09:34,979 --> 01:09:36,310
于是，我们看到了+ +（星期一）。

1748
01:09:36,310 --> 01:09:37,660
 - 是相反的。

1749
01:09:37,660 --> 01:09:39,410
它的值递减1。

1750
01:09:39,410 --> 01:09:43,319
这个循环里面，我希望做一些事情。

1751
01:09:43,319 --> 01:09:46,390
所以我要像printf说些什么。

1752
01:09:46,390 --> 01:09:48,939
我不想说10了，因为这显然是刚

1753
01:09:48,939 --> 01:09:50,000
要打印相同的值。

1754
01:09:50,000 --> 01:09:52,246
我想要什么，而不是打印，可能吗？

1755
01:09:52,246 --> 01:09:52,590
是啊。

1756
01:09:52,590 --> 01:09:55,270
因此，“我”。因此，％D，I。

1757
01:09:55,270 --> 01:09:57,340
>> 所以我要偷到一从早期的那些想法 - 

1758
01:09:57,340 --> 01:09:59,640
这种偷梁换柱的格式代码 - 

1759
01:09:59,640 --> 01:10:01,620
，然后在这里，在底部，我将返回0，只

1760
01:10:01,620 --> 01:10:02,710
良好的措施。

1761
01:10:02,710 --> 01:10:04,740
但现在，我有一个更简洁的方案。

1762
01:10:04,740 --> 01:10:07,490
这是只有几行字，而不是一些10或11号线。

1763
01:10:07,490 --> 01:10:09,440
让我去我的提示下来。

1764
01:10:09,440 --> 01:10:10,630
翻拍循环。

1765
01:10:10,630 --> 01:10:12,140
重新运行循环。

1766
01:10:12,140 --> 01:10:13,570
和它似乎是相同的。

1767
01:10:13,570 --> 01:10:15,550
现在，该方案没有更有趣。

1768
01:10:15,550 --> 01:10:17,180
但现在我可以键入这样的事情。

1769
01:10:17,180 --> 01:10:18,970
我可以更改为100。

1770
01:10:18,970 --> 01:10:21,400
然后我就可以重新编译我的程序。

1771
01:10:21,400 --> 01:10:23,360
然后我就可以重新运行我的程序。

1772
01:10:23,360 --> 01:10:26,390
而现在“超高速今天的计算机上。

1773
01:10:26,390 --> 01:10:27,820
然而，有我有 - 

1774
01:10:27,820 --> 01:10:29,620
而实际上，我的屏幕缓存不

1775
01:10:29,620 --> 01:10:30,890
远不止这些。

1776
01:10:30,890 --> 01:10:31,680
我们走吧。

1777
01:10:31,680 --> 01:10:34,090
因此，我们有所有100个。

1778
01:10:34,090 --> 01:10:35,880
但它很容易在这里犯错。

1779
01:10:35,880 --> 01:10:37,920
这是怎么回事，是预期的行为，如果我

1780
01:10:37,920 --> 01:10:41,150
不小心这样做呢？

1781
01:10:41,150 --> 01:10:42,550
因此，它感觉就像是无限的。

1782
01:10:42,550 --> 01:10:44,670
因此，让我们来看看，如果在计算机的行为。

1783
01:10:44,670 --> 01:10:47,020
>> 因此，让我继续前进，使循环。

1784
01:10:47,020 --> 01:10:48,355
让我跑环。

1785
01:10:53,590 --> 01:10:55,210
因此，让我们回来，在短短的时刻。

1786
01:10:55,210 --> 01:10:56,720
我们将让这个运行。

1787
01:10:56,720 --> 01:10:59,520
因为，我们应该算什么，微创？

1788
01:10:59,520 --> 01:11:02,200
大概至少2个十亿，如果我们有多少位，和

1789
01:11:02,200 --> 01:11:03,660
我们使用的是正面的价值观。

1790
01:11:03,660 --> 01:11:04,890
所以，让我们跳回到这里。

1791
01:11:04,890 --> 01:11:07,810
除了这些类型的循环，我们有什么时，被称为

1792
01:11:07,810 --> 01:11:09,430
循环。所以，就像在刮，你永远

1793
01:11:09,430 --> 01:11:11,240
块，你不得不重复块。

1794
01:11:11,240 --> 01:11:13,270
同样，在C中，你有其他的方式

1795
01:11:13,270 --> 01:11:14,260
表达自己。

1796
01:11:14,260 --> 01:11:17,110
所以，你有这个概念的一个while循环，可让您

1797
01:11:17,110 --> 01:11:18,860
表达自己的一点点不同。

1798
01:11:18,860 --> 01:11:21,490
然后你有一些所谓的do-whil​​e循环，

1799
01:11:21,490 --> 01:11:24,200
经营略有不同。

1800
01:11:24,200 --> 01:11:25,320
而我们除了耻笑这些随着时间的推移。

1801
01:11:25,320 --> 01:11:28,630
>> 但是，让我们来看看在这最后一个在这里。

1802
01:11:28,630 --> 01:11:30,160
如果我们去 - 

1803
01:11:30,160 --> 01:11:31,466
仍在运行。

1804
01:11:31,466 --> 01:11:32,770
这是相当无限的。

1805
01:11:32,770 --> 01:11:36,870
因此，让我进入正面，并显示如何，我们实际上可以

1806
01:11:36,870 --> 01:11:39,410
一点点更有效地治理用户输入。

1807
01:11:39,410 --> 01:11:40,910
这是一个很短的程序。

1808
01:11:40,910 --> 01:11:43,730
在这里，我们有，在主，廉政n声明。

1809
01:11:43,730 --> 01:11:46,570
所以给我一个变量n。现在，我从字面上说

1810
01:11:46,570 --> 01:11:48,340
“做的。”然后，我有左大

1811
01:11:48,340 --> 01:11:49,630
括号，靠近大括号。

1812
01:11:49,630 --> 01:11:52,000
然后请注意，右后，它说，当n

1813
01:11:52,000 --> 01:11:53,790
是小于1。

1814
01:11:53,790 --> 01:11:55,300
所以注意到，这些线 - 

1815
01:11:55,300 --> 01:11:56,740
19至24  - 

1816
01:11:56,740 --> 01:11:59,450
共同组成一个do-whil​​e循环。

1817
01:11:59,450 --> 01:12:01,280
再次，新的语法，而不是一个新的想法。

1818
01:12:01,280 --> 01:12:03,740
它只是另一种方式的循环，语法。

1819
01:12:03,740 --> 01:12:04,890
那么，这是什么做的？

1820
01:12:04,890 --> 01:12:08,000
而n是小于1，执行下列操作。

1821
01:12:08,000 --> 01:12:09,080
那么，我该怎么办？

1822
01:12:09,080 --> 01:12:11,390
我要求你给我一个正整数。

1823
01:12:11,390 --> 01:12:14,110
然后我尝试从用户得到一个整数。

1824
01:12:14,110 --> 01:12:16,740
但在这里的操作顺序，因为

1825
01:12:16,740 --> 01:12:21,850
而条件是在这里，我要检查，是n

1826
01:12:21,850 --> 01:12:23,100
小于1？

1827
01:12:23,100 --> 01:12:24,600
因此，假设用户 - 

1828
01:12:24,600 --> 01:12:26,450
在这样的要求后 - 

1829
01:12:26,450 --> 01:12:29,190
类型中的值0。

1830
01:12:29,190 --> 01:12:34,510
这种情况是怎么回事，是真还是假？

1831
01:12:34,510 --> 01:12:35,820
那么，它是真实的。

1832
01:12:35,820 --> 01:12:38,700
因为n是0，和0小于1。

1833
01:12:38,700 --> 01:12:40,140
那么，这意味着什么呢？

1834
01:12:40,140 --> 01:12:41,160
再次这样做。

1835
01:12:41,160 --> 01:12:41,990
再次这样做。

1836
01:12:41,990 --> 01:12:42,640
再次这样做。

1837
01:12:42,640 --> 01:12:46,080
只有当该条件的计算结果为false。

1838
01:12:46,080 --> 01:12:47,510
如果我输入42。

1839
01:12:47,510 --> 01:12:49,690
好了没有，42是不小于1。

1840
01:12:49,690 --> 01:12:52,320
因此，这个循环被执行。

1841
01:12:52,320 --> 01:12:54,650
因此，在这一点上，该程序会说，感谢

1842
01:12:54,650 --> 01:12:57,530
42，在这种情况下。

1843
01:12:57,530 --> 01:13:00,320
既然你有这样的方式表达自己 - 

1844
01:13:00,320 --> 01:13:02,360
我们不应该等待完成。

1845
01:13:02,360 --> 01:13:03,620
这将需要一些时间。

1846
01:13:03,620 --> 01:13:04,990
要继续下一次，也许吧。

1847
01:13:04,990 --> 01:13:08,050
>> 但现在，你有能力，希望了解一个

1848
01:13:08,050 --> 01:13:09,060
位的怪胎幽默。

1849
01:13:09,060 --> 01:13:11,560
抱歉。

1850
01:13:11,560 --> 01:13:13,620
在计算机科学的幽默，这是不是代表

1851
01:13:13,620 --> 01:13:14,870
世界，但它很可爱。

1852
01:13:21,020 --> 01:13:23,890
[笑]让我们结束关于这一点。

1853
01:13:23,890 --> 01:13:25,750
我们星期一见。

1854
01:13:25,750 --> 01:13:31,629
[掌声]