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

2
00:00:10,940 --> 00:00:13,060
>> 大卫·马兰：所有
没错，所以这是CS50。

3
00:00:13,060 --> 00:00:15,040
而这显然是一个星期五。

4
00:00:15,040 --> 00:00:16,850
而这是一个星期的末端。

5
00:00:16,850 --> 00:00:21,020
所以，你可能还记得，我们不放过​​，
最后一次，有各种各样的悬念。

6
00:00:21,020 --> 00:00:25,020
我们借以揭露这个谎言，没有
不管你被教导成长

7
00:00:25,020 --> 00:00:31,610
向上，1除以10不是在
事实上，0.1或0.100或0.10000。

8
00:00:31,610 --> 00:00:35,270
事实上，如果我们编译这个
计划，因为我们没有昨天，有，

9
00:00:35,270 --> 00:00:39,770
使不精确性，然后
做点，斜线，不精确，

10
00:00:39,770 --> 00:00:43,600
我们了解到，这是什么
1除以10实际上是。

11
00:00:43,600 --> 00:00:46,140
所以这不是真的相当的情况下。

12
00:00:46,140 --> 00:00:49,014
但是，这确实暗示了一些
电脑的基本限制。

13
00:00:49,014 --> 00:00:50,930
事实上，中
我们将要做的事情

14
00:00:50,930 --> 00:00:55,130
今天就来看看为什么这有
事情发生了，有什么意义这有，

15
00:00:55,130 --> 00:00:58,430
人类如何失败
掌握这一些很

16
00:00:58,430 --> 00:01:00,410
严重situations--
在其结果

17
00:01:00,410 --> 00:01:03,141
已经相当惨烈
和expensive--也

18
00:01:03,141 --> 00:01:04,849
看看我们如何
实际上可以捍卫

19
00:01:04,849 --> 00:01:06,530
针对这些种类的限制。

20
00:01:06,530 --> 00:01:10,940
所以直觉，也许，
为什么是1除以10，

21
00:01:10,940 --> 00:01:15,480
根据我的电脑
这里，不只是的1/10，0.10？

22
00:01:15,480 --> 00:01:15,980
是啊。

23
00:01:15,980 --> 00:01:16,530
你有什么感想？

24
00:01:16,530 --> 00:01:17,860
>> 观众：基数是不同的？

25
00:01:17,860 --> 00:01:18,550
>> 大卫·马兰：该是什么？

26
00:01:18,550 --> 00:01:19,730
呵呵，基数是不同的？

27
00:01:19,730 --> 00:01:20,720
因此，不完全是。

28
00:01:20,720 --> 00:01:23,200
它实际上更多
基本的硬件。

29
00:01:23,200 --> 00:01:23,980
其他的想法？

30
00:01:23,980 --> 00:01:24,584
是啊。

31
00:01:24,584 --> 00:01:26,750
观众：他们
表示数字不同？

32
00:01:26,750 --> 00:01:27,880
大卫·马兰：所以they--权。

33
00:01:27,880 --> 00:01:29,338
他们代表的数字不同。

34
00:01:29,338 --> 00:01:30,700
不准确，很明显。

35
00:01:30,700 --> 00:01:33,190
这样is--好，
不同于什么？

36
00:01:33,190 --> 00:01:34,490
或者从谁？

37
00:01:34,490 --> 00:01:35,050
从我们呢？

38
00:01:35,050 --> 00:01:35,966
观众：是啊。

39
00:01:35,966 --> 00:01:38,930
它们不使用小数
系统[听不清]。

40
00:01:38,930 --> 00:01:39,680
大卫·马兰：OK。

41
00:01:39,680 --> 00:01:41,560
因此，从某种意义上说，他们不
使用十进制系统。

42
00:01:41,560 --> 00:01:43,720
在系统底层，
一切，的确，二进制，

43
00:01:43,720 --> 00:01:45,510
这就是相关的，其实。

44
00:01:45,510 --> 00:01:48,135
但是，它甚至更简单
解释比。

45
00:01:48,135 --> 00:01:48,635
是啊。

46
00:01:48,635 --> 00:01:49,970
>> 观众：他们
只有这么多的位。

47
00:01:49,970 --> 00:01:52,370
他们最多只能存储一定
某种程度上，像小数。

48
00:01:52,370 --> 00:01:52,780
>> 大卫·马兰：是的。

49
00:01:52,780 --> 00:01:54,420
这是什么真正得到它。

50
00:01:54,420 --> 00:01:57,180
事实证明，计算机
通常情况下，将永远只有

51
00:01:57,180 --> 00:01:59,690
使用的信息的有限数量
代表什么。

52
00:01:59,690 --> 00:01:59,870
对？

53
00:01:59,870 --> 00:02:02,110
毕竟，我们只有一个固定的
量的硬盘空间。

54
00:02:02,110 --> 00:02:04,210
我们只有一个固定量
的RAM，或计算机的内存。

55
00:02:04,210 --> 00:02:06,251
如果你只有一个
固定金额的东西，

56
00:02:06,251 --> 00:02:09,611
当然你不能真正计数
到无穷大或任何你想要的数字。

57
00:02:09,611 --> 00:02:11,610
你有种，有
挑选什么范围

58
00:02:11,610 --> 00:02:13,220
值你要支持。

59
00:02:13,220 --> 00:02:18,100
>> 因此，例如，一两个星期
以前，当我们谈到ASCII，

60
00:02:18,100 --> 00:02:21,610
我们谈了8位，
或字节，可以这么说，

61
00:02:21,610 --> 00:02:26,360
最大数我们可以
有8位表示是什么呢？

62
00:02:26,360 --> 00:02:28,350
255。

63
00:02:28,350 --> 00:02:31,850
我们可以表示256个总价值
但如果我们把其中的一个

64
00:02:31,850 --> 00:02:34,190
在0--好了，但如果我们
花其中的一个0，

65
00:02:34,190 --> 00:02:36,830
那么最大的数
是，当然，255。

66
00:02:36,830 --> 00:02:39,410
>> 所以，事实证明，这是
的情况下也一样，在这种情况下。

67
00:02:39,410 --> 00:02:42,350
我们开始谈，最后一次，
有关浮点数字，

68
00:02:42,350 --> 00:02:44,640
来自整数不同，在
他们有一个小数点

69
00:02:44,640 --> 00:02:47,056
并希望一些数字
在这之后，但是它们太。

70
00:02:47,056 --> 00:02:51,730
一台计算机通常只打算
使用32位，也许64位

71
00:02:51,730 --> 00:02:53,497
来表示一个浮点值。

72
00:02:53,497 --> 00:02:56,080
因此，即使我们已经长大了
学习数学和了解

73
00:02:56,080 --> 00:02:58,750
你绝对可以有
数的无限数量

74
00:02:58,750 --> 00:03:01,650
小数点后不
如果你有有限的内存。

75
00:03:01,650 --> 00:03:03,930
你有种，有圆形，
或者挑选哪些

76
00:03:03,930 --> 00:03:05,346
你会数来表示。

77
00:03:05,346 --> 00:03:08,710
所以，你能想到的，从某种意义上说，
这是计算机的最接近

78
00:03:08,710 --> 00:03:14,050
近似​​的值的1/10
它可以得到，只有32左右位。

79
00:03:14,050 --> 00:03:15,300
而且它不只是1/10。

80
00:03:15,300 --> 00:03:19,820
>> 举例来说，如果我改变这
1/3，我们认为这是更简单。

81
00:03:19,820 --> 00:03:21,300
因此，1除以3。

82
00:03:21,300 --> 00:03:22,355
让我保存文件。

83
00:03:22,355 --> 00:03:24,680
让我继续前进，重新编译它。

84
00:03:24,680 --> 00:03:25,820
让我重新运行它。

85
00:03:25,820 --> 00:03:30,000
在这里，显然，三分之一没有0.3
然后3的无限数量

86
00:03:30,000 --> 00:03:30,770
其后。

87
00:03:30,770 --> 00:03:32,540
你有这样的不精确性在最后。

88
00:03:32,540 --> 00:03:35,544
所以，我们人类是正确的，什么
你了解，其实，正确的，

89
00:03:35,544 --> 00:03:37,460
但是我们撞了
针对一些限制。

90
00:03:37,460 --> 00:03:39,420
>> 而我的想法
我们今天会做，是开始

91
00:03:39,420 --> 00:03:42,190
通过看，坦率地说，在
这种悲惨的后果

92
00:03:42,190 --> 00:03:45,490
有时，人类的时候
并不完全实现

93
00:03:45,490 --> 00:03:48,460
针对这一现实，这些限制。

94
00:03:48,460 --> 00:03:52,360
而且我们会看到一系列的小插图
从历史频道的需要

95
00:03:52,360 --> 00:03:53,950
一起来看看如何事情已经出了问题。

96
00:03:53,950 --> 00:03:56,340
这是约8分钟之久，
我们将在这之后回来

97
00:03:56,340 --> 00:03:59,439
看一看在完全相同
还有什么可能出错。

98
00:03:59,439 --> 00:04:00,605
如果我们能昏暗的lights--

99
00:04:00,605 --> 00:04:02,350
>> [视频回放]

100
00:04:02,350 --> 00:04:06,310
>> -Computers，我们都逐渐接受
经常令人沮丧的问题，

101
00:04:06,310 --> 00:04:07,750
和他们一起去。

102
00:04:07,750 --> 00:04:11,370
错误，病毒，和软件
故障都是小的价格

103
00:04:11,370 --> 00:04:13,230
支付的便利。

104
00:04:13,230 --> 00:04:17,519
但是，在高科技和高速
军事和航天计划的应用，

105
00:04:17,519 --> 00:04:22,130
可以最小的问题
被放大成灾难。

106
00:04:22,130 --> 00:04:27,750
1996年6月4日，科学家准备
启动一个无人阿丽亚娜5型火箭。

107
00:04:27,750 --> 00:04:29,890
它携带的科学
卫星设计

108
00:04:29,890 --> 00:04:33,030
建立精确如何
地球的磁场相互作用

109
00:04:33,030 --> 00:04:35,600
与太阳风。

110
00:04:35,600 --> 00:04:37,930
火箭是专为
欧洲航天局

111
00:04:37,930 --> 00:04:41,620
并从其工厂升空
在法属圭亚那的海岸。

112
00:04:41,620 --> 00:04:44,924
>>  - 和大约30秒后进入
飞行中，他们首先

113
00:04:44,924 --> 00:04:46,340
发现了一些打算错了。

114
00:04:46,340 --> 00:04:49,280
使喷嘴被旋转
在某种程度上，他们真的不应该。

115
00:04:49,280 --> 00:04:53,042
约40秒后进入飞行，
明确了车辆遇到了麻烦，

116
00:04:53,042 --> 00:04:55,250
而当他们提出的
决定摧毁它。

117
00:04:55,250 --> 00:04:58,970
随着一系列安全主任
巨大的勇气按下按钮，

118
00:04:58,970 --> 00:05:03,940
炸毁了火箭之前，它可能
成为危害公众安全。

119
00:05:03,940 --> 00:05:06,600
>>  - 这是处女
阿丽亚娜5的航程，

120
00:05:06,600 --> 00:05:09,270
它破坏了
地方，因为一个缺陷

121
00:05:09,270 --> 00:05:10,992
嵌在火箭的软件。

122
00:05:10,992 --> 00:05:12,700
在-The问题
阿丽亚娜是，有

123
00:05:12,700 --> 00:05:15,370
是一个数字，需要
64位表示，

124
00:05:15,370 --> 00:05:18,150
他想转换
它以一个16位的数。

125
00:05:18,150 --> 00:05:21,160
他们假定数
从来没有将是非常大的，

126
00:05:21,160 --> 00:05:25,020
大多数的这些数字中
64位数字是0。

127
00:05:25,020 --> 00:05:26,310
但他们错了。

128
00:05:26,310 --> 00:05:28,680
>> 一-The无力
软件程序接受

129
00:05:28,680 --> 00:05:32,820
所产生的那种数
另一种是在失败的根源。

130
00:05:32,820 --> 00:05:37,190
软件开发已经成为一个
的新技术非常昂贵的部分。

131
00:05:37,190 --> 00:05:40,760
阿丽亚娜-4火箭一直非常
成功的，那么多的软件

132
00:05:40,760 --> 00:05:43,990
创造这也是
用在阿丽亚娜5。

133
00:05:43,990 --> 00:05:49,750
>> -The基本的问题是，阿丽亚娜
5增快，加速快。

134
00:05:49,750 --> 00:05:53,000
而且软件早已不是
占了这一点。

135
00:05:53,000 --> 00:05:56,330
>> 火箭-The破坏
是一个巨大的金融灾难，

136
00:05:56,330 --> 00:05:59,670
全因一分钟，软件错误。

137
00:05:59,670 --> 00:06:01,990
但是，这是不是第一次
实时数据转换问题

138
00:06:01,990 --> 00:06:05,310
一直困扰现代火箭技术。

139
00:06:05,310 --> 00:06:08,300
>> -in 1991，在开始
第一次海湾战争中，

140
00:06:08,300 --> 00:06:10,650
爱国者导弹
经历了类似的一种

141
00:06:10,650 --> 00:06:12,650
数转换的问题。

142
00:06:12,650 --> 00:06:15,620
其结果是，28人，
28美国士兵

143
00:06:15,620 --> 00:06:18,440
被打死，约
100人受伤，

144
00:06:18,440 --> 00:06:21,900
当爱国者，这是应该
以防止传入的飞毛腿导弹，

145
00:06:21,900 --> 00:06:24,630
没有发射导弹。

146
00:06:24,630 --> 00:06:29,440
>>  - 当伊拉克入侵科威特和美国
在1991年年初推出沙漠风暴，

147
00:06:29,440 --> 00:06:33,800
爱国者导弹部署
保护沙特阿拉伯和以色列

148
00:06:33,800 --> 00:06:37,000
从伊拉克飞毛腿导弹攻击。

149
00:06:37,000 --> 00:06:40,610
爱国者是美国，中程
表面对空气系统

150
00:06:40,610 --> 00:06:43,010
由雷神公司制造。

151
00:06:43,010 --> 00:06:49,080
>> 爱国者拦截-The大小，
本身就是约，约20英尺长。

152
00:06:49,080 --> 00:06:51,250
而且它的重量约2000磅。

153
00:06:51,250 --> 00:06:55,195
同时还可以进行about--的弹头
我认为这是约150磅。

154
00:06:55,195 --> 00:06:59,500
和弹头本身，
是一种高爆炸药，

155
00:06:59,500 --> 00:07:02,570
它有它周围的碎片。

156
00:07:02,570 --> 00:07:06,890
弹头的外壳是
设计像鹿弹。

157
00:07:06,890 --> 00:07:09,130
>> -The导弹
进行，4％的集装箱，

158
00:07:09,130 --> 00:07:12,080
并通过半拖车被运送。

159
00:07:12,080 --> 00:07:19,100
>> -The爱国者反导弹系统
追溯到现在至少需要20年。

160
00:07:19,100 --> 00:07:22,320
它最初的设计
作为防空导弹

161
00:07:22,320 --> 00:07:24,180
击落敌人的飞机。

162
00:07:24,180 --> 00:07:27,860
在第一次海湾战争，
当战争来了，

163
00:07:27,860 --> 00:07:32,745
陆军希望用它来
击落飞毛腿导弹，而不是飞机。

164
00:07:32,745 --> 00:07:36,150
伊拉克队还是没有
这么多的问题，

165
00:07:36,150 --> 00:07:39,110
但陆军担心飞毛腿导弹。

166
00:07:39,110 --> 00:07:42,340
因此，他们试图
升级爱国者。

167
00:07:42,340 --> 00:07:44,760
>> -Intercepting敌人
导弹行驶在马赫5

168
00:07:44,760 --> 00:07:47,250
将要进行足够的挑战。

169
00:07:47,250 --> 00:07:50,000
但是爱国者的时候
被冲进服务，

170
00:07:50,000 --> 00:07:54,030
陆军不知道的
，使得伊拉克修改

171
00:07:54,030 --> 00:07:56,840
他们的飞毛腿导弹几乎是不可能的打击。

172
00:07:56,840 --> 00:08:01,020
>>  - 什么事，是飞毛腿的
要来的，是不稳定的，

173
00:08:01,020 --> 00:08:02,310
他们摇晃。

174
00:08:02,310 --> 00:08:05,140
这样做的原因，
是伊拉克人，为了

175
00:08:05,140 --> 00:08:09,450
让600公里出
300公里的射程导弹，

176
00:08:09,450 --> 00:08:12,930
把重出前弹头
并提出弹头更轻。

177
00:08:12,930 --> 00:08:17,710
所以，现在，爱国者的苦思
在飞毛腿，并且大多数时候，

178
00:08:17,710 --> 00:08:21,700
绝大多数的
时间，它只是由飞毛腿飞。

179
00:08:21,700 --> 00:08:25,700
>>  - 一旦爱国者系统运营商
实现了爱国者偏离目标，

180
00:08:25,700 --> 00:08:29,790
他们引爆了爱国者弹头，
为了避免可能的人员伤亡，如果它

181
00:08:29,790 --> 00:08:32,380
被允许倒在地上。

182
00:08:32,380 --> 00:08:36,340
>>  - 那是大多数人所看到的，
那些大火球在天空中，

183
00:08:36,340 --> 00:08:41,289
和误解为
飞毛腿弹头的拦截。

184
00:08:41,289 --> 00:08:43,590
虽然在夜间
天空，爱国者亮相

185
00:08:43,590 --> 00:08:47,020
要成功地
摧毁飞毛腿导弹，在达兰，

186
00:08:47,020 --> 00:08:49,730
有可能是没有错
关于它的性能。

187
00:08:49,730 --> 00:08:53,990
在那里，爱国者的雷达系统
失去了进入的飞毛腿的轨道，

188
00:08:53,990 --> 00:08:56,650
永不推出，
由于软件缺陷。

189
00:08:56,650 --> 00:08:59,650

190
00:08:59,650 --> 00:09:04,100
这是谁首先发现了以色列人
该系统不再是上，

191
00:09:04,100 --> 00:09:07,510
越大时间差异
成为，由于一个时钟的嵌入式

192
00:09:07,510 --> 00:09:09,490
在系统的计算机。

193
00:09:09,490 --> 00:09:12,670
>>  - 关于前2周
悲剧发生在宰赫兰，

194
00:09:12,670 --> 00:09:15,010
以色列人报
国防部，

195
00:09:15,010 --> 00:09:17,940
该系统是浪费时间，
该后约8小时的运行，

196
00:09:17,940 --> 00:09:21,410
他们注意到，该系统
变得明显不太准确。

197
00:09:21,410 --> 00:09:25,290
国防部回应
告诉所有的爱国者电池

198
00:09:25,290 --> 00:09:28,070
不离开系统
上很长一段时间。

199
00:09:28,070 --> 00:09:29,960
他们从来不说什么很长一段时间了。

200
00:09:29,960 --> 00:09:30,460
8小时？

201
00:09:30,460 --> 00:09:30,960
10小时？

202
00:09:30,960 --> 00:09:31,870
千小时？

203
00:09:31,870 --> 00:09:33,734
没有人知道。

204
00:09:33,734 --> 00:09:35,650
-The爱国者电池
驻扎在军营

205
00:09:35,650 --> 00:09:40,410
在宰赫兰的，其有缺陷的内部
时钟，已经在超过100小时

206
00:09:40,410 --> 00:09:43,041
2月25日的晚上。

207
00:09:43,041 --> 00:09:47,416
>>  - 它跟踪时间精度
约一秒的1/10。

208
00:09:47,416 --> 00:09:49,290
现在1/10秒是
一个有趣的数字

209
00:09:49,290 --> 00:09:52,700
因为它不能
按二进制，没错。

210
00:09:52,700 --> 00:09:54,820
这意味着，它不能
表示，准确地说，

211
00:09:54,820 --> 00:09:57,420
在任何现代数字计算机。

212
00:09:57,420 --> 00:10:01,460
很难相信，但
使用这个作为一个例子。

213
00:10:01,460 --> 00:10:03,520
让我们来数的1/3。

214
00:10:03,520 --> 00:10:07,110
三分之一不能表示
十进制，没错。

215
00:10:07,110 --> 00:10:11,490
1/3是0.333持续了无穷大。

216
00:10:11,490 --> 00:10:15,486
有没有办法做到这一点，有
绝对精度，十进制。

217
00:10:15,486 --> 00:10:18,360
这正是相同种类的
问题发生在爱国者。

218
00:10:18,360 --> 00:10:22,510
该系统运行更长的
更糟糕的时间误差成了。

219
00:10:22,510 --> 00:10:28,420
>> -After运行100小时，误差
在时间只有一秒钟的约1/3。

220
00:10:28,420 --> 00:10:31,830
但是，在针对一个方面
导弹5马赫旅行，

221
00:10:31,830 --> 00:10:35,890
它导致了跟踪
对600多万米的错误。

222
00:10:35,890 --> 00:10:38,970
这将是一个致命的错误
对于战士在宰赫兰。

223
00:10:38,970 --> 00:10:45,035
>>  - 什么事，是飞毛腿发射是
通过预警卫星探测，

224
00:10:45,035 --> 00:10:48,930
他们新的飞毛腿是
即将在他们的大方向。

225
00:10:48,930 --> 00:10:51,170
他们不知道有人来了。

226
00:10:51,170 --> 00:10:53,990
>> 现在 - 它要由雷达
爱国者系统的组成部分，

227
00:10:53,990 --> 00:10:58,520
保卫达兰，定位和保持
跟踪来袭的敌方导弹。

228
00:10:58,520 --> 00:10:59,690
>> -The雷达是非常聪明的。

229
00:10:59,690 --> 00:11:01,710
它实际上跟踪
飞毛腿的位置

230
00:11:01,710 --> 00:11:04,040
然后预测哪里
它很可能是，

231
00:11:04,040 --> 00:11:06,140
接下来的时间，该
雷达发送的脉冲输出。

232
00:11:06,140 --> 00:11:07,660
这被称为距离门。

233
00:11:07,660 --> 00:11:11,870
>>  - 然后，一旦爱国者
决定时间已够

234
00:11:11,870 --> 00:11:16,280
传递回去检查下
具体地址为检测对象，

235
00:11:16,280 --> 00:11:17,280
它可以追溯到。

236
00:11:17,280 --> 00:11:21,690
因此，当它回到了错
地方，然后看到没有对象

237
00:11:21,690 --> 00:11:25,230
和它决定，没有
对象，这是一个错误的检测，

238
00:11:25,230 --> 00:11:26,650
和下降的轨道。

239
00:11:26,650 --> 00:11:29,690
传入飞毛腿消失
从雷达屏幕上，

240
00:11:29,690 --> 00:11:32,670
几秒钟后，它
撞上了军营。

241
00:11:32,670 --> 00:11:38,100
飞毛腿杀害28是最后一个
第一次海湾战争期间，人开火。

242
00:11:38,100 --> 00:11:43,460
可悲的是，更新的软件
抵达宰赫兰的第二天。

243
00:11:43,460 --> 00:11:46,150
软件缺陷有
得到修复，闭合

244
00:11:46,150 --> 00:11:48,940
在陷入困境的一章
爱国者导弹的历史。

245
00:11:48,940 --> 00:11:50,220
>> [结束播放]

246
00:11:50,220 --> 00:11:54,340
>> 大卫·马兰：所以我们就来看看
一些类似的限制，只是有点。

247
00:11:54,340 --> 00:11:58,470
但首先，让我们来
过渡到一些仅供参考的。

248
00:11:58,470 --> 00:12:01,575
因此，埃德蒙顿这个周末，有
将超级部分，

249
00:12:01,575 --> 00:12:04,200
这意味着可以取代
定期的部分，这

250
00:12:04,200 --> 00:12:05,460
将一个星期，因此启动。

251
00:12:05,460 --> 00:12:08,204
看看在CS50的网站
对于这些详细信息。

252
00:12:08,204 --> 00:12:11,120
他们也将被拍摄下来，流
住那些无法参加。

253
00:12:11,120 --> 00:12:12,980
问题1是关于
当然，本已网站，

254
00:12:12,980 --> 00:12:15,105
我们将看看
在只是一点点。

255
00:12:15,105 --> 00:12:18,350
而办公时间也将采取
至周四把这个星期一。

256
00:12:18,350 --> 00:12:20,960
>> 因此，这是最典型
节目中，我们看了最后一次。

257
00:12:20,960 --> 00:12:23,590
这就像最简单
程序，你可以用C写的，

258
00:12:23,590 --> 00:12:25,250
即使这是一个有点大胆索赔。

259
00:12:25,250 --> 00:12:25,750
对？

260
00:12:25,750 --> 00:12:28,070
因为有很多的
似乎复杂此。

261
00:12:28,070 --> 00:12:30,445
所以，让我们快速浏览一下
什么一些这些元件中的

262
00:12:30,445 --> 00:12:33,080
分别为，然后尝试提供
如何的心理模型

263
00:12:33,080 --> 00:12:35,710
这些简单的程序
工作，然后我们将开始

264
00:12:35,710 --> 00:12:38,050
看事情越来越复杂。

265
00:12:38,050 --> 00:12:41,280
因此，这条线在这里，现在强调的，
在黄色的，没有大家说什么，最后一次，

266
00:12:41,280 --> 00:12:43,200
这为我们做？

267
00:12:43,200 --> 00:12:45,220
什么是它服务的目的是什么？

268
00:12:45,220 --> 00:12:46,984
任何人从更远了？

269
00:12:46,984 --> 00:12:47,483
是啊。

270
00:12:47,483 --> 00:12:48,649
>> 观众：[听不清]

271
00:12:48,649 --> 00:12:50,871

272
00:12:50,871 --> 00:12:51,704
大卫·马兰：好。

273
00:12:51,704 --> 00:12:53,537
所以，它给你的访问
为命令，或让我们

274
00:12:53,537 --> 00:12:56,750
给他们打电话的功能，有人
别人写的，被声明，

275
00:12:56,750 --> 00:12:58,350
可以这么说，在一些其他的文件。

276
00:12:58,350 --> 00:13:02,370
所以我们会看到什么.h文件
是对.c文件，最终。

277
00:13:02,370 --> 00:13:04,710
但现在，只知道
该printf的，例如，

278
00:13:04,710 --> 00:13:08,370
是其中已被功能
在其他文件中声明，在某处

279
00:13:08,370 --> 00:13:12,930
否则云计算的硬盘驱动器上
允许我们访问printf和使用

280
00:13:12,930 --> 00:13:15,240
而不必重新发明
那个轮子自己。

281
00:13:15,240 --> 00:13:16,930
同时，主要的。

282
00:13:16,930 --> 00:13:19,690
什么是主要的，上周的模拟？

283
00:13:19,690 --> 00:13:20,190
是啊。

284
00:13:20,190 --> 00:13:21,460
>> 观众：绿旗点击。

285
00:13:21,460 --> 00:13:21,740
>> 大卫·马兰：是的。

286
00:13:21,740 --> 00:13:23,490
划痕的，当绿旗点击。

287
00:13:23,490 --> 00:13:25,560
这就像一块拼图
该踢东西了。

288
00:13:25,560 --> 00:13:28,306
所以同样，做世界
几年前的决定C，

289
00:13:28,306 --> 00:13:30,930
和一堆其他语言，
如果你想编写一个程序，

290
00:13:30,930 --> 00:13:33,410
你的第一个功能
已被调用，主。

291
00:13:33,410 --> 00:13:34,641
而且它有看起来像这样。

292
00:13:34,641 --> 00:13:36,640
但是，我们会回来的，
另一次，是什么，INT，

293
00:13:36,640 --> 00:13:38,690
并且，无效的，意味着在这方面。

294
00:13:38,690 --> 00:13:42,860
就目前而言，花括号样
像划痕的拼图形状

295
00:13:42,860 --> 00:13:45,080
它封装线的一些数字。

296
00:13:45,080 --> 00:13:47,070
而就在电线之间
在这里，这是一个在这里。

297
00:13:47,070 --> 00:13:51,610
printf的是，其目的在一个函数
生活是打印的格式化字符串。

298
00:13:51,610 --> 00:13:55,010
而到格式化的，我的意思是你
可以在占位符值堵塞，

299
00:13:55,010 --> 00:13:58,360
你可以指定多个小数
点，有多少数字打印

300
00:13:58,360 --> 00:14:00,040
后一个小数点等。

301
00:14:00,040 --> 00:14:05,040
和printf，当然，需要一个
以上参数或参数，

302
00:14:05,040 --> 00:14:06,770
否则已知的，更简单地说，作为输入。

303
00:14:06,770 --> 00:14:09,230
>> 所以printf的，想了很多
函数的输入参数。

304
00:14:09,230 --> 00:14:12,730
而这些输入被接受
由两个括号这里。

305
00:14:12,730 --> 00:14:15,180
而那些里面是一个输入。

306
00:14:15,180 --> 00:14:18,600
这是一个字符串，因为我们已经把它称为，
这是一个字符的只是一个序列，

307
00:14:18,600 --> 00:14:22,310
像一个字，或短语，或整个
文章甚至在双引号之间。

308
00:14:22,310 --> 00:14:25,712
这就是发生了什么事情来影响
当然，printf的行为，因为，

309
00:14:25,712 --> 00:14:27,170
它只是一个普通的打印功能。

310
00:14:27,170 --> 00:14:29,600
它不会知道是什么
打印，除非你告诉它。

311
00:14:29,600 --> 00:14:31,000
然后，一些细枝末节。

312
00:14:31,000 --> 00:14:34,056
那么，我们能说这个奇怪
的符号序列是？

313
00:14:34,056 --> 00:14:34,556
是啊。

314
00:14:34,556 --> 00:14:35,410
>> 观众：新行。

315
00:14:35,410 --> 00:14:35,990
>> 大卫·马兰：新行。

316
00:14:35,990 --> 00:14:39,340
所以，事实证明，你不能只打，
进入，当你写的程序。

317
00:14:39,340 --> 00:14:42,590
通常，编译器是会得到
有点困惑，你的意思。

318
00:14:42,590 --> 00:14:45,340
相反，你必须从字面上
说，给我一个新的生产线在这里。

319
00:14:45,340 --> 00:14:49,506
所以/ N是我们一般
调用一个转义字符。

320
00:14:49,506 --> 00:14:50,870
因此n，新线路。

321
00:14:50,870 --> 00:14:53,810
而编译器知道
当它看到/ N，

322
00:14:53,810 --> 00:14:57,420
它实际上应该诱导计算机，
最终，或printf，在这种情况下，

323
00:14:57,420 --> 00:15:00,260
打印出一个新的实际
行，像打了，进入，

324
00:15:00,260 --> 00:15:01,480
键盘上的键。

325
00:15:01,480 --> 00:15:05,620
最后，做什么我们说
这一块的语法是什么？

326
00:15:05,620 --> 00:15:06,591
这是什么代表什么呢？

327
00:15:06,591 --> 00:15:07,090
是啊。

328
00:15:07,090 --> 00:15:07,490
>> 观众：[听不清]

329
00:15:07,490 --> 00:15:08,660
>> 大卫·马兰：这只是
该行的末尾。

330
00:15:08,660 --> 00:15:09,909
它是语句的末尾。

331
00:15:09,909 --> 00:15:11,890
并认识到我们不
把它们无处不在。

332
00:15:11,890 --> 00:15:13,900
我们当然不会把他们
在每行的末端。

333
00:15:13,900 --> 00:15:16,680
举例来说，有没有对
第一行，有没有上线

334
00:15:16,680 --> 00:15:18,680
有，主，有没有
花括号后，

335
00:15:18,680 --> 00:15:21,740
但你会开始看到并获得
熟悉的地方，它被称为为。

336
00:15:21,740 --> 00:15:26,014
它是一个功能之后几乎总是
致电或发表声明，一些行动

337
00:15:26,014 --> 00:15:27,180
你的确服用。

338
00:15:27,180 --> 00:15:29,520
>> 而现在知道，特别是如果
在那些不太舒服，

339
00:15:29,520 --> 00:15:32,540
这些都是种愚蠢的事情
你会最终不小心撞

340
00:15:32,540 --> 00:15:33,873
你的头撞墙了。

341
00:15:33,873 --> 00:15:36,107
因为你会在逻辑上
相信在某些问题

342
00:15:36,107 --> 00:15:38,440
你已经解决了问题
集，该死的东西只是

343
00:15:38,440 --> 00:15:40,187
将无法编译，甚至运行。

344
00:15:40,187 --> 00:15:43,270
所以通常情况下，在初期，它会
是因为你错过了一个括号，

345
00:15:43,270 --> 00:15:44,455
或者你错过了一个分号。

346
00:15:44,455 --> 00:15:46,547
所以只是留心
中，这样的东西

347
00:15:46,547 --> 00:15:49,380
并尽量不要被沮丧
因为他们很快做到这一点

348
00:15:49,380 --> 00:15:50,640
成为旧帽子。

349
00:15:50,640 --> 00:15:53,910
但它很容易得到
受挫早上，作为一个结果。

350
00:15:53,910 --> 00:15:57,020
>> 所以，现在，让我们来看看如何
这条线是实际工作

351
00:15:57,020 --> 00:15:59,170
再看看一个稍微
更复杂的之一。

352
00:15:59,170 --> 00:16:02,017
所以我们在这里，在
能够得出这样的屏幕上。

353
00:16:02,017 --> 00:16:04,100
让我们假设
这是我的电脑屏幕，

354
00:16:04,100 --> 00:16:08,589
但我写的，你好程序，
而我还没有实现，printf的。

355
00:16:08,589 --> 00:16:10,130
别人已经实施，printf的。

356
00:16:10,130 --> 00:16:12,420
谁愿意自称
已经实施了，printf的？

357
00:16:12,420 --> 00:16:12,920
如果我们可能吗？

358
00:16:12,920 --> 00:16:13,830
好吧，你叫什么名字？

359
00:16:13,830 --> 00:16:14,155
>> 学生1：[？柯巴。 ？]

360
00:16:14,155 --> 00:16:15,529
>> 大卫·马兰：Copal的，拜托了。

361
00:16:15,529 --> 00:16:16,430
上来吧。

362
00:16:16,430 --> 00:16:17,070
好吧。

363
00:16:17,070 --> 00:16:22,260
因此，我们有，在这里，一些名称标签，
因为我们会做出这样的小游戏。

364
00:16:22,260 --> 00:16:26,270
我们会打电话给你，printf的。

365
00:16:26,270 --> 00:16:30,170
如果你想要到这里来，
我刚刚在屏幕上绘制，

366
00:16:30,170 --> 00:16:32,340
这是相当简单的，还有我，这。

367
00:16:32,340 --> 00:16:35,550
>> 所有的权利，所以，你好我的名字是，
printf的，如果你想要把那。

368
00:16:35,550 --> 00:16:35,740
好吧。

369
00:16:35,740 --> 00:16:37,360
如果你可以去展台
通过在计算机屏幕

370
00:16:37,360 --> 00:16:39,730
就好像你是功能
来到这个计算机系统。

371
00:16:39,730 --> 00:16:42,063
而你的人生目标是
实际打印的东西。

372
00:16:42,063 --> 00:16:44,560
但是，就像节目我们
刚刚在屏幕上，在这里，

373
00:16:44,560 --> 00:16:47,060
我们将不得不
实际上给你一些意见。

374
00:16:47,060 --> 00:16:51,810
>> 所以，如果我的输入，在这里，
显然，什么是传递给printf，

375
00:16:51,810 --> 00:16:53,730
让我们种的讥笑它是这样的。

376
00:16:53,730 --> 00:16:58,720
我将字面上写上
一张纸，“你好，世界”

377
00:16:58,720 --> 00:17:03,020
反斜线N.而且要明确，什么样
我刚刚画在这张纸上，

378
00:17:03,020 --> 00:17:04,020
看起来是这样的。

379
00:17:04,020 --> 00:17:08,730
所以，当我运行这个程序，而这
代码黄线被执行，

380
00:17:08,730 --> 00:17:12,970
就好像我，hello程序，
我交给一些输入开了一个功能

381
00:17:12,970 --> 00:17:13,970
别人写的。

382
00:17:13,970 --> 00:17:16,595
>> 如果你与你的手指，
居然可以，用你的手指，

383
00:17:16,595 --> 00:17:21,520
在屏幕上绘制什么
这是你一直在流传，

384
00:17:21,520 --> 00:17:27,465
的效果，最终，是
看到正是这样，在屏幕上。

385
00:17:27,465 --> 00:17:29,140
和一个小角落的情况下在这里。

386
00:17:29,140 --> 00:17:31,540
而良好的，我们不应该看到
的，新线，在这一点上。

387
00:17:31,540 --> 00:17:33,900
这将是不正确的你
明确地得出新行。

388
00:17:33,900 --> 00:17:36,810
但是，如果我们不停地写上的字
屏幕上，他们最终会低于。

389
00:17:36,810 --> 00:17:39,560
>> 所以，非常感谢你，但坚持
这里只是一个瞬间各地。

390
00:17:39,560 --> 00:17:42,860
我们现在需要一个其他
志愿者，如果我们能，

391
00:17:42,860 --> 00:17:46,830
那将需要发挥的作用
of--这只是人们在乐团

392
00:17:46,830 --> 00:17:47,355
现在。

393
00:17:47,355 --> 00:17:47,980
如何about--确定。

394
00:17:47,980 --> 00:17:48,480
就在这儿。

395
00:17:48,480 --> 00:17:49,180
上来吧。

396
00:17:49,180 --> 00:17:49,955
你叫什么名字？

397
00:17:49,955 --> 00:17:50,922
>> 学生2：[？ Ivay。 ？]

398
00:17:50,922 --> 00:17:51,796
大卫·马兰：对不起？

399
00:17:51,796 --> 00:17:52,990
学生2：[？ Ivay。 ？]

400
00:17:52,990 --> 00:17:55,320
大卫·马兰：阮经天，上来吧。

401
00:17:55,320 --> 00:17:55,820
没有？

402
00:17:55,820 --> 00:17:58,390
难道我得到的错误，甚至
你说了两遍之后？

403
00:17:58,390 --> 00:17:58,890
上来吧。

404
00:17:58,890 --> 00:18:00,030
这是很难听到了这里。

405
00:18:00,030 --> 00:18:05,240

406
00:18:05,240 --> 00:18:05,740
行。

407
00:18:05,740 --> 00:18:07,190
我很抱歉，你叫什么名字？

408
00:18:07,190 --> 00:18:07,680
>> 学生2：[？ Ivay。 ？]

409
00:18:07,680 --> 00:18:08,790
>> [？大卫·马兰：Ivay。 ？] 行。

410
00:18:08,790 --> 00:18:10,430
现在，如果你不
心，你的GetString。

411
00:18:10,430 --> 00:18:11,013
>> 学生2：确定。

412
00:18:11,013 --> 00:18:11,797
酷。

413
00:18:11,797 --> 00:18:14,630
大卫·马兰：所以，如果你想
站在这里只是一瞬间，

414
00:18:14,630 --> 00:18:17,100
让我们来看看一个稍微
更复杂的程序，即

415
00:18:17,100 --> 00:18:18,670
现在有三行代码。

416
00:18:18,670 --> 00:18:24,080
因此，我们有，其一，说明用你的名字
printf的;二，一个电话给GetString，

417
00:18:24,080 --> 00:18:28,060
随后分配到一个
变量调用，字符串s，或称为S;

418
00:18:28,060 --> 00:18:31,260
然后再次调用，printf的，
但是这次使用两个输入。

419
00:18:31,260 --> 00:18:33,646
>> 因此，我们已经做状态
你的名字，或者更确切地说，我们已经

420
00:18:33,646 --> 00:18:34,770
已经做了printf的电话。

421
00:18:34,770 --> 00:18:38,960
所以我会写，说出你的名字。

422
00:18:38,960 --> 00:18:42,089
所以，有什么我要去
通，printf的，在短短的时刻，

423
00:18:42,089 --> 00:18:43,005
是很简单，这一点。

424
00:18:43,005 --> 00:18:47,760
所以，如果你想继续前进，得出这样的
在屏幕上，这是现在你的输入。

425
00:18:47,760 --> 00:18:48,260
好吧。

426
00:18:48,260 --> 00:18:51,160
而忘记字符串，我们现在有
我们自己的行代码在这里。

427
00:18:51,160 --> 00:18:54,470
所以，GetString的，我们需要
实际调用，GetString的。

428
00:18:54,470 --> 00:18:57,920
所以，你的人生目标是只走
外面的乐团，如果你能，

429
00:18:57,920 --> 00:18:58,980
并得到某人的名字。

430
00:18:58,980 --> 00:19:00,860
但是，让我们给你
东西把它。

431
00:19:00,860 --> 00:19:02,908
如果你想，去
进取，得到一个字符串，

432
00:19:02,908 --> 00:19:05,241
得到某人的名字上
一张纸，如果你能。

433
00:19:05,241 --> 00:19:12,940

434
00:19:12,940 --> 00:19:13,530
>> 好吧。

435
00:19:13,530 --> 00:19:15,250
我们将看到，在短短的时刻，
他的名字我们得到。

436
00:19:15,250 --> 00:19:17,630
同时，我所要
有现成的，是一张空白

437
00:19:17,630 --> 00:19:21,340
纸，其中，我要去
存储任何值它

438
00:19:21,340 --> 00:19:25,752
是，GetString的是返回给我，
我，作为一个所谓的字符串变量，S。

439
00:19:25,752 --> 00:19:26,252
好吧。

440
00:19:26,252 --> 00:19:27,293
所以，你有什么吗？

441
00:19:27,293 --> 00:19:27,950
聂。

442
00:19:27,950 --> 00:19:28,450
好吧。

443
00:19:28,450 --> 00:19:30,910
因此，我们有聂的名字在这里。

444
00:19:30,910 --> 00:19:33,750
因此，这是字面上
已返回

445
00:19:33,750 --> 00:19:35,810
对我来说，可以这么说，通过GetString的。

446
00:19:35,810 --> 00:19:38,720
>> 我，现在，我准备
执行左手侧

447
00:19:38,720 --> 00:19:43,440
那表情，在这里我简单的
抄下来，今天的目的，聂。

448
00:19:43,440 --> 00:19:46,470
所以，现在，我有一个变量
所谓，S，存储聂的名字。

449
00:19:46,470 --> 00:19:49,520
我已经交给
printf的，以前的说法。

450
00:19:49,520 --> 00:19:52,800
但是，在我们的第三个，也是最后的行
代码，我实际上是手的printf

451
00:19:52,800 --> 00:19:58,500
东西有点different--
“你好，％S，”反斜线ñ。

452
00:19:58,500 --> 00:20:01,510
>> 这样一来，最后一行我要去
到send--的最后一件事，我

453
00:20:01,510 --> 00:20:03,060
要现在写下来，是这样的。

454
00:20:03,060 --> 00:20:06,310
所以两行代码，或
而代码的最后一行，

455
00:20:06,310 --> 00:20:10,690
要求两inputs--
之一，这和两个，这一点。

456
00:20:10,690 --> 00:20:13,330
所以，如果我们的printf函数
现在可以把这些作为输入，

457
00:20:13,330 --> 00:20:16,000
让我清除屏幕为您服务。

458
00:20:16,000 --> 00:20:17,250
其实也没什么，你可以继续。

459
00:20:17,250 --> 00:20:19,333
我们会离开它，因为
它是在相同的程序。

460
00:20:19,333 --> 00:20:21,760

461
00:20:21,760 --> 00:20:27,380
我们应该看到，你好，聂。

462
00:20:27,380 --> 00:20:27,880
好吧。

463
00:20:27,880 --> 00:20:29,670
因此，这是相当多的
箍跳通过，只

464
00:20:29,670 --> 00:20:31,620
写，说明你的
名称和，你好，聂。

465
00:20:31,620 --> 00:20:37,210
但消息传递的这个简单的想法，
输入的传球和输出接收的，

466
00:20:37,210 --> 00:20:40,430
正是我们将不得不模型
即使是最复杂的功能。

467
00:20:40,430 --> 00:20:41,804
所以，谢谢你这么多，你俩。

468
00:20:41,804 --> 00:20:43,730
我们有一个可爱的压力
球在这里为你。

469
00:20:43,730 --> 00:20:48,890
谢谢你对我们的GetString
和printf志愿者的一致好评。

470
00:20:48,890 --> 00:20:49,551
谢谢。

471
00:20:49,551 --> 00:20:50,050
好吧。

472
00:20:50,050 --> 00:20:50,966
谢谢你们。

473
00:20:50,966 --> 00:20:56,640

474
00:20:56,640 --> 00:21:00,430
>> 因此，我们一直在谈论
迄今为止，大部分是关于串。

475
00:21:00,430 --> 00:21:06,550
而事实证明，C能实际
了解几个不同的数据类型。

476
00:21:06,550 --> 00:21:08,860
事实上，让我们
一起来看看这些在这里。

477
00:21:08,860 --> 00:21:12,490
因此，C，和很多语言，
认识事物称为字符。

478
00:21:12,490 --> 00:21:16,852
一个char通常一个是
单字节或8位。

479
00:21:16,852 --> 00:21:19,810
它代表一个字符，
像字母A或资本

480
00:21:19,810 --> 00:21:21,990
字母A，或小写字母
A，或感叹号，

481
00:21:21,990 --> 00:21:25,440
或任何字符，你可以键入
你的键盘，有时甚至更多。

482
00:21:25,440 --> 00:21:26,795
我们也碰巧看到彩车。

483
00:21:26,795 --> 00:21:31,160
浮子是，一般情况下，
32位值，或四个字节

484
00:21:31,160 --> 00:21:33,660
因为再次，一个字节是8比特。

485
00:21:33,660 --> 00:21:36,675
>> 所以一个float是一个浮点值，
大一些的小数点。

486
00:21:36,675 --> 00:21:38,550
事实上，这就是
这部电影是说

487
00:21:38,550 --> 00:21:42,240
，当他们谈到浮动
点值，一些固定位的数目

488
00:21:42,240 --> 00:21:43,940
被用于表示一个实数。

489
00:21:43,940 --> 00:21:45,740
但也有东西叫做双打。

490
00:21:45,740 --> 00:21:47,860
这些存在于Java中，
如果你已经采取了APCS，

491
00:21:47,860 --> 00:21:51,540
和双，正如其名字令人欣慰
顾名思义，是两次大如浮动。

492
00:21:51,540 --> 00:21:54,540
它仍然是一个实数，
它只是有更多的位

493
00:21:54,540 --> 00:21:58,390
与要更加精确，
或存储更大的数字。

494
00:21:58,390 --> 00:21:58,890
int是容易的。

495
00:21:58,890 --> 00:22:00,181
我们谈到了这最后的时间。

496
00:22:00,181 --> 00:22:01,160
这只是一个整数。

497
00:22:01,160 --> 00:22:03,980
而且它是一般32
位，或四个字节。

498
00:22:03,980 --> 00:22:07,850
>> 所以，如果你有，我们现在看到的，
32 bits--我们0周这样做，

499
00:22:07,850 --> 00:22:10,820
曾经如此briefly--，如果您有
32位，什么是最大的

500
00:22:10,820 --> 00:22:13,580
数可以表示为一个整​​数？

501
00:22:13,580 --> 00:22:16,080
给予或采取？

502
00:22:16,080 --> 00:22:18,380
这样4十亿，
而这只有当我们

503
00:22:18,380 --> 00:22:20,690
仅代表正数。

504
00:22:20,690 --> 00:22:23,930
如果你有32位，并且要
表示负数为好，

505
00:22:23,930 --> 00:22:27,100
你的范围是，从本质上讲，负
2十亿转正2十亿。

506
00:22:27,100 --> 00:22:29,250
但是总体来说，我们将开始
在0升至4十亿。

507
00:22:29,250 --> 00:22:32,400
>> 你不必准确地知道，但
我们可以看到这一点，事实上，如果我只是

508
00:22:32,400 --> 00:22:36,400
开了一个小计算器，点击这里。

509
00:22:36,400 --> 00:22:41,070
我可以做2的32，和
这正是有多大，

510
00:22:41,070 --> 00:22:43,190
有多少价值，你可以
表示，具有32位。

511
00:22:43,190 --> 00:22:44,442
而且它的约4十亿。

512
00:22:44,442 --> 00:22:46,900
因此，我们会继续看到这个数字
在几个不同的地方。

513
00:22:46,900 --> 00:22:48,890
但是如果你需要更长的
数比，

514
00:22:48,890 --> 00:22:51,670
原来有
一些所谓的很长很长。

515
00:22:51,670 --> 00:22:54,005
而一个很长很长的
通常64位，这

516
00:22:54,005 --> 00:22:56,380
意味着它是一个数量级
比int更大。

517
00:22:56,380 --> 00:22:59,510
>> 所以，我甚至不能发音最大
你可以代表数字，

518
00:22:59,510 --> 00:23:01,340
但它明显更大。

519
00:23:01,340 --> 00:23:05,190
现在，顺便说一句，从历史上看，
如果一个int是32位，

520
00:23:05,190 --> 00:23:12,780
和很长很长为64位，怎么样
大是一个长期的，而不是一个很长很长？

521
00:23:12,780 --> 00:23:16,500

522
00:23:16,500 --> 00:23:20,330
你会认为这是比int长
但也许少长不是很长很长，

523
00:23:20,330 --> 00:23:21,400
但它实际上依赖。

524
00:23:21,400 --> 00:23:23,400
>> 所以它变成一颗颗
过的挫折，

525
00:23:23,400 --> 00:23:26,830
对某些系统编写代码，
是，并不是所有的这些数据类型的

526
00:23:26,830 --> 00:23:28,440
有预先确定的值。

527
00:23:28,440 --> 00:23:29,771
有时候，这多少位。

528
00:23:29,771 --> 00:23:31,020
有时候，很多位。

529
00:23:31,020 --> 00:23:32,750
所以，你居然要知道，
有时，哪些硬件

530
00:23:32,750 --> 00:23:34,083
您正在运行的软件。

531
00:23:34,083 --> 00:23:36,960
值得庆幸的是，其他语言和
现在还存在着其他的数据类型，

532
00:23:36,960 --> 00:23:38,400
让您更精确。

533
00:23:38,400 --> 00:23:41,220
好了，我们看到的字符串，
而我们看到的布尔也

534
00:23:41,220 --> 00:23:43,960
但事实证明，这些都
只与CS50库。

535
00:23:43,960 --> 00:23:46,240
因此，那些不建
到C.这些替代，

536
00:23:46,240 --> 00:23:49,340
进来叫该文件
CS50.h，我们最终会

537
00:23:49,340 --> 00:23:51,831
剥开的层。

538
00:23:51,831 --> 00:23:53,830
但现在，他们只是
附加数据类型。

539
00:23:53,830 --> 00:23:57,060
一个布尔值是真还是假，和
串是字符序列，

540
00:23:57,060 --> 00:23:57,970
就像一个字。

541
00:23:57,970 --> 00:24:01,690
现在printf的，我们已经看到，有
占位符，％S就是其中之一。

542
00:24:01,690 --> 00:24:05,430
你也许可以，到现在为止，
从这些其它实例中，如何推断

543
00:24:05,430 --> 00:24:07,720
你可以有一个占位符
对于不同的数据类型。

544
00:24:07,720 --> 00:24:11,150
例如，以此来猜测，如果你
想使用打印出单个字符

545
00:24:11,150 --> 00:24:15,270
printf的，占位符大概％C。

546
00:24:15,270 --> 00:24:19,650
如果你想打印出
整数的占位符，％我。

547
00:24:19,650 --> 00:24:25,150
％LLD是一个很长很长的十进制值，
但很长很长，所以映射到这一点。

548
00:24:25,150 --> 00:24:28,640
然后％f浮点
点值或双，

549
00:24:28,640 --> 00:24:31,270
所以有时候他们重新使用
在不同的上下文。

550
00:24:31,270 --> 00:24:33,350
所以我们会看到和使用
其中一些随着时间的推移。

551
00:24:33,350 --> 00:24:36,420
和printf等功能也
支持别人的转义序列，

552
00:24:36,420 --> 00:24:38,080
有时，这些都是必要的。

553
00:24:38,080 --> 00:24:39,770
所以反斜杠n是一个新的生产线。

554
00:24:39,770 --> 00:24:42,886
反斜杠T，没有任何人
要采取刺？

555
00:24:42,886 --> 00:24:43,760
观众：标签。

556
00:24:43,760 --> 00:24:44,551
大卫·马兰：标签。

557
00:24:44,551 --> 00:24:46,810
所以，如果你真的想
打印出标签，而不是

558
00:24:46,810 --> 00:24:49,940
的空间的固定号码，但实际的
制表符，你不打你，

559
00:24:49,940 --> 00:24:53,490
标签上，在键盘上键，通常，
你其实反斜杠吨。

560
00:24:53,490 --> 00:24:57,750
反斜杠双引号，
为什么我会永远想的？

561
00:24:57,750 --> 00:24:58,250
对？

562
00:24:58,250 --> 00:25:00,417
为什么我不能只是输入
我的键盘上双引号？

563
00:25:00,417 --> 00:25:02,124
观众：
因为，否则，它是

564
00:25:02,124 --> 00:25:04,830
会认为这是结束
对喜欢您的打印[？文本。 ？]

565
00:25:04,830 --> 00:25:05,420
>> 大卫·马兰：没错。

566
00:25:05,420 --> 00:25:07,211
请记住，我们的
printf的例子，当我们

567
00:25:07,211 --> 00:25:10,075
被传递的输入对printf，
在该输入字符串的左

568
00:25:10,075 --> 00:25:12,950
并在该输入的右
春天，当然，是一个双引号。

569
00:25:12,950 --> 00:25:16,270
如果你自己输入有双重
报价在中间的那个，

570
00:25:16,270 --> 00:25:18,920
计算机可能潜在地
感到困惑，因为到，

571
00:25:18,920 --> 00:25:20,760
这是否双引号
属于中间？

572
00:25:20,760 --> 00:25:22,150
它是否与左边的归属？

573
00:25:22,150 --> 00:25:23,566
是否有一个正确的归属？

574
00:25:23,566 --> 00:25:26,780
所以，如果你想使超
明确的，你做的反斜线双引号，

575
00:25:26,780 --> 00:25:30,480
因此，它的逃脱了，可以这么说，和
它不是混为一谈别的东西。

576
00:25:30,480 --> 00:25:34,400
而且还有其他几个人在这里，
反斜线R，单引号，0，

577
00:25:34,400 --> 00:25:36,510
我们可以看到随着时间的推移，以及。

578
00:25:36,510 --> 00:25:37,760
而现在，怎么样的功能呢？

579
00:25:37,760 --> 00:25:41,630
>> 这样我们就可以采取迄今的行动
在这种语言，C，好了，我们已经看到，

580
00:25:41,630 --> 00:25:44,320
printf的，当然，所有的
屏幕上的其他人的，

581
00:25:44,320 --> 00:25:47,140
在这里，我们将使用的
当然第一个只有少数几个星期，

582
00:25:47,140 --> 00:25:48,485
来当CS50库。

583
00:25:48,485 --> 00:25:51,850
他们能够更容易，在
C，实际获取用户输入。

584
00:25:51,850 --> 00:25:54,200
事实证明，在C和
坦率地说在几种语言，

585
00:25:54,200 --> 00:25:57,450
它在脖子上做一个真正的痛苦
简单的东西，比如提示用户

586
00:25:57,450 --> 00:26:01,310
为键盘，为他或她的输入。

587
00:26:01,310 --> 00:26:03,240
所以，这些功能更容易。

588
00:26:03,240 --> 00:26:05,472
>> 它也有错误
在整个检查，

589
00:26:05,472 --> 00:26:07,180
这样一来，当你
记得上周三，我们

590
00:26:07,180 --> 00:26:09,740
看到了，重试，警告，
当我不配合，

591
00:26:09,740 --> 00:26:11,700
而我输入一个字，而不是数字？

592
00:26:11,700 --> 00:26:15,402
我们早做了繁重
在确保用户合作。

593
00:26:15,402 --> 00:26:17,860
但这些都只是培训
车轮，我们将最终，

594
00:26:17,860 --> 00:26:19,640
并迅速，起飞。

595
00:26:19,640 --> 00:26:22,630
>> 因此，要回顾一下，然后，
让我们快速浏览一下，

596
00:26:22,630 --> 00:26:26,620
就像我们有划痕，在没有
C.在一些典型结构

597
00:26:26,620 --> 00:26:28,580
这是为了，排序
的，是一个旋风之旅，

598
00:26:28,580 --> 00:26:30,990
只是让你有一个参考
那你首先看到的东西。

599
00:26:30,990 --> 00:26:34,100
但是，我们来看看实际的编码
使用其中的一些积木。

600
00:26:34,100 --> 00:26:36,710
所以，就像在刮，
当我们已经报表喜欢，

601
00:26:36,710 --> 00:26:41,570
或者说，等待，在C，我们确实有
功能以及，如printf。

602
00:26:41,570 --> 00:26:45,350
>> 如果我们想表达的条件
在C，它是类似的，在精神上，

603
00:26:45,350 --> 00:26:47,840
该拼图的
看起来是这样的划痕。

604
00:26:47,840 --> 00:26:49,850
但是相反，我们
从字面上只写，如果。

605
00:26:49,850 --> 00:26:51,830
然后，在括号
我们把一个条件，

606
00:26:51,830 --> 00:26:54,807
其中，该条件是我们将
打电话，再次，一个布尔表达式。

607
00:26:54,807 --> 00:26:56,390
再次，这是有点伪的。

608
00:26:56,390 --> 00:26:58,830
而且，事实上，//是注释。

609
00:26:58,830 --> 00:27:00,550
这只是英语单词我自己。

610
00:27:00,550 --> 00:27:03,000
但是，这是一般
的一个，如果，条件结构。

611
00:27:03,000 --> 00:27:05,220
但是，我们会看到具体的
例子在短短的时刻。

612
00:27:05,220 --> 00:27:07,960
>> 如果你想有一个
两路的岔路口，

613
00:27:07,960 --> 00:27:11,740
就像我们与我们的志愿者在做
周三你可以有一个，否则，如果。

614
00:27:11,740 --> 00:27:16,020
如果你想有一个第三和
最后一个条件，或者默认的情况下，

615
00:27:16,020 --> 00:27:19,006
你可以只是一个其他块，还有。

616
00:27:19,006 --> 00:27:21,880
同样，用布尔表达式，
你可以，而且，它们在一起。

617
00:27:21,880 --> 00:27:24,296
而且我们看到在周三，即
它不是一个单一的符号，

618
00:27:24,296 --> 00:27:28,220
它的2，为低级别的原因
我们最终会看到和发挥。

619
00:27:28,220 --> 00:27:30,410
的OR-ing的东西放在一起
是2竖条。

620
00:27:30,410 --> 00:27:32,240
根据美国的键盘，这
通常是一个关键

621
00:27:32,240 --> 00:27:35,730
与上面的Shift键
您的Enter键或Return键。

622
00:27:35,730 --> 00:27:38,620
>> 此外，还有这些东西
我们将使用也许一次或两次。

623
00:27:38,620 --> 00:27:42,570
它们是功能上等同于
你可以用做的，如果，否则，如果，

624
00:27:42,570 --> 00:27:44,950
否则，如果其他人，建设，
但他们称为交换机。

625
00:27:44,950 --> 00:27:48,020
他们看起来非常不同，但我们会
看到我们的一些分配代码，

626
00:27:48,020 --> 00:27:51,890
对于未来的习题集，最有可能的，
它有时只是一个漂亮

627
00:27:51,890 --> 00:27:54,060
表达一个整体的方式
一堆条件，

628
00:27:54,060 --> 00:27:57,590
无需大量的花括号和
很多括号和缩进的。

629
00:27:57,590 --> 00:28:01,910
但他们给我们没有更多的
功率比我们已经。

630
00:28:01,910 --> 00:28:02,550
现在循环。

631
00:28:02,550 --> 00:28:05,020
而这其中，我们来看看
在慢一点。

632
00:28:05,020 --> 00:28:08,470
但随后，我们将开始使用这些，
特别是对于那些已经熟悉。

633
00:28:08,470 --> 00:28:13,830
这是规范的方式，如果难以置信
神秘的方式，用C编写一个循环

634
00:28:13,830 --> 00:28:15,896
>> 现在，在划痕一个循环是
很简单。

635
00:28:15,896 --> 00:28:17,020
你有一个，永远块。

636
00:28:17,020 --> 00:28:19,760
你有一个，重复，块与
只是一个数字，你必须输入内容。

637
00:28:19,760 --> 00:28:22,220
而伴随着，for循环，可以
同时实现这些想法，

638
00:28:22,220 --> 00:28:23,595
但它是一个多一点的技术。

639
00:28:23,595 --> 00:28:25,994
但坦率地说，这也是
相对简单。

640
00:28:25,994 --> 00:28:28,160
一旦你知道的顺序
操作，你从字面上

641
00:28:28,160 --> 00:28:30,910
只是要在价值观堵塞
并告诉计算机做什么。

642
00:28:30,910 --> 00:28:32,800
因此，这里有一个例子。

643
00:28:32,800 --> 00:28:38,040
这是一个循环的是，相当
简单地说，从一个人数多达计算

644
00:28:38,040 --> 00:28:40,187
通过另一个。

645
00:28:40,187 --> 00:28:42,020
而就扫一眼
它，即使你有

646
00:28:42,020 --> 00:28:44,660
没有以往的经验
这种语言，什么号码

647
00:28:44,660 --> 00:28:46,920
它可能开始计数？

648
00:28:46,920 --> 00:28:47,730
OK，0。

649
00:28:47,730 --> 00:28:50,240
我猜那是因为你
看到有一个int和我，

650
00:28:50,240 --> 00:28:51,073
这是一个变量。

651
00:28:51,073 --> 00:28:52,390
它初始化为0。

652
00:28:52,390 --> 00:28:55,670
>> 再后来，它看起来像
我们传递的printf，一个值。

653
00:28:55,670 --> 00:28:58,000
而且，事实上，我在这里做一个小错字。

654
00:28:58,000 --> 00:28:59,850
但是，这容易固定。

655
00:28:59,850 --> 00:29:02,390
我要补充的，我在这里。

656
00:29:02,390 --> 00:29:06,150
我们现在有printf的存在
通过该占位符值。

657
00:29:06,150 --> 00:29:08,299
这有什么经历来算呢？

658
00:29:08,299 --> 00:29:08,840
听众：50。

659
00:29:08,840 --> 00:29:09,340
50。

660
00:29:09,340 --> 00:29:10,160
49。

661
00:29:10,160 --> 00:29:10,910
大卫·马兰：49。

662
00:29:10,910 --> 00:29:13,340
所以50，乍一看，似乎是正确的。

663
00:29:13,340 --> 00:29:16,990
但是，事实证明，将是
我们的条件，我们继续检查。

664
00:29:16,990 --> 00:29:21,740
而且我们要停止一次
i是不再小于50。

665
00:29:21,740 --> 00:29:24,920
所以这个循环中，反之，应
执行，只要i小于50。

666
00:29:24,920 --> 00:29:28,891
但只要它变为50，或51，
或者更糟，它应该自动停止。

667
00:29:28,891 --> 00:29:29,390
好吧。

668
00:29:29,390 --> 00:29:31,200
>> 那么究竟是什么发生在这里？

669
00:29:31,200 --> 00:29:33,160
因此，这是秩序
操作为一个循环。

670
00:29:33,160 --> 00:29:35,440
一，你有
所谓初始化。

671
00:29:35,440 --> 00:29:38,264
这种黄色高亮块
代码首先执行，

672
00:29:38,264 --> 00:29:40,930
并且它有一个，每效果
周三，你可能想象。

673
00:29:40,930 --> 00:29:45,500
它创建了一个名为i和它的变量
在变量存储值0。

674
00:29:45,500 --> 00:29:47,560
所以i为0，在这一点上的故事。

675
00:29:47,560 --> 00:29:49,680
>> 接下来的事情，
发生在这个结构，

676
00:29:49,680 --> 00:29:51,540
是该条件被检查。

677
00:29:51,540 --> 00:29:54,325
于是我立即检查，
为i小于50？

678
00:29:54,325 --> 00:29:57,700
当然，答案
现在来看，毫无疑问，是的。

679
00:29:57,700 --> 00:30:00,710
是的，因为我是0，
这是肯定小于50。

680
00:30:00,710 --> 00:30:03,866
然后发生了什么，是这
行代码被执行。

681
00:30:03,866 --> 00:30:06,740
而事实上，如果有多个
的代码中的那些大括号线，

682
00:30:06,740 --> 00:30:09,020
他们都得到执行此起彼伏。

683
00:30:09,020 --> 00:30:11,450
>> 并且在这里的效果，是
显然，打印出

684
00:30:11,450 --> 00:30:15,365
的编号i，这是会
为0，然后1，然后2。

685
00:30:15,365 --> 00:30:15,865
但为什么？

686
00:30:15,865 --> 00:30:17,410
它为什么会得到增加？

687
00:30:17,410 --> 00:30:20,680
那么，第四件事，
碰巧的是，这个语法

688
00:30:20,680 --> 00:30:22,610
被执行，分号之后。

689
00:30:22,610 --> 00:30:27,506
我++是一个说速记的方式;
取的i的值，并把它加1;

690
00:30:27,506 --> 00:30:30,380
再下一次，加
1到它;而下一次，

691
00:30:30,380 --> 00:30:31,330
其加1。

692
00:30:31,330 --> 00:30:33,640
>> 因此，如果我们继续下去，
什么会发生

693
00:30:33,640 --> 00:30:35,890
接下来就是我不打算
以后再初始化我。

694
00:30:35,890 --> 00:30:38,290
如果我一直在初始化
i到0，本实施例

695
00:30:38,290 --> 00:30:41,110
永远不会结束，因为
我会停留在0。

696
00:30:41,110 --> 00:30:43,870
但什么事情发生是
该条件将被检查，

697
00:30:43,870 --> 00:30:54,280
该行代码会被执行，
在我将增加，

698
00:30:54,280 --> 00:30:56,970
条件将被检查，
代码会被执行。

699
00:30:56,970 --> 00:30:59,790
它再次保持骑自行车，
又一次，又一次，

700
00:30:59,790 --> 00:31:03,340
直到我++诱导值50。

701
00:31:03,340 --> 00:31:05,870
>> 条件接着说，
比50 50少了呢？

702
00:31:05,870 --> 00:31:09,360
当然，答案是否定的，
所以整个代码停止执行。

703
00:31:09,360 --> 00:31:13,020
如果你有在屏幕上更多的代码
向下跌破，那接下来会发生什么。

704
00:31:13,020 --> 00:31:17,530
它弹出来，这些花括号和
继续打印后更多。

705
00:31:17,530 --> 00:31:20,470
>> 所以，现在开个玩笑，从狐步舞，那
你也许现在明白了。

706
00:31:20,470 --> 00:31:30,810

707
00:31:30,810 --> 00:31:31,560
它总是有趣的。

708
00:31:31,560 --> 00:31:34,110
这就像笑
样的过滤，

709
00:31:34,110 --> 00:31:38,370
然后你意识到你不应该
是笑的幽默是这样。

710
00:31:38,370 --> 00:31:41,160
但是，有一些外卖
在这里，教学法，太。

711
00:31:41,160 --> 00:31:43,577
所以，事实证明，我
缺了一块的语法，

712
00:31:43,577 --> 00:31:45,410
或狐步舞的失踪
一块语法在这里。

713
00:31:45,410 --> 00:31:48,076
现在缺少的，我们已经有
在每一个其他实施例，从而多远？

714
00:31:48,076 --> 00:31:51,599

715
00:31:51,599 --> 00:31:53,390
返回，在那里，所以
这是别的东西，

716
00:31:53,390 --> 00:31:54,440
我们再回过头来不久。

717
00:31:54,440 --> 00:31:55,398
缺少了什么有关系吗？

718
00:31:55,398 --> 00:31:55,908
是啊。

719
00:31:55,908 --> 00:31:58,150
>> 观众：该
初始化[听不清]。

720
00:31:58,150 --> 00:31:58,470
>> 大卫·马兰：OK。

721
00:31:58,470 --> 00:31:58,980
所以呀。

722
00:31:58,980 --> 00:32:03,210
所以实际上，这个is--嘛，
和计数初始化

723
00:32:03,210 --> 00:32:05,470
上述起来，或者说，上述宣布了起来。

724
00:32:05,470 --> 00:32:06,960
因此，这是做的另一种方式。

725
00:32:06,960 --> 00:32:08,685
但不是在一条线是有效的，但。

726
00:32:08,685 --> 00:32:09,310
怎么在这里？

727
00:32:09,310 --> 00:32:10,196
>> 观众：是不是大括号？

728
00:32:10,196 --> 00:32:10,640
>> 大卫·马兰：是的。

729
00:32:10,640 --> 00:32:12,080
因此，大括号丢失。

730
00:32:12,080 --> 00:32:15,495
但是这个代码，我的意思是，他们的信用，
实际上，语法上有效。

731
00:32:15,495 --> 00:32:17,610
事实证明，你不
需要花括号

732
00:32:17,610 --> 00:32:21,691
如果你只有一行代码
要在循环内执行。

733
00:32:21,691 --> 00:32:24,190
现在我们总是在课堂上和
我们所有的分销代码，

734
00:32:24,190 --> 00:32:26,730
包括大括号
无论如何，仅仅是为了清楚起见。

735
00:32:26,730 --> 00:32:29,010
但要意识到，在教科书
和网上的例子，

736
00:32:29,010 --> 00:32:31,300
你很可能看到大
牙套有时失踪。

737
00:32:31,300 --> 00:32:34,850
这没关系，如果你
已经缩进和预期

738
00:32:34,850 --> 00:32:38,650
是代码只是一个单一的线，而不是
多行代码，潜在的。

739
00:32:38,650 --> 00:32:39,150
好吧。

740
00:32:39,150 --> 00:32:44,500
所以相关的问题
不精确，溢出的问题，

741
00:32:44,500 --> 00:32:48,560
在这个意义上，类似地，
确实整数必须限制他们

742
00:32:48,560 --> 00:32:49,970
就像浮点值？

743
00:32:49,970 --> 00:32:53,120
在世界上的浮点
价值观，我们只能是如此精确，

744
00:32:53,120 --> 00:32:55,710
在此之后，有时
不好的事情都可能发生，

745
00:32:55,710 --> 00:32:57,760
而我们的方案可以是越野车和错误。

746
00:32:57,760 --> 00:33:00,050
现在，即使是整数，
你会遇到的问题。

747
00:33:00,050 --> 00:33:03,820
现在的整数不具有
小数点或之后的数字。

748
00:33:03,820 --> 00:33:07,130
它只是一个自然数，一般。

749
00:33:07,130 --> 00:33:09,430
那么，什么可以去错了一个int？

750
00:33:09,430 --> 00:33:12,210
如果我用一个int来
计数，有什么可以去错了吗？

751
00:33:12,210 --> 00:33:13,230
似乎简单了很多。

752
00:33:13,230 --> 00:33:13,873
是啊。

753
00:33:13,873 --> 00:33:16,240
>> 观众：如果
数字变[听不清]

754
00:33:16,240 --> 00:33:17,073
>> 大卫·马兰：是的。

755
00:33:17,073 --> 00:33:20,820
如果算上如此之高，你有什么
无法用语言表达的真正的大数目。

756
00:33:20,820 --> 00:33:21,320
对？

757
00:33:21,320 --> 00:33:23,910
在某些时候，你会
超过界限

758
00:33:23,910 --> 00:33:27,077
的一个32位值或64位的值。

759
00:33:27,077 --> 00:33:29,410
现在，再次，我不知道怎么样
发音一个64位的值，

760
00:33:29,410 --> 00:33:32,230
但我知道，有一个32位整数，
它可以是最大的值，

761
00:33:32,230 --> 00:33:35,490
如果它是唯一积极的
值，是约4十亿。

762
00:33:35,490 --> 00:33:39,000
所以，如果我尝试数到5十亿，
事情将要发生。

763
00:33:39,000 --> 00:33:41,050
但是，让我们看看，其实都有可能发生。

764
00:33:41,050 --> 00:33:44,570
在整数世界
溢出，在那里你，从某种意义上说，

765
00:33:44,570 --> 00:33:48,270
溢出的能力
整数，会发生什么事情？

766
00:33:48,270 --> 00:33:51,190
>> 所以这里有一个二进制数，
这是一个倒退到0。

767
00:33:51,190 --> 00:33:54,630
这是全1，和占位符
在那里，有2的幂，

768
00:33:54,630 --> 00:33:55,980
所以这是二进制的。

769
00:33:55,980 --> 00:33:59,416
因此，这些都是8,1位在屏幕上。

770
00:33:59,416 --> 00:34:01,290
如果你还记得或
你快做数学题，

771
00:34:01,290 --> 00:34:06,074
什么样的价值正在被代表
这里这八个1位？

772
00:34:06,074 --> 00:34:06,950
255。

773
00:34:06,950 --> 00:34:09,260
即使你是不是很确定
数学的，你可以做出来。

774
00:34:09,260 --> 00:34:10,550
或者你可以只种
原因通过它，

775
00:34:10,550 --> 00:34:12,633
等一下，如果我
较8位值，

776
00:34:12,633 --> 00:34:17,750
我已经得到了256个可能的值，
但其中第一是0，

777
00:34:17,750 --> 00:34:19,909
我只知道，
最大的将是255，

778
00:34:19,909 --> 00:34:21,510
而这正是这一个可能。

779
00:34:21,510 --> 00:34:26,060
>> 因此，假设我尝试添加1到这个值。

780
00:34:26,060 --> 00:34:28,750
你会在年级做
加入学校的时候1，而且

781
00:34:28,750 --> 00:34:31,139
并不真正适合，因为
你必须随身携带的1？

782
00:34:31,139 --> 00:34:34,380
这是什么数将
当你加1变成什么？

783
00:34:34,380 --> 00:34:37,030
这将变为0。

784
00:34:37,030 --> 00:34:37,530
对？

785
00:34:37,530 --> 00:34:41,139
因为如果你有更多的bits--，我会
尝试，种，它这里 - 打出来

786
00:34:41,139 --> 00:34:44,710
如果我们有更多的位，我们
可以在这里做的是添加1，

787
00:34:44,710 --> 00:34:47,370
然后我们会得到这一点。

788
00:34:47,370 --> 00:34:48,739
哎呦。

789
00:34:48,739 --> 00:34:52,250
我们希望有一个1位一路看过来。

790
00:34:52,250 --> 00:34:55,530
>> 但是，如果这是一个有限
值，这是只有8位，

791
00:34:55,530 --> 00:34:57,480
这就是预先确定
由计算机，

792
00:34:57,480 --> 00:34:59,370
这1实际上是不存在的。

793
00:34:59,370 --> 00:35:00,980
正中下怀它掉下悬崖。

794
00:35:00,980 --> 00:35:05,480
所以，如果你添加1到255，有什么
值你显然得到什么呢？

795
00:35:05,480 --> 00:35:06,180
0。

796
00:35:06,180 --> 00:35:09,700
所以意外的数字，
或许，无意间，

797
00:35:09,700 --> 00:35:12,040
最终披着这样。

798
00:35:12,040 --> 00:35:14,079
那么什么可以是这意味着什么呢？

799
00:35:14,079 --> 00:35:15,620
嗯，有一些不同的东西。

800
00:35:15,620 --> 00:35:18,751
所以之一，它最终看起来
如0，无意间，

801
00:35:18,751 --> 00:35:20,750
但你可以种看，
即使在现实世界中，

802
00:35:20,750 --> 00:35:23,416
是好还是坏，
表现这种思想的限制。

803
00:35:23,416 --> 00:35:26,630
例如，任何你谁
玩过乐高星球大战，

804
00:35:26,630 --> 00:35:28,880
没有人知道发生
硬币的最大数目

805
00:35:28,880 --> 00:35:32,032
您可以在乐高星球大战收集？

806
00:35:32,032 --> 00:35:35,640
以基于猜测
当今领先的问题。

807
00:35:35,640 --> 00:35:39,140
这是大于256或255。

808
00:35:39,140 --> 00:35:40,330
它的4间十亿。

809
00:35:40,330 --> 00:35:42,080
所以，事实证明，和
有一些people--

810
00:35:42,080 --> 00:35:46,080
一些谷歌上搜索确认最后night--
已经得到了4个十亿金币，

811
00:35:46,080 --> 00:35:47,730
或者诸如此类的东西，在乐高星球大战。

812
00:35:47,730 --> 00:35:49,860
虽然很明显，有
一种方法来欺骗游戏，

813
00:35:49,860 --> 00:35:53,222
有一个错误或功能，可以让你
只是累积很多很多的点。

814
00:35:53,222 --> 00:35:54,930
但最大的可能
值，根据

815
00:35:54,930 --> 00:35:58,360
这个屏幕截图的人，我
网上找到的，确实是，4个十亿。

816
00:35:58,360 --> 00:35:59,240
>> 现在，这是为什么？

817
00:35:59,240 --> 00:36:03,040
这正是4个十亿，
可能是因为有人决定，

818
00:36:03,040 --> 00:36:05,500
谁在写本场比赛，
他们可以做4组十亿，

819
00:36:05,500 --> 00:36:07,340
什么，什么，什么，
像值我忍了

820
00:36:07,340 --> 00:36:10,256
用计算器较早，但
它只是一个少许清洁剂对人类

821
00:36:10,256 --> 00:36:12,610
说的最大数量
的coins--或螺栓，

822
00:36:12,610 --> 00:36:14,860
他们称之为them--你
可以收集4十亿。

823
00:36:14,860 --> 00:36:16,290
所以，这是为什么？

824
00:36:16,290 --> 00:36:20,310
如何为乐高游戏
实施反

825
00:36:20,310 --> 00:36:23,420
那就是维持轨道的
硬币有多少？

826
00:36:23,420 --> 00:36:24,266
他们使用的是什么？

827
00:36:24,266 --> 00:36:26,390
观众：它停止
4个十亿后计数。

828
00:36:26,390 --> 00:36:27,720
大卫·马兰：它停止
4个十亿计数后，

829
00:36:27,720 --> 00:36:29,525
这意味着你可以
推断，作为一个程序员，

830
00:36:29,525 --> 00:36:31,960
他们很可能
使用32位的整数。

831
00:36:31,960 --> 00:36:35,380
就像程序员真的只是
类型化，INT，在他或她的代码，

832
00:36:35,380 --> 00:36:39,620
这就是可变的类​​型
他们使用存储别人的代码。

833
00:36:39,620 --> 00:36:42,230
因此，有其他表现
这些类型的限制。

834
00:36:42,230 --> 00:36:45,063
>> 所以，我没有玩过这个game--
而我读了历史

835
00:36:45,063 --> 00:36:48,470
确认作为much--但在
文明，那里的原始版本

836
00:36:48,470 --> 00:36:53,240
你显然与每个互动
另外，可以发动战争或和平，

837
00:36:53,240 --> 00:36:56,590
甘地被认为是一个
最和平的角色，因为我

838
00:36:56,590 --> 00:36:59,280
理解，在第一
版本文明。

839
00:36:59,280 --> 00:37:03,250
而事实上，在范围为1至10，
他的侵略性只是一个1。

840
00:37:03,250 --> 00:37:05,620
所以永远是那么温和
侵略性，显然。

841
00:37:05,620 --> 00:37:11,590
>> 但是，在某些时候，你可以很明显
在地理上安装民主。

842
00:37:11,590 --> 00:37:14,900
如果你安装的民主
到你的游戏版本，

843
00:37:14,900 --> 00:37:17,320
那么你的攻击水平下降。

844
00:37:17,320 --> 00:37:18,460
这是一个很好的事情。

845
00:37:18,460 --> 00:37:20,890
人们更安静
显然，在这种情况下。

846
00:37:20,890 --> 00:37:23,190
但很显然，有人做
没有一个，如果，条件

847
00:37:23,190 --> 00:37:24,780
在代码中的原始版本。

848
00:37:24,780 --> 00:37:30,650
>> 所以，甘地的侵略水平由去
正1，负2，负1，

849
00:37:30,650 --> 00:37:33,840
但游戏不
了解负数。

850
00:37:33,840 --> 00:37:38,680
所以，事情的经过是甘地的侵略
从1级去了，到0，负1，

851
00:37:38,680 --> 00:37:40,900
这具有的效果
折回是

852
00:37:40,900 --> 00:37:44,690
最积极的角色
在比赛中，以255的值，

853
00:37:44,690 --> 00:37:46,630
上的比例为1至10。

854
00:37:46,630 --> 00:37:49,887
从那时起，还有的是
更化身这场比赛，

855
00:37:49,887 --> 00:37:51,720
他们已经把它作为
一种复活节彩蛋的，

856
00:37:51,720 --> 00:37:53,870
甘地显然是
这么可怕的攻击性。

857
00:37:53,870 --> 00:37:56,740
但它是一个结果
很简单的编程错误

858
00:37:56,740 --> 00:37:58,630
在游戏中的该非常早期版本。

859
00:37:58,630 --> 00:38:02,860
>> 现在更令人不安的是，多
最近，波音787

860
00:38:02,860 --> 00:38:05,720
被记录为具有
错误，不是那种设备

861
00:38:05,720 --> 00:38:07,340
你特别想有一个bug。

862
00:38:07,340 --> 00:38:10,130
且症状，我会读
在这里，从网上的文章，

863
00:38:10,130 --> 00:38:13,840
是这样的，一个模型787飞机
已连续供电

864
00:38:13,840 --> 00:38:18,030
248天就失去了所有
交变电流，交流，

865
00:38:18,030 --> 00:38:20,850
电功率，由于
发电机控制单元，

866
00:38:20,850 --> 00:38:23,330
GCUs，同时
进入故障安全模式。

867
00:38:23,330 --> 00:38:26,790
因此，这是发出警告
当这个问题被发现。

868
00:38:26,790 --> 00:38:28,750
这种情况是由于
通过软件计数器，

869
00:38:28,750 --> 00:38:32,230
内部的GCUs，所以
整数或一个变量，

870
00:38:32,230 --> 00:38:36,850
248之后溢出
连续功率天。

871
00:38:36,850 --> 00:38:40,350
波音是在过程中
开发GCU软件升级

872
00:38:40,350 --> 00:38:42,350
将弥补的不安全状态。

873
00:38:42,350 --> 00:38:44,226
>> 那么像导弹
方案中，其中，

874
00:38:44,226 --> 00:38:46,850
他们有一些类型的变量
被计数，计数，

875
00:38:46,850 --> 00:38:50,720
和计数，但渐渐溢满
其能力的界限，

876
00:38:50,720 --> 00:38:54,890
同样做了该死的飞机
具有可变的溢出

877
00:38:54,890 --> 00:38:56,410
经过足够的时间运行。

878
00:38:56,410 --> 00:38:59,240
这样一来，舌头在脸颊的方式
解决此问题的工作

879
00:38:59,240 --> 00:39:04,400
是真正的，重新启动，你的飞机每
247个天，使得存储器被擦拭

880
00:39:04,400 --> 00:39:06,100
和可变回到0。

881
00:39:06,100 --> 00:39:09,410
但要意识到，这是一个非常
大型化身软件，

882
00:39:09,410 --> 00:39:14,070
但特别是当我们听到苹果
操作系统进入汽车，

883
00:39:14,070 --> 00:39:18,030
并从谷歌自驾车车，
任意数量的软件的化身

884
00:39:18,030 --> 00:39:21,000
在我们的日常生活中，电视
和手表等，

885
00:39:21,000 --> 00:39:24,950
实现由软件所包围，
所有这一切都写的是我们人类。

886
00:39:24,950 --> 00:39:28,150
>> 正如我们都会很快就会发现，
它很容易和非常典型

887
00:39:28,150 --> 00:39:30,250
编写软件时犯错误。

888
00:39:30,250 --> 00:39:32,745
如果你不抓住他们，
一些不好的事情都可能发生。

889
00:39:32,745 --> 00:39:35,400
现在有时，一些
有趣的事情都可能发生，

890
00:39:35,400 --> 00:39:38,280
或者至少有时候我们
知道会发生一些不良。

891
00:39:38,280 --> 00:39:41,550
因此，0除以0，从等级
学校，一般是一件坏事。

892
00:39:41,550 --> 00:39:43,050
这是不确定的。

893
00:39:43,050 --> 00:39:46,440
而事实证明out--，让如果我们看
我的麦克风可以选择此up--苹果

894
00:39:46,440 --> 00:39:47,790
曾与这一些有趣的最近。

895
00:39:47,790 --> 00:39:48,850
所以，我有一个iPhone在这里。

896
00:39:48,850 --> 00:39:54,160
我要谈的Siri，问她
给我的答案0除以0。

897
00:39:54,160 --> 00:39:55,850
什么是0除以0？

898
00:39:55,850 --> 00:39:59,350

899
00:39:59,350 --> 00:40:02,230
>> SIRI：假设您有0
饼干，和你平分他们

900
00:40:02,230 --> 00:40:03,540
在0朋友。

901
00:40:03,540 --> 00:40:05,810
多少饼干确实每个人得到什么呢？

902
00:40:05,810 --> 00:40:06,350
看到了吗？

903
00:40:06,350 --> 00:40:07,660
它没有意义。

904
00:40:07,660 --> 00:40:10,540
而且饼干怪兽是悲哀
有没有饼干。

905
00:40:10,540 --> 00:40:13,987
而你伤心，
你有没有朋友。

906
00:40:13,987 --> 00:40:15,570
大卫·马兰：这是一种令人厌恶的。

907
00:40:15,570 --> 00:40:17,550
所以这就是刚才说有。

908
00:40:17,550 --> 00:40:21,380
这是不确定的，它没有定义，
而事实上，许多编程语言

909
00:40:21,380 --> 00:40:24,950
或者，真的，编译器会
当您，检测程序，

910
00:40:24,950 --> 00:40:27,050
试图除以0 0。

911
00:40:27,050 --> 00:40:29,830
更多乐趣比这虽然是
，显然，饼干怪兽

912
00:40:29,830 --> 00:40:31,270
是在Twitter上的这些日子。

913
00:40:31,270 --> 00:40:37,610
他回答了，这一点，
这是绝对可爱。

914
00:40:37,610 --> 00:40:40,110
但是，让我们快速浏览一下
一对夫妇的其他构造，

915
00:40:40,110 --> 00:40:43,459
然后把一些这方面的
代码中使用，以良好的方式。

916
00:40:43,459 --> 00:40:45,250
所以，事实证明，除了
对循环，有

917
00:40:45,250 --> 00:40:49,174
一种叫做while循环，即
看起来不同的，是实现

918
00:40:49,174 --> 00:40:51,590
一个小differently--和
我们最终会看到examples--

919
00:40:51,590 --> 00:40:53,500
但在某种意义上，
它的简单，因为它

920
00:40:53,500 --> 00:40:56,670
不允许初始化和
环路的边界之内更新。

921
00:40:56,670 --> 00:40:57,794
你仍然可以实现它。

922
00:40:57,794 --> 00:41:01,219
所以，你可以做同样的事情
与while循环，与一个for循环，

923
00:41:01,219 --> 00:41:03,260
但你的语法，ultimately--
因为我们最终会

924
00:41:03,260 --> 00:41:04,551
see--将是不同的。

925
00:41:04,551 --> 00:41:07,450
甚至还有一个do while循环，这
其实是有一点不同，

926
00:41:07,450 --> 00:41:09,640
在而一个for循环
和while循环总是

927
00:41:09,640 --> 00:41:13,005
首先检查自己的条件，如果
你看过这个东西从上到下，

928
00:41:13,005 --> 00:41:16,440
那种看起来它会
检查它的情况最后，因为它是

929
00:41:16,440 --> 00:41:17,910
真正的最后一行代码。

930
00:41:17,910 --> 00:41:20,580
事实上，这将是有益的
在我们编写某些程序，

931
00:41:20,580 --> 00:41:23,746
如果你想只是盲目地做一些事情
最终检查的条件。

932
00:41:23,746 --> 00:41:25,205
这不一定是坏事。

933
00:41:25,205 --> 00:41:27,912
如果我们想要的变量，我们可以做
它在几个不同的方式。

934
00:41:27,912 --> 00:41:30,290
而我们的狐步舞看见
卡通，做的一种方法，

935
00:41:30,290 --> 00:41:33,400
在这里你声明的变量，
如int计数器分号，

936
00:41:33,400 --> 00:41:36,570
然后later--说不定下
行，也许10线later--

937
00:41:36,570 --> 00:41:37,800
你居然初始化。

938
00:41:37,800 --> 00:41:42,230
因此，这2行代码
声明一个int类型的变量

939
00:41:42,230 --> 00:41:44,930
并称之为反，所以它给
我足够的位来容纳一个int。

940
00:41:44,930 --> 00:41:48,230
然后最终，它把
值0到该变量。

941
00:41:48,230 --> 00:41:51,250
它排列0和1的在一个
模式，我们知道上周，

942
00:41:51,250 --> 00:41:53,260
代表我们所知道的0号。

943
00:41:53,260 --> 00:41:56,920
或者坦白地说，你可以做这么多
更简洁地说，就这样。

944
00:41:56,920 --> 00:41:59,390
>> 现在，我们也有
能够调用函数。

945
00:41:59,390 --> 00:42:03,070
而事实上，这里有一个2线
程序，或它们的摘录，

946
00:42:03,070 --> 00:42:06,157
这使我们能够真正
编写一些代码，

947
00:42:06,157 --> 00:42:08,990
得到来自user--字符串多
就像我们的志愿者一时ago--

948
00:42:08,990 --> 00:42:11,320
结果存储到
一个名为名称的变量，

949
00:42:11,320 --> 00:42:15,470
和then--很像我们的志愿者
与printf--打印出这些值

950
00:42:15,470 --> 00:42:19,180
通过传递两个参数，
串，其次是可变

951
00:42:19,180 --> 00:42:20,781
叫，名称本身。

952
00:42:20,781 --> 00:42:23,155
因此，让我们来看看，前
我们再回过头来马里奥那里，

953
00:42:23,155 --> 00:42:26,010
在一对夫妇的这个现在的例子。

954
00:42:26,010 --> 00:42:30,537
>> 我要继续前进，开
了，让我们说，功能0.c。

955
00:42:30,537 --> 00:42:33,120
和往常一样，这个代码是
可在球场上的网站，

956
00:42:33,120 --> 00:42:35,660
这样你就可以在一起玩
回家看它以后。

957
00:42:35,660 --> 00:42:40,400
但这里有一个程序在它的
本质上，从线17至22。

958
00:42:40,400 --> 00:42:43,270
主程序所在
计划总是会启动。

959
00:42:43,270 --> 00:42:46,980
这一方案，显然，是怎么回事
打印出你的名字，冒号。

960
00:42:46,980 --> 00:42:50,320
它随后将打电话的GetString，
就像我们做了与我们的志愿者。

961
00:42:50,320 --> 00:42:53,365
然后，这是有趣的，
它会调用PrintName。

962
00:42:53,365 --> 00:42:56,490
事实证明，这一切的时候，有
似乎是被称为PrintName函数。

963
00:42:56,490 --> 00:42:57,614
可打印某人的名字。

964
00:42:57,614 --> 00:43:01,210
我们并不需要用printf从
昔日，有PrintName。

965
00:43:01,210 --> 00:43:03,500
>> 但是，这是误导
因为PrintName不

966
00:43:03,500 --> 00:43:06,760
配备了C.人们不
一些40年或50年前发明了它，

967
00:43:06,760 --> 00:43:07,990
我这样做，而不是。

968
00:43:07,990 --> 00:43:10,330
而事实上，如果我滚动
进一步下降，通知

969
00:43:10,330 --> 00:43:14,200
我怎么能写我自己
在C函数我们最终会

970
00:43:14,200 --> 00:43:16,319
解释为什么我们一直在说，
无效，在少数地方，

971
00:43:16,319 --> 00:43:18,110
但今天，让我们
光看这个名字。

972
00:43:18,110 --> 00:43:20,905
>> 在第24行，如果你想
创建自己的功能，

973
00:43:20,905 --> 00:43:22,780
你从字面上写的
功能的命名。

974
00:43:22,780 --> 00:43:24,340
我选择了PrintName。

975
00:43:24,340 --> 00:43:26,159
在括号，你
然后指定哪几种

976
00:43:26,159 --> 00:43:28,450
投入，有多少你
希望此功能可走。

977
00:43:28,450 --> 00:43:31,906
在这种情况下，我想带
1变量调用，名称，

978
00:43:31,906 --> 00:43:34,030
而这将是
型，字符串，因此它会

979
00:43:34,030 --> 00:43:35,780
是一串字符。

980
00:43:35,780 --> 00:43:39,170
然后，这个program--
就像在刮，

981
00:43:39,170 --> 00:43:42,590
你可以定制拼图pieces--
将有这种自定义行为。

982
00:43:42,590 --> 00:43:46,760
这将调用printf
传递，你好，占位符，

983
00:43:46,760 --> 00:43:49,110
然后它会堵塞
在任何用户调用。

984
00:43:49,110 --> 00:43:51,450
>> 所以这是一个例子是什么
计算机科学家会

985
00:43:51,450 --> 00:43:55,090
调用抽象或功能
分解，这只是

986
00:43:55,090 --> 00:43:58,110
花哨的方式saying--是，如果
你喜欢这个高层次的想法，

987
00:43:58,110 --> 00:44:01,569
像我想功能，
打印某人的名字，绝对是你

988
00:44:01,569 --> 00:44:04,360
可以从字面上写的printf然后
通过在你想要的参数，

989
00:44:04,360 --> 00:44:07,340
并计划将工作，
因为它有自周三。

990
00:44:07,340 --> 00:44:10,510
但是，你可以开始抽象掉
打印名的概念。

991
00:44:10,510 --> 00:44:13,270
你可以给它一个名字，
像PrintName，和这

992
00:44:13,270 --> 00:44:15,280
这种想法从0周分层的。

993
00:44:15,280 --> 00:44:19,910
>> 从今往后，我和你不必知道
或护理PrintName是如何实现的。

994
00:44:19,910 --> 00:44:22,470
是的，它使用printf的，也许它
不，谁知道什么用？

995
00:44:22,470 --> 00:44:23,410
谁在乎？

996
00:44:23,410 --> 00:44:26,034
现在，我说在这里，
而不是到这里的。

997
00:44:26,034 --> 00:44:28,700
事实上，作为我们的计划获得
更加先进和复杂，

998
00:44:28,700 --> 00:44:32,550
我们将继续采取理所当然
较低级别的拼图存在。

999
00:44:32,550 --> 00:44:34,780
因为我们写了他们
或者别人没有，所以

1000
00:44:34,780 --> 00:44:36,910
我们可以再建在它们上面。

1001
00:44:36,910 --> 00:44:39,430
让我们来看看这个
变型，功能之一。

1002
00:44:39,430 --> 00:44:41,780
>> 所以这一块是一个有点多
先进的，但事实证明，

1003
00:44:41,780 --> 00:44:44,570
在CS50的图书馆，
这里只有一个调用getInt功能。

1004
00:44:44,570 --> 00:44:47,720
我们没有想到，几年前，到
实现GetPositiveInt功能。

1005
00:44:47,720 --> 00:44:50,970
这是一个有点恼人，因为如果
你们正在编写一个程序，其中

1006
00:44:50,970 --> 00:44:53,325
你想获得一个积极的
从用户的整数，

1007
00:44:53,325 --> 00:44:55,010
你完全可以使用调用getInt。

1008
00:44:55,010 --> 00:44:57,840
你完全可以用检查
条件，也许一个循环

1009
00:44:57,840 --> 00:45:00,320
如果int是更大
比0和骂的用户

1010
00:45:00,320 --> 00:45:02,699
如果他或她不给
你正数。

1011
00:45:02,699 --> 00:45:04,740
但是，让我们建立这个
建筑挡住自己，一，

1012
00:45:04,740 --> 00:45:06,555
定制刮片，如果你愿意。

1013
00:45:06,555 --> 00:45:08,680
我将有一个程序
在这里，最终，我

1014
00:45:08,680 --> 00:45:11,780
希望能够调用
GetPositiveInt，我想成为

1015
00:45:11,780 --> 00:45:14,200
能够打印出什么那int是。

1016
00:45:14,200 --> 00:45:16,240
但是，这是现在的抽象化了。

1017
00:45:16,240 --> 00:45:19,050
它只是被赋予了很高的水平
名称它做什么，

1018
00:45:19,050 --> 00:45:21,780
这是美妙的，因为它是
非常直观，现在读。

1019
00:45:21,780 --> 00:45:24,710
如果我做不在乎什么是底下
引擎盖，让我向下滚动。

1020
00:45:24,710 --> 00:45:27,140
这是一个有点吓人
在第一，尤其

1021
00:45:27,140 --> 00:45:29,470
如果这是你的第一个程序，
但让我们一起来看看。

1022
00:45:29,470 --> 00:45:32,860
>> 我不再说的，无效的，
因为事实证明功能，

1023
00:45:32,860 --> 00:45:34,777
就像GetString的，可
返回一个值给我。

1024
00:45:34,777 --> 00:45:36,610
他们不只是有
打印到屏幕上，

1025
00:45:36,610 --> 00:45:38,410
他们实际上可以手
我的东西回来。

1026
00:45:38,410 --> 00:45:41,535
和而PrintName之前，
我没回来需要什么。

1027
00:45:41,535 --> 00:45:44,160
我需要的副作用
东西显示在屏幕上，

1028
00:45:44,160 --> 00:45:46,570
但我并不需要一个人
递给我的东西回来。

1029
00:45:46,570 --> 00:45:48,840
这里，与GetPositiveInt，
像调用getInt，

1030
00:45:48,840 --> 00:45:50,640
我想交到东西回来。

1031
00:45:50,640 --> 00:45:53,220
所以我说不是的，无效的，
在线路23，但整型，

1032
00:45:53,220 --> 00:45:55,570
它说，该功能
我正在写，

1033
00:45:55,570 --> 00:45:58,860
称为GetPositiveInt是要
递给我回一个整数，没有什么，

1034
00:45:58,860 --> 00:45:59,890
不作废。

1035
00:45:59,890 --> 00:46:03,280
>> 同时，要采取不
投入，所以我，善良，推翻它。

1036
00:46:03,280 --> 00:46:08,280
我不给GetPositiveInt任何
输入时，我希望它给我的输出。

1037
00:46:08,280 --> 00:46:09,800
然后现在会发生什么？

1038
00:46:09,800 --> 00:46:11,640
因此，这里就是我可以声明一个变量。

1039
00:46:11,640 --> 00:46:15,090
我一直在循环之外做了，
对于原因，我们最终会看到，

1040
00:46:15,090 --> 00:46:17,700
但是这只是给
我的32位调用，N，

1041
00:46:17,700 --> 00:46:20,952
我已经预先确定
他们存储的整数。

1042
00:46:20,952 --> 00:46:23,660
而下面这一点，做while结构，
这就是为什么它是非常有用的。

1043
00:46:23,660 --> 00:46:26,700
从字面上做到这一点，
而n小于1。

1044
00:46:26,700 --> 00:46:28,030
因此，让我们看看会发生什么。

1045
00:46:28,030 --> 00:46:30,760
我打印出来，请
给我一个积极的INT。

1046
00:46:30,760 --> 00:46:34,300
然后我得到一个int，使用CS50的
功能与存储在n个。

1047
00:46:34,300 --> 00:46:38,990
>> 然后，什么样的代码行可能
下一个被执行，逻辑？

1048
00:46:38,990 --> 00:46:41,890
哪条线是多少？

1049
00:46:41,890 --> 00:46:42,571
是啊，所以31。

1050
00:46:42,571 --> 00:46:45,320
你不会知道，直到你
被告知或排序的推断是，

1051
00:46:45,320 --> 00:46:45,986
但是这是真的。

1052
00:46:45,986 --> 00:46:48,280
不言而喻从上到下
然后不断重复。

1053
00:46:48,280 --> 00:46:55,840
所以，如果我已经输​​入中说，数
负1，为n比1负少？

1054
00:46:55,840 --> 00:46:56,340
是啊。

1055
00:46:56,340 --> 00:46:58,470
因为负1小于1。

1056
00:46:58,470 --> 00:46:59,510
那么会发生什么情况？

1057
00:46:59,510 --> 00:47:03,260
我要做到这一点
而n是小于1，

1058
00:47:03,260 --> 00:47:05,760
所以我打算回去线28。

1059
00:47:05,760 --> 00:47:09,530
>> 而每一个时间 - 让我们运行this--
让功能1编译它，

1060
00:47:09,530 --> 00:47:11,340
现在点斜线功能1。

1061
00:47:11,340 --> 00:47:14,280
如果我型负1，这是
要保持吼我

1062
00:47:14,280 --> 00:47:17,530
直到我合作，因为每个
我的输入小于1

1063
00:47:17,530 --> 00:47:20,070
如果它而小于1，
我将继续这样做。

1064
00:47:20,070 --> 00:47:24,240
如果我终于给它一些像50，
值得庆幸的是，它说，感谢50。

1065
00:47:24,240 --> 00:47:24,970
为什么呢？

1066
00:47:24,970 --> 00:47:30,640
因为只要n是不小于
1，我停止陷在这个循环中，

1067
00:47:30,640 --> 00:47:33,840
而这种新的关键字的今天，
返回时，从字面上做到这一点。

1068
00:47:33,840 --> 00:47:36,800
所以，我刚刚实施，在
感，GetString的相当于，

1069
00:47:36,800 --> 00:47:40,590
在那里我递回
不管是谁用我的，一定的价值。

1070
00:47:40,590 --> 00:47:42,820
它并不必须是
一个字符串，它是一个int。

1071
00:47:42,820 --> 00:47:44,990
因此，一个简单，快捷
举例来说，但我们会很快

1072
00:47:44,990 --> 00:47:47,930
看到一些更复杂
版本还在。

1073
00:47:47,930 --> 00:47:53,882
事实上，让我们来看看一个
数字1，这是所谓return.c。

1074
00:47:53,882 --> 00:47:55,590
而这其中实际上
简单一点。

1075
00:47:55,590 --> 00:47:59,010
因此，在这个方案的目的
life--让我们编译并运行它，

1076
00:47:59,010 --> 00:48:03,090
所以要回报，点
斜线，return--通知

1077
00:48:03,090 --> 00:48:05,530
程序简单立方体的价值2。

1078
00:48:05,530 --> 00:48:08,410
它是非常愚蠢的，这是很难
代码，它没有采取任何投入，

1079
00:48:08,410 --> 00:48:12,220
但它确实说明另一个
我写我自己的功能。

1080
00:48:12,220 --> 00:48:15,760
所以在这里，我宣布一个
可变的，所谓的类型为int x，，

1081
00:48:15,760 --> 00:48:17,840
等于数字2，
完全是任意的。

1082
00:48:17,840 --> 00:48:19,530
这仅仅是一些蓬松打印。

1083
00:48:19,530 --> 00:48:23,070
它说，x是现在，这样的和
这样，多维数据点点点。

1084
00:48:23,070 --> 00:48:26,390
而神奇的是显然的第21行。

1085
00:48:26,390 --> 00:48:30,120
我打电话调用的函数，立方体，
我交给它的一张纸

1086
00:48:30,120 --> 00:48:32,890
用数字2写在上面，
和什么样的价值，数学，

1087
00:48:32,890 --> 00:48:34,860
我想出来的吗？

1088
00:48:34,860 --> 00:48:36,570
正如完整性检查？

1089
00:48:36,570 --> 00:48:37,070
8。

1090
00:48:37,070 --> 00:48:37,570
对？

1091
00:48:37,570 --> 00:48:40,160
我想2立方回，2〜
3的力量，所以8回。

1092
00:48:40,160 --> 00:48:42,570
>> 那么，是立方体实现？

1093
00:48:42,570 --> 00:48:44,349
好吧，发现它在这里实现了。

1094
00:48:44,349 --> 00:48:47,140
就如同之前，从逻辑上讲，
即使语法可能是

1095
00:48:47,140 --> 00:48:49,320
很新，你们中许多人，
我想这个功能

1096
00:48:49,320 --> 00:48:51,780
递给我回来的片
纸，上面有一个int。

1097
00:48:51,780 --> 00:48:53,990
所以，我有一个int，该
名字是随意，

1098
00:48:53,990 --> 00:48:55,530
可方便地称为立方体。

1099
00:48:55,530 --> 00:48:58,430
输入到它，是n
整型，所以这是

1100
00:48:58,430 --> 00:49:00,800
我怎么可以通过在数
2上一张纸。

1101
00:49:00,800 --> 00:49:03,910
然后事实证明C支持
数学，所以你不用X的的时间，

1102
00:49:03,910 --> 00:49:06,680
你只需要使用星号
乘法。

1103
00:49:06,680 --> 00:49:11,070
而这个返回n次n次
N，这是一个简单的立方值。

1104
00:49:11,070 --> 00:49:12,840
>> 那么，我们要与这一切？

1105
00:49:12,840 --> 00:49:14,570
这绝对是一个
旋风之旅，放心，

1106
00:49:14,570 --> 00:49:16,410
在超级节
而在问题设置1，

1107
00:49:16,410 --> 00:49:18,368
你可以通过走
这一切全愈。

1108
00:49:18,368 --> 00:49:22,490
而在问题设置1，我们将过渡
从头开始的图形世界

1109
00:49:22,490 --> 00:49:25,640
到更多的东西命令行
在C.但我们会汲取灵感

1110
00:49:25,640 --> 00:49:27,680
从此这里的游戏
从昔日的，其中，

1111
00:49:27,680 --> 00:49:31,591
使用C和的标准版
p将您将实现马里奥的金字塔。

1112
00:49:31,591 --> 00:49:34,340
而在的黑客版
p将，如果你选择选举，

1113
00:49:34,340 --> 00:49:38,280
您将实现多一点
有两个高峰挑战金字塔。

1114
00:49:38,280 --> 00:49:41,239
您还可以实施
算法，贪婪算法。

1115
00:49:41,239 --> 00:49:43,030
原来有
一些有趣的逻辑

1116
00:49:43,030 --> 00:49:45,640
过程背后
运行出纳站

1117
00:49:45,640 --> 00:49:47,410
实际上交给
有人背的变化。

1118
00:49:47,410 --> 00:49:50,410
有一种算法，是相当
简单的，你甚至可能

1119
00:49:50,410 --> 00:49:53,576
直观地把握，当你第一次读到
它 - 意识到这就是我一直

1120
00:49:53,576 --> 00:49:57,110
做我已经给了一些人的任何时间
钱back--，让你永远

1121
00:49:57,110 --> 00:50:00,679
最小化的数量
纸币或金属币

1122
00:50:00,679 --> 00:50:02,220
您正在移交给用户。

1123
00:50:02,220 --> 00:50:04,610
而这，当然，是引人注目
因为如果你去CVS或诸如此类的东西，

1124
00:50:04,610 --> 00:50:06,430
你不想成为手
一大堆的人

1125
00:50:06,430 --> 00:50:07,596
或者一大堆便士。

1126
00:50:07,596 --> 00:50:10,120
你想最少
硬币，大概，可能。

1127
00:50:10,120 --> 00:50:13,070
>> 最后，你也可以挑战
在水世界玩水

1128
00:50:13,070 --> 00:50:17,220
而实际上得到升值
对于流动速率之间的映射，

1129
00:50:17,220 --> 00:50:19,890
都喜欢，水淋浴，
到底有多少水被使用。

1130
00:50:19,890 --> 00:50:22,640
而其中的典故，
将这个片段在这里，

1131
00:50:22,640 --> 00:50:24,840
我们将结束对
短短60秒，即

1132
00:50:24,840 --> 00:50:29,070
描绘了一幅图片
低流量的淋浴喷头。

1133
00:50:29,070 --> 00:50:30,886
>> [视频回放]

1134
00:50:30,886 --> 00:50:31,385
-好吧。

1135
00:50:31,385 --> 00:50:32,774
我在这里得到的一切。

1136
00:50:32,774 --> 00:50:35,800
我得到了旋风F系列，
水润，Jetflow，斯德哥尔摩

1137
00:50:35,800 --> 00:50:37,660
Supersteam，你的名字。

1138
00:50:37,660 --> 00:50:39,265
>>  - 和你有什么建议？

1139
00:50:39,265 --> 00:50:40,460
>> -你要买什么？

1140
00:50:40,460 --> 00:50:41,300
>> -Power的人。

1141
00:50:41,300 --> 00:50:42,285
电源。

1142
00:50:42,285 --> 00:50:42,910
样丝克伍事件。

1143
00:50:42,910 --> 00:50:44,520
 - 这就是辐射。

1144
00:50:44,520 --> 00:50:46,335
-这是正确的。

1145
00:50:46,335 --> 00:50:48,275
 - 现在这是什么？

1146
00:50:48,275 --> 00:50:49,704
 - 这就是特种兵450。

1147
00:50:49,704 --> 00:50:50,620
我不卖这个。

1148
00:50:50,620 --> 00:50:51,700
>>  - 但是，这就是我们想要的。

1149
00:50:51,700 --> 00:50:52,680
这是一个突击队450。

1150
00:50:52,680 --> 00:50:53,882
>>  - 不相信我。

1151
00:50:53,882 --> 00:50:55,090
它仅用于马戏团。

1152
00:50:55,090 --> 00:50:56,512
这是大象。

1153
00:50:56,512 --> 00:50:59,356
>> -I'll支付任何费用。

1154
00:50:59,356 --> 00:51:01,252
>>  - 什么对杰里？

1155
00:51:01,252 --> 00:51:02,760
>>  - 他不能处理。

1156
00:51:02,760 --> 00:51:04,910
他细腻。

1157
00:51:04,910 --> 00:51:05,750
哦耶。

1158
00:51:05,750 --> 00:51:36,737

1159
00:51:36,737 --> 00:51:37,320
[结束播放]

1160
00:51:37,320 --> 00:51:37,700
大卫·马兰：好的。

1161
00:51:37,700 --> 00:51:38,820
那如果CS50。

1162
00:51:38,820 --> 00:51:40,050
我们会看到你下周。

1163
00:51:40,050 --> 00:51:45,910

1164
00:51:45,910 --> 00:51:49,029
>> 扬声器1：[？斯卡利？]，[？伊恩？]
只要这个尾奏项目，

1165
00:51:49,029 --> 00:51:50,362
你有什么家伙想出了？

1166
00:51:50,362 --> 00:51:51,990
>> 扬声器2：好了，我们已经给
它的各种思想，

1167
00:51:51,990 --> 00:51:53,250
我们认为，最好的办法用于：

1168
00:51:53,250 --> 00:51:53,660
>> 扬声器3：我？

1169
00:51:53,660 --> 00:51:54,326
>> 扬声器2：是的。

1170
00:51:54,326 --> 00:51:56,360
通过一切手段，其实。

1171
00:51:56,360 --> 00:51:59,425
>> 扬声器3：所以我觉得
我们可以总结一下我们的想法

1172
00:51:59,425 --> 00:52:05,450
对于一个word--什么的片尾。

1173
00:52:05,450 --> 00:52:08,950

1174
00:52:08,950 --> 00:52:10,409
>> 大卫·马兰：没事？

1175
00:52:10,409 --> 00:52:11,200
扬声器3：没有。

1176
00:52:11,200 --> 00:52:12,990
大卫·马兰：这是什么意思？

1177
00:52:12,990 --> 00:52:16,260
SPEAKER 3：片尾是关于什么。

1178
00:52:16,260 --> 00:52:21,720
扬声器2：嗯，我的意思是，在哲学，
我的意思是，没有什么是永远的东西。

1179
00:52:21,720 --> 00:52:24,200
扬声器1：所以what's--
有什么前提？

1180
00:52:24,200 --> 00:52:25,720
扬声器3：所以它就像生活。

1181
00:52:25,720 --> 00:52:26,680
行。

1182
00:52:26,680 --> 00:52:28,294
今天你做了什么？

1183
00:52:28,294 --> 00:52:31,811
>> 大卫·马兰：我站起来，有
早餐，来到工作。

1184
00:52:31,811 --> 00:52:34,056
>> 扬声器3：这是一个片尾曲。

1185
00:52:34,056 --> 00:52:36,806
扬声器2：但是，我的意思是，不应该
事情发生在他身上的the--

1186
00:52:36,806 --> 00:52:37,889
扬声器3：不，不，不，不。

1187
00:52:37,889 --> 00:52:40,220
什么都没发生。

1188
00:52:40,220 --> 00:52:42,910
>> 扬声器1：那么，为什么我们看什么？

1189
00:52:42,910 --> 00:52:46,956
>> 扬声器3：因为
这是一个尾奏的CS50。

1190
00:52:46,956 --> 00:52:48,652
>> 大卫·马兰：还没有。

1191
00:52:48,652 --> 00:52:49,151