1
00:00:00,000 --> 00:00:11,736

2
00:00:11,736 --> 00:00:16,626
>> [视频回放]

3
00:00:16,626 --> 00:00:19,410
>> 数学-A胜利
和机械技能

4
00:00:19,410 --> 00:00:23,270
这是伟大的新自动
计算器在哈佛大学。

5
00:00:23,270 --> 00:00:27,140
在数学复杂的问题
把通过机器以编码形式

6
00:00:27,140 --> 00:00:31,710
在磁带上精确地解决了
的时间分钟馏分所需

7
00:00:31,710 --> 00:00:32,819
人类计算。

8
00:00:32,819 --> 00:00:44,280

9
00:00:44,280 --> 00:00:48,220
为了加快各种形式的
数学和科学的研究，

10
00:00:48,220 --> 00:00:53,840
巨型机械的大脑会工作
美国海军直到战争结束。

11
00:00:53,840 --> 00:01:03,620

12
00:01:03,620 --> 00:01:06,570
>> [结束播放]

13
00:01:06,570 --> 00:01:08,590
>> DAVID J.马兰：这是CS50。

14
00:01:08,590 --> 00:01:10,590
过去是一个神奇的
的地方，但如果你曾经

15
00:01:10,590 --> 00:01:13,366
不知道这是什么设备
在哈佛科学中心，

16
00:01:13,366 --> 00:01:16,150
这的确是部分
哈佛大学的马克我，这是

17
00:01:16,150 --> 00:01:18,710
现陈列有
在过去的许多年。

18
00:01:18,710 --> 00:01:20,590
你会看到什么
嵌入问题集

19
00:01:20,590 --> 00:01:24,416
一个是幕后看看
在什么设备做了，确实，

20
00:01:24,416 --> 00:01:27,540
哈利·刘易斯教授，谁是谁非
计算机科学系在这里。

21
00:01:27,540 --> 00:01:29,440
因此，更多的是在短短位。

22
00:01:29,440 --> 00:01:33,990
>> 但是，今天我们开始转型
从上周到这一点，

23
00:01:33,990 --> 00:01:37,290
我们会带提
在这里，人们的照片

24
00:01:37,290 --> 00:01:38,630
这实际上是颇负盛名。

25
00:01:38,630 --> 00:01:42,270
有谁知道这是什么
这里是在屏幕上？

26
00:01:42,270 --> 00:01:43,880
至少根据神话。

27
00:01:43,880 --> 00:01:44,837
是啊。

28
00:01:44,837 --> 00:01:45,920
听众：第一个病毒。

29
00:01:45,920 --> 00:01:49,570
DAVID J.马兰：所以这是假想
在计算机中的第一实际错误。

30
00:01:49,570 --> 00:01:52,490
现在，在现实中字错误，
为程序中的错误，

31
00:01:52,490 --> 00:01:55,250
已经伴随我们一段
时间在物理世界中，

32
00:01:55,250 --> 00:01:58,190
这是第一个
记录的时间，其中确实有人

33
00:01:58,190 --> 00:02:02,280
弹拨大蛾子出来的标志
II计算机，将其放在粘合剂，

34
00:02:02,280 --> 00:02:05,006
然后记录了它
作为第一个已知的bug

35
00:02:05,006 --> 00:02:06,630
到其实已经发现了身体。

36
00:02:06,630 --> 00:02:10,104
所以这样被输入
这为今天的绝杀。

37
00:02:10,104 --> 00:02:12,020
从去年的一​​切
每周在网上提供。

38
00:02:12,020 --> 00:02:14,840
特别是资源，你可能
不一定注意到，特别是

39
00:02:14,840 --> 00:02:15,881
如果来到这里的人。

40
00:02:15,881 --> 00:02:20,230
因此，教学研究员之一，每
一年做一个规范的集合票据，

41
00:02:20,230 --> 00:02:22,010
所以你不必守
你的头，试图

42
00:02:22,010 --> 00:02:24,410
抄写任何东西
这可能发生在这里上课。

43
00:02:24,410 --> 00:02:25,940
因此，认识到这些
所谓[？ Scribd？]注意事项

44
00:02:25,940 --> 00:02:29,350
在线，肯定是幻灯片和
我们在课堂上使用的源代码。

45
00:02:29,350 --> 00:02:31,436
我们充分文字成绩单
可用。

46
00:02:31,436 --> 00:02:34,310
所以，如果你依稀记得一些
长期，想看看它一点点

47
00:02:34,310 --> 00:02:37,280
更容易，实现所有
那是在线搜索。

48
00:02:37,280 --> 00:02:38,930
除了演练为好。

49
00:02:38,930 --> 00:02:42,710
事实上，今天我们首先来看看
较低级别的编程语言，

50
00:02:42,710 --> 00:02:45,290
很快就被我们所知道的
为C，这是很容易

51
00:02:45,290 --> 00:02:48,820
以经过短短几分迷路
片刻时间，然后进行排序奇迹

52
00:02:48,820 --> 00:02:52,370
我们如何真正得到了一些
复杂的例子，从最简单的。

53
00:02:52,370 --> 00:02:54,975
所以，实现我们的樱桃
挑类中的一些中

54
00:02:54,975 --> 00:02:57,850
的代表性的例子，但
认识到这么多也

55
00:02:57,850 --> 00:03:01,140
可在网上这样你就可以工作
通过它按照自己的节奏，

56
00:03:01,140 --> 00:03:02,950
然而，你最舒服。

57
00:03:02,950 --> 00:03:05,200
>> 但是当我们离开了与
这只是该计划。

58
00:03:05,200 --> 00:03:09,690
于是我点击绿色旗帜，
而这是什么节目呢？

59
00:03:09,690 --> 00:03:10,710
说，你好，世界。

60
00:03:10,710 --> 00:03:13,180
它使猫说
你好在他的小世界

61
00:03:13,180 --> 00:03:15,990
在顶部左侧
的划痕的用户界面。

62
00:03:15,990 --> 00:03:18,810
但是，我们开始引进
上周一些术语。

63
00:03:18,810 --> 00:03:23,614
因此，像这样的事情，我们叫什么？

64
00:03:23,614 --> 00:03:25,280
可能是什么通称呢？

65
00:03:25,280 --> 00:03:26,266
是啊。

66
00:03:26,266 --> 00:03:28,210
方法或声明。

67
00:03:28,210 --> 00:03:29,280
当然，这是一个动作。

68
00:03:29,280 --> 00:03:30,140
做这个。

69
00:03:30,140 --> 00:03:32,400
然而，有
其他形状划伤，

70
00:03:32,400 --> 00:03:35,360
除了这些所谓的
声明中，他们也

71
00:03:35,360 --> 00:03:38,221
像这样的事情，我们叫什么？

72
00:03:38,221 --> 00:03:38,720
是啊。

73
00:03:38,720 --> 00:03:39,634
这样一个循环。

74
00:03:39,634 --> 00:03:42,050
在这种情况下，这个事
重复序列，很明显，10倍。

75
00:03:42,050 --> 00:03:43,040
有一个永远的块。

76
00:03:43,040 --> 00:03:44,164
有一对夫妇他人。

77
00:03:44,164 --> 00:03:48,309
而今天我们要看看如何
翻译这一个更现代世界，

78
00:03:48,309 --> 00:03:50,850
如果你愿意，即使它
要乍一看

79
00:03:50,850 --> 00:03:52,024
要更加神秘。

80
00:03:52,024 --> 00:03:53,190
但这些确实循环。

81
00:03:53,190 --> 00:03:56,182
然后，我们喜欢的东西
这一点，其中有这样的形状，

82
00:03:56,182 --> 00:03:57,515
而且基本上问的问题。

83
00:03:57,515 --> 00:03:58,890
我们将其称为什么呢？

84
00:03:58,890 --> 00:03:59,762
>> 听众：布尔表达式。

85
00:03:59,762 --> 00:04:00,320
>> DAVID J.马兰：是的。

86
00:04:00,320 --> 00:04:01,340
布尔表达式。

87
00:04:01,340 --> 00:04:04,502
东西是真或
假，是或否，一个或零，

88
00:04:04,502 --> 00:04:05,960
但您要查看的世界。

89
00:04:05,960 --> 00:04:08,335
但是，我们叫那些布尔
表现形式，我们将它们插入

90
00:04:08,335 --> 00:04:09,900
为条件，或分支机构。

91
00:04:09,900 --> 00:04:12,170
和在世界
从无到有，一切都很好

92
00:04:12,170 --> 00:04:15,460
在其形状方面联锁，
如果它使逻辑意义的话，

93
00:04:15,460 --> 00:04:18,490
但你不必停留在只
做一件事有条件，

94
00:04:18,490 --> 00:04:20,450
你可以有一个谚语
岔路口

95
00:04:20,450 --> 00:04:24,040
做非此即彼，如果
条件是真还是假。

96
00:04:24,040 --> 00:04:26,040
然后，你会看到，
如果你还没有准备好，

97
00:04:26,040 --> 00:04:27,480
你甚至可以嵌套这些块。

98
00:04:27,480 --> 00:04:32,110
所以划痕生长填充形状
您可能要插入进去，

99
00:04:32,110 --> 00:04:35,330
这样你就可以真正表达最
你可能想要做的任何逻辑。

100
00:04:35,330 --> 00:04:38,220
>> 公告现在的几句话
对于在这里和纽黑文。

101
00:04:38,220 --> 00:04:39,370
所以切片从今天开始。

102
00:04:39,370 --> 00:04:42,120
该网址，这是在球场上的
网站，对于那些不熟悉的。

103
00:04:42,120 --> 00:04:43,970
段将是一个
机会相聚

104
00:04:43,970 --> 00:04:46,553
在一个更亲密的环境
比[？桑德斯？]允许，

105
00:04:46,553 --> 00:04:50,347
用10至20的同学用
助教在不同的轨道，

106
00:04:50,347 --> 00:04:51,930
和不同的速度，如果你选择。

107
00:04:51,930 --> 00:04:54,080
事实上，课程提供
不同的部分

108
00:04:54,080 --> 00:04:57,340
对于那些不太舒服，更
舒适，介于两者之间，

109
00:04:57,340 --> 00:04:59,860
和拇指这里的作用，是
有没有正式的定义，

110
00:04:59,860 --> 00:05:04,600
但如果你不舒服，
那种你知道的。

111
00:05:04,600 --> 00:05:07,470
你是一个勇敢一点对
踩着脚下，也许，回理念

112
00:05:07,470 --> 00:05:10,130
在课堂上，或显示
长达一个在部分之间。

113
00:05:10,130 --> 00:05:12,770
如果你因为你是编程
是六岁，更舒适，

114
00:05:12,770 --> 00:05:13,400
也许你。

115
00:05:13,400 --> 00:05:16,150
而如果它是一种胜负难料，
这正是之间的中

116
00:05:16,150 --> 00:05:17,190
就是要。

117
00:05:17,190 --> 00:05:18,410
>> 现在，在此期间，
一类这种规模，

118
00:05:18,410 --> 00:05:21,326
它需要我们相当长的一段时间，部分
每一个人，所以我们所谓的，

119
00:05:21,326 --> 00:05:24,030
超节，来了这
周末及下周初，

120
00:05:24,030 --> 00:05:26,570
所以看看在课程的网站
对于那些过程宽，

121
00:05:26,570 --> 00:05:28,610
并且还拍摄了那些
谁也无法使它们。

122
00:05:28,610 --> 00:05:33,470
而部分本身将启动
在本周三CS50零指标。

123
00:05:33,470 --> 00:05:35,880
习题集0已经是
在球场上的网站。

124
00:05:35,880 --> 00:05:40,010
并意识到你必须
9晚天这学期。

125
00:05:40,010 --> 00:05:43,240
所以这是从去年升级
今年，当我们有五晚了几天。

126
00:05:43,240 --> 00:05:46,210
>> 所以，如果你想知道，
我们有九习题集。

127
00:05:46,210 --> 00:05:53,200
你有九晚天，每个
你只能花一，每周上。

128
00:05:53,200 --> 00:05:56,089
这实际上使所有的
问题集将于周五公布，

129
00:05:56,089 --> 00:05:58,630
但我们的目标是把一个小
心理压力位

130
00:05:58,630 --> 00:06:01,100
你试图让
事情在周四

131
00:06:01,100 --> 00:06:03,960
因为你很快就会发现，
是好还是坏，最

132
00:06:03,960 --> 00:06:07,820
一切都在软件世界结束
以比预计的要长很多。

133
00:06:07,820 --> 00:06:10,620
因此，认为这是一种
机会帮助

134
00:06:10,620 --> 00:06:13,880
自己到周四目标，
但感到欣慰的是，是的，

135
00:06:13,880 --> 00:06:14,950
一切都将于周五公布。

136
00:06:14,950 --> 00:06:17,590
如果你提交他们
周四，这是美妙的。

137
00:06:17,590 --> 00:06:21,020
有没有奖励积分或额外
信用为满足这一最后期限。

138
00:06:21,020 --> 00:06:23,250
它的意思是只有一个拐杖。

139
00:06:23,250 --> 00:06:25,810
>> 和办公时间，无论是
在这里和在纽黑文，

140
00:06:25,810 --> 00:06:28,840
在人，如果你想
与我们的课程满足

141
00:06:28,840 --> 00:06:31,060
教学研究员和CA的援助。

142
00:06:31,060 --> 00:06:31,640
>> 好吧。

143
00:06:31,640 --> 00:06:33,110
所以，现在，让我们这个更真实。

144
00:06:33,110 --> 00:06:35,470
一时间它会启动
得到多一点神秘，但很

145
00:06:35,470 --> 00:06:37,310
迅速上周五和
下周我们将

146
00:06:37,310 --> 00:06:41,230
能够这样做大大超过
我们可以迄今在划痕。

147
00:06:41,230 --> 00:06:44,350
因此，我们推出了代码的最后
本周，尽管pictoral。

148
00:06:44,350 --> 00:06:45,620
这是拼图。

149
00:06:45,620 --> 00:06:48,800
我们形式化，这是
所谓源代码，

150
00:06:48,800 --> 00:06:50,330
但也没有什么样子的？

151
00:06:50,330 --> 00:06:52,550
那么，它看起来有点
这样的事情。

152
00:06:52,550 --> 00:06:55,410
而且，事实上，只是那种
逗，我们可以去与此有关。

153
00:06:55,410 --> 00:06:57,800
我要继续前进，
这里打开一个窗口，

154
00:06:57,800 --> 00:06:59,810
我只是要选择新的文件。

155
00:06:59,810 --> 00:07:03,200
而且我要保存此文件
因为像招呼C点。

156
00:07:03,200 --> 00:07:05,700
更重要的是选择
也就是说在短短的时刻。

157
00:07:05,700 --> 00:07:08,630
这是一个人怎么可能
去写一个程序。

158
00:07:08,630 --> 00:07:13,990
包括标准I / O点H，INT主要
虚空，然后打开大括号，关闭

159
00:07:13,990 --> 00:07:19,430
大括号，printf的招呼逗号世界，
反斜杠N，分号，保存，完成。

160
00:07:19,430 --> 00:07:19,930
行。

161
00:07:19,930 --> 00:07:21,670
我已经写了我的第一次
程序，但是它是怎么回事

162
00:07:21,670 --> 00:07:23,878
是难以置信腻味
因为当我真正

163
00:07:23,878 --> 00:07:27,352
运行，当然这个程序，
通过先写使招呼，

164
00:07:27,352 --> 00:07:30,310
然后斑点削减招呼，我们将
通过这个更加详细

165
00:07:30,310 --> 00:07:31,730
在一个时刻，这就是它所做的。

166
00:07:31,730 --> 00:07:33,270
不弹出打开的任何窗口。

167
00:07:33,270 --> 00:07:35,070
它不会做任何事情
特别花哨。

168
00:07:35,070 --> 00:07:38,830
它所做的是什么，我告诉它
这样做，但我们怎么去的？

169
00:07:38,830 --> 00:07:40,560
我们如何建立在那？

170
00:07:40,560 --> 00:07:43,430
好吧，让我们来介绍几个
不同的概念在这里。

171
00:07:43,430 --> 00:07:47,170
>> 所以之一，我们即将开始
使用被称为编译程序。

172
00:07:47,170 --> 00:07:51,470
编译器存在于Mac OS，Windows中，
Linux中，任何数目的操作系统的，

173
00:07:51,470 --> 00:07:54,540
我们会尽快为您介绍
环境，我们将使用，

174
00:07:54,540 --> 00:07:57,410
但一个编译器只是一般
术语，指的软件

175
00:07:57,410 --> 00:08:01,940
这需要源代码和
从它产生的目标代码。

176
00:08:01,940 --> 00:08:03,940
换句话说，如果
有作为输入源

177
00:08:03,940 --> 00:08:08,250
代码，像我刚才输入的，
它最终生成目标代码。

178
00:08:08,250 --> 00:08:11,780
代码和目标代码实际上只是
说它输出一个奇特的方式

179
00:08:11,780 --> 00:08:12,926
零的和一个人的。

180
00:08:12,926 --> 00:08:14,800
换言之，源
代码，即使它

181
00:08:14,800 --> 00:08:17,240
会显得有点神秘，
又有点不太友好

182
00:08:17,240 --> 00:08:19,590
比刮乍看之下，
它至少东西

183
00:08:19,590 --> 00:08:21,120
我们人类能理解。

184
00:08:21,120 --> 00:08:24,360
那种它看起来和听起来像
英语，即使它非常简洁。

185
00:08:24,360 --> 00:08:28,040
而在零的编程和
一个人的，因为我们的前辈不得不这样做，

186
00:08:28,040 --> 00:08:30,920
几年前，不是
特别有趣的挑战。

187
00:08:30,920 --> 00:08:33,710
然而，这就是
电脑还是可以理解的。

188
00:08:33,710 --> 00:08:37,010
因此，编译器会让我们从
源代码，目标代码。

189
00:08:37,010 --> 00:08:39,860
这就像用打开文件
编译器，当你保存它，

190
00:08:39,860 --> 00:08:41,419
你得到这些零和一。

191
00:08:41,419 --> 00:08:43,419
所以我们会看到怎么办
在短短的时刻。

192
00:08:43,419 --> 00:08:47,400
>> 但是，让我们现在试图提供一个
上周，这之间的桥梁，

193
00:08:47,400 --> 00:08:50,660
这样即使我们得到红
这类事情，大括号，

194
00:08:50,660 --> 00:08:54,100
和分号，和括号，并
所有这些智力有趣

195
00:08:54,100 --> 00:08:57,620
编程的各方面，这非常
可以理解早早就绊倒人组成，

196
00:08:57,620 --> 00:09:00,930
认识到，所有的思想
今天，是与上。

197
00:09:00,930 --> 00:09:03,975
所以最后，我们看到了这个例子
在这里，Hello World程序。

198
00:09:03,975 --> 00:09:07,500
好了，从今天开始，如果我们想
实施同样的计划，

199
00:09:07,500 --> 00:09:10,800
它会看起来
有点这样的事情。

200
00:09:10,800 --> 00:09:14,040
我们将长期INT什么才解释，
和主，和无效的，和所有的

201
00:09:14,040 --> 00:09:18,770
是，但至少我在这里看到
早已熟悉的Hello World。

202
00:09:18,770 --> 00:09:20,860
>> 同时，这样的事情
功能，打个招呼，

203
00:09:20,860 --> 00:09:23,570
很简单的将是一个
很简单的声明是这样的。

204
00:09:23,570 --> 00:09:26,930
PRINTF的hello world，一些
引用，用反斜杠，

205
00:09:26,930 --> 00:09:29,780
用分号，但
更多的来。

206
00:09:29,780 --> 00:09:34,066
循环，同时，这是一个循环，，
当然，说世界你好一辈子，

207
00:09:34,066 --> 00:09:36,690
而这个人会看起来
多一点在过去的怪异，

208
00:09:36,690 --> 00:09:39,530
但如果我说些什么
像，而真实的，我

209
00:09:39,530 --> 00:09:44,050
然后可以打印出世界，你好
一遍又一遍又一遍。

210
00:09:44,050 --> 00:09:46,660
然后，你可以种
的开始在这里推断，

211
00:09:46,660 --> 00:09:49,070
使用此约定
大括号是一种

212
00:09:49,070 --> 00:09:52,050
像拥抱
代码缩进行那里。

213
00:09:52,050 --> 00:09:55,840
代码的printf的行很像
黄色的一块拼图了上面。

214
00:09:55,840 --> 00:09:58,740
因此，我们不会说永远，
我们要说的，而真正的，

215
00:09:58,740 --> 00:10:01,020
但我们会看到这是为什么在短短的一点。

216
00:10:01,020 --> 00:10:04,210
>> 同时，如果我们有一个循环是这样，
你重复的东西是有限的地方

217
00:10:04,210 --> 00:10:07,730
数字时代，这一个了它的
要采取一些习惯

218
00:10:07,730 --> 00:10:12,820
，但它会说，对于int
我得到零，我不到10，我++，

219
00:10:12,820 --> 00:10:14,056
然后printf的一次。

220
00:10:14,056 --> 00:10:15,430
但是，将是格局。

221
00:10:15,430 --> 00:10:18,434
而对于那些你熟悉的
与AP计算机科学或Java，

222
00:10:18,434 --> 00:10:21,100
或任何数量的其他语言，
几乎所有这些构建体的

223
00:10:21,100 --> 00:10:23,820
迄今为止应该大多是熟悉的。

224
00:10:23,820 --> 00:10:24,680
>> 所以变量。

225
00:10:24,680 --> 00:10:29,270
所以这里有一个简单的划痕摘录
设置一个所谓的计数器为零的变量，

226
00:10:29,270 --> 00:10:33,150
然后永远说的计数器，
然后它改变由一个计数器。

227
00:10:33,150 --> 00:10:37,030
因此，它具有零启动，
再一，二，三。

228
00:10:37,030 --> 00:10:42,560
那么，怎么可能我们介绍，在
这种新的语言有点相似？

229
00:10:42,560 --> 00:10:45,460
诠释计数器等于
为零，而真实的，这

230
00:10:45,460 --> 00:10:48,100
与以前同样的想法
做事永远的，

231
00:10:48,100 --> 00:10:49,530
而我只是去给printf。

232
00:10:49,530 --> 00:10:53,310
而现在它变得有点怪，
％的我，但更多的是前来，

233
00:10:53,310 --> 00:10:55,140
但这些想法是完全一样的。

234
00:10:55,140 --> 00:10:58,820
我们刚才要坚持
计算机是语法

235
00:10:58,820 --> 00:11:00,010
将我们的需求。

236
00:11:00,010 --> 00:11:04,620
>> 布尔表达式，像
SX小于y或x除y以下，

237
00:11:04,620 --> 00:11:06,354
和y小于ž。

238
00:11:06,354 --> 00:11:09,270
这将看起来少了一些
这样，用括号只

239
00:11:09,270 --> 00:11:13,020
像数学中的好措施，只是
确保操作的顺序

240
00:11:13,020 --> 00:11:14,750
是因为我们打算。

241
00:11:14,750 --> 00:11:15,600
而现在，条件。

242
00:11:15,600 --> 00:11:21,220
因此，如果x小于y，表示x是少
比Y，否则，如果x大于Y，

243
00:11:21,220 --> 00:11:26,020
说x大于Y，否则
从逻辑上讲，x必须等于y。

244
00:11:26,020 --> 00:11:28,710
所以，你可能实现
像这样的划痕，

245
00:11:28,710 --> 00:11:31,230
或者你可能实现
它在这个语法。

246
00:11:31,230 --> 00:11:35,090
再次，花括号是种
给我们相同的形状拼图

247
00:11:35,090 --> 00:11:40,750
件，但语法，现在，也许是
开始跟着一些模式。

248
00:11:40,750 --> 00:11:42,910
>> 那么，是什么让我们在这里？

249
00:11:42,910 --> 00:11:45,260
所以我们当时在我们的主程序。

250
00:11:45,260 --> 00:11:47,930
让我们实际上，现在，
用它做什么。

251
00:11:47,930 --> 00:11:50,660
因此，在这种非常第一
行，我们看到犀利包括，

252
00:11:50,660 --> 00:11:53,160
标准I / O，点H，和
然后一些奇怪的角度

253
00:11:53,160 --> 00:11:57,330
括号低于。 INT主要
虚空，然后printf的世界你好。

254
00:11:57,330 --> 00:11:58,200
因此，只要采取的一个步骤。

255
00:11:58,200 --> 00:12:02,440
有人谁以前从未编程，
至少解释这些线中的一条。

256
00:12:02,440 --> 00:12:04,490
使用也许有些
上周的行话。

257
00:12:04,490 --> 00:12:06,942
什么是printf的，例如？

258
00:12:06,942 --> 00:12:07,442
是啊。

259
00:12:07,442 --> 00:12:08,410
>> 听众：[听不清]

260
00:12:08,410 --> 00:12:08,610
>> DAVID J.马兰：是的。

261
00:12:08,610 --> 00:12:11,380
这是一个函数，或者声明，
从上周的术语。

262
00:12:11,380 --> 00:12:13,470
而且它是一个行动
这在做什么。

263
00:12:13,470 --> 00:12:15,855
现在这个功能，或者
这种说法，确实

264
00:12:15,855 --> 00:12:17,550
它似乎需要一些类型的输入？

265
00:12:17,550 --> 00:12:20,080

266
00:12:20,080 --> 00:12:24,380
以及在何种意义呢它
似乎采取的输入，如果是的话？

267
00:12:24,380 --> 00:12:26,180
输入，请问我的意思？

268
00:12:26,180 --> 00:12:26,720
是啊。

269
00:12:26,720 --> 00:12:27,595
>> 听众：[听不清]

270
00:12:27,595 --> 00:12:30,565

271
00:12:30,565 --> 00:12:31,440
DAVID J.马兰：是的。

272
00:12:31,440 --> 00:12:34,890
所以划掉了一些拼图
在这里你可以参数化的。

273
00:12:34,890 --> 00:12:37,980
你可以告诉重复
阻止多少次重复，

274
00:12:37,980 --> 00:12:40,320
所以这是一个输入
排序，并就像划痕

275
00:12:40,320 --> 00:12:43,060
有一个白色的小占位符
你键入的数量，

276
00:12:43,060 --> 00:12:45,810
这样做，我们在此使用
文字世界括号

277
00:12:45,810 --> 00:12:49,910
给我们，圆形
在其中，我们可以将我们的输入。

278
00:12:49,910 --> 00:12:53,180
毕竟，几十年前
当这种语言，称为C，

279
00:12:53,180 --> 00:12:55,950
被发明没有人
预计这是我们的一员，

280
00:12:55,950 --> 00:12:59,420
这些若干年后，我们就
想要一个函数，打招呼。

281
00:12:59,420 --> 00:12:59,920
对？

282
00:12:59,920 --> 00:13:02,880
这将会是很好，如果有一个
拼图，或关键词，

283
00:13:02,880 --> 00:13:05,502
这就是所谓的打招呼，说
从字面上只是说你好。

284
00:13:05,502 --> 00:13:06,460
但是，我们不需要这样。

285
00:13:06,460 --> 00:13:09,320
我们可以有一些低得多
的水平，就像一个普通的打印

286
00:13:09,320 --> 00:13:12,760
命令，这需要投入，
并打印任何我们想要的。

287
00:13:12,760 --> 00:13:14,960
所以现在看到的格局
这将开始出现。

288
00:13:14,960 --> 00:13:19,310
开括号，括号接近是
显然拥抱输入，

289
00:13:19,310 --> 00:13:21,770
然后我看到双
报价两端。

290
00:13:21,770 --> 00:13:25,110
还有奇怪的反斜线
N，但希望现在你

291
00:13:25,110 --> 00:13:29,900
可以开始至少是想象
的printf正在采取某种形式的输入。

292
00:13:29,900 --> 00:13:31,850
还不如用户友好
从无到有，但它只是

293
00:13:31,850 --> 00:13:34,920
就像插在一定的价值已经出现。

294
00:13:34,920 --> 00:13:38,306
>> 好了，现在让我们来实际
做一些与此有关。

295
00:13:38,306 --> 00:13:40,930
所以，有些人可能知道，从
面前逛过类，

296
00:13:40,930 --> 00:13:42,638
与朋友聊天时，
对于许多年

297
00:13:42,638 --> 00:13:44,590
我们使用了一种叫做
该CS50设备。

298
00:13:44,590 --> 00:13:49,160
这是描述一个技术术语
称为虚拟机，这

299
00:13:49,160 --> 00:13:51,870
是一个软件，你的
前辈会下载关闭

300
00:13:51,870 --> 00:13:53,360
课程的网站上免费。

301
00:13:53,360 --> 00:13:56,550
他们还将免费下载一个
软件称为虚拟机管理程序，

302
00:13:56,550 --> 00:14:00,590
一些所谓的像VMware，
或VirtualBox的，或任意数量的

303
00:14:00,590 --> 00:14:04,450
其他工具，并在他们的Mac或PC
或者他们去年无论电脑

304
00:14:04,450 --> 00:14:06,620
而在过去的几年中，他们
将双击图标

305
00:14:06,620 --> 00:14:08,860
运行此软件
所谓的虚拟机管理程序。

306
00:14:08,860 --> 00:14:12,220
然后里面那个节目
他们会打开CS50设备。

307
00:14:12,220 --> 00:14:14,710
和效果是
无论是你的前辈

308
00:14:14,710 --> 00:14:17,780
在运行Mac OS或
Windows中，他或她再

309
00:14:17,780 --> 00:14:22,910
随后有一个新的窗口，他们的
屏幕上运行CS50的环境。

310
00:14:22,910 --> 00:14:27,370
因此，虚拟机可以让你运行一个
的另一个内的操作系统，

311
00:14:27,370 --> 00:14:28,785
而这正是我们所做的事情。

312
00:14:28,785 --> 00:14:31,410
纵观大多当然，我们的
使用称为操作系统

313
00:14:31,410 --> 00:14:34,070
Linux的，特别是
Ubuntu Linux操作系统，并且这

314
00:14:34,070 --> 00:14:37,590
在过去几年的一个非常好的方法
确保每个人都在使用过程中

315
00:14:37,590 --> 00:14:38,840
只是有相同的环境。

316
00:14:38,840 --> 00:14:41,339
你可以使用任何类型的
计算机你真正想要的。

317
00:14:41,339 --> 00:14:43,930
间的缺点，但是，
是它就像两个千兆字节

318
00:14:43,930 --> 00:14:45,480
下载这个东西。

319
00:14:45,480 --> 00:14:50,310
它并不一定工作超好上
人，他们的电脑，也许只有

320
00:14:50,310 --> 00:14:54,570
有这么RAM演出，或者，还是不
CPU速度的太多千兆赫，

321
00:14:54,570 --> 00:14:56,750
所以今年，
这个和其它原因，

322
00:14:56,750 --> 00:14:59,140
有，我们已经过渡
这种环境。

323
00:14:59,140 --> 00:15:03,730
所谓CS50 IDE，它是
基于开源软件，

324
00:15:03,730 --> 00:15:07,380
和支持的平台
一家名为Cloud9

325
00:15:07,380 --> 00:15:11,110
支持在欧洲，那
让我们有本质

326
00:15:11,110 --> 00:15:15,770
这完全一样的环境中
过去几年，但在所谓的云。

327
00:15:15,770 --> 00:15:17,532
>> 那么，什么是云计算？

328
00:15:17,532 --> 00:15:20,480
你可能已经点击
它在你的Mac或PC图标。

329
00:15:20,480 --> 00:15:22,210
什么是云计算？

330
00:15:22,210 --> 00:15:22,709
是吗？

331
00:15:22,709 --> 00:15:25,880

332
00:15:25,880 --> 00:15:26,780
大声一点。

333
00:15:26,780 --> 00:15:30,510

334
00:15:30,510 --> 00:15:31,010
是啊。

335
00:15:31,010 --> 00:15:33,770
它只是一堆电脑
其他地方存储数据和运行

336
00:15:33,770 --> 00:15:34,880
软件等。

337
00:15:34,880 --> 00:15:39,390
因此，它实际上只是这个词去
描述[的法律？可出租？]

338
00:15:39,390 --> 00:15:40,930
居住在其他地方的计算机。

339
00:15:40,930 --> 00:15:42,810
那你，你自己，
不一定拥有。

340
00:15:42,810 --> 00:15:45,256
所以，当你的数据，或者你
计划，是在云中，

341
00:15:45,256 --> 00:15:47,630
它只是意味着它是在人
其他地方的其他人的电脑，

342
00:15:47,630 --> 00:15:50,510
不，最有可能的，在你的
物理笔记本电脑或台式机。

343
00:15:50,510 --> 00:15:52,990
所以这就是CS50 IDE现在。

344
00:15:52,990 --> 00:15:55,670
>> 从此以后，你会去到一定
这将向您介绍网址

345
00:15:55,670 --> 00:16:00,090
要在问题设置1，后面的
周，将接着，在记录在，

346
00:16:00,090 --> 00:16:01,480
给你这样的环境。

347
00:16:01,480 --> 00:16:03,896
而就像刮了
涉及到几个不同的面板，

348
00:16:03,896 --> 00:16:06,030
这样做CS50的IDE有完全相同的。

349
00:16:06,030 --> 00:16:09,480
在左上方这里，你
要看到一个熟悉的文件浏览器。

350
00:16:09,480 --> 00:16:11,930
所以任何一个文件，你
投入这个环境

351
00:16:11,930 --> 00:16:13,346
只是要在那里列出。

352
00:16:13,346 --> 00:16:14,350
文件和文件夹。

353
00:16:14,350 --> 00:16:16,790
在这里顶，
你会看到一个地方

354
00:16:16,790 --> 00:16:18,420
在这里你可以真正编写代码。

355
00:16:18,420 --> 00:16:21,860
最初的C，后来在
长期在PHP和JavaScript，

356
00:16:21,860 --> 00:16:24,739
和，或许为最终
项目，Ruby或Java或Python的

357
00:16:24,739 --> 00:16:27,280
或任意数量的语言
在这种环境下的支持。

358
00:16:27,280 --> 00:16:30,130
它不是在所有绑
到CS50明确。

359
00:16:30,130 --> 00:16:33,390
>> 然后在这里的底部边角，
特别是对于那些更舒适，

360
00:16:33,390 --> 00:16:35,590
你有什么
所谓的终端窗口。

361
00:16:35,590 --> 00:16:38,770
而这个终端窗口允许
你执行任何命令你

362
00:16:38,770 --> 00:16:40,860
想在这个云环境。

363
00:16:40,860 --> 00:16:42,860
它可以让你安装
任何额外的软件

364
00:16:42,860 --> 00:16:46,810
你想要的，因为你所谓的
根或管理员权限。

365
00:16:46,810 --> 00:16:49,930
因此，换句话说，即使这
在云最终主持，

366
00:16:49,930 --> 00:16:52,400
尽管我们有
简化它在一定程度上

367
00:16:52,400 --> 00:16:57,110
默认情况下，从字面上介绍，
感谢Dan Armendariz环，和迪诺，

368
00:16:57,110 --> 00:17:01,070
和CS50的团队在丹·布拉德利
过去数月，一个不舒服

369
00:17:01,070 --> 00:17:05,140
模式隐藏了许多的
最初混乱的干扰。

370
00:17:05,140 --> 00:17:10,119
一切都存在于
代表一个典型的计算机系统

371
00:17:10,119 --> 00:17:12,319
你可能在现实世界中使用。

372
00:17:12,319 --> 00:17:15,640
>> 那么，这一切意味着，和
我们能真正用它做？

373
00:17:15,640 --> 00:17:19,124
让我们实际采取在偷看的程序。

374
00:17:19,124 --> 00:17:21,290
所以，我要打通
实际的环境在这里，

375
00:17:21,290 --> 00:17:23,894
这仅仅是我们的Chrome浏览器
浏览器，它可以是火狐，

376
00:17:23,894 --> 00:17:26,640
可能是IE浏览器，
或一些其他的浏览器为好。

377
00:17:26,640 --> 00:17:28,400
它的全部筛选这里的时刻。

378
00:17:28,400 --> 00:17:31,580
我想实际挑逗
除了这是什么节目了。

379
00:17:31,580 --> 00:17:36,170
因此，让我们来看看，通过放大了
顶部，我做什么，我怎么来到这里。

380
00:17:36,170 --> 00:17:38,315
因此，这里的这些精确
同一行的代码。

381
00:17:38,315 --> 00:17:40,440
因此，这是语句，
正如你前面提到的。

382
00:17:40,440 --> 00:17:42,580
该功能打招呼。

383
00:17:42,580 --> 00:17:45,870
大括号，在
四号线和六号线，

384
00:17:45,870 --> 00:17:49,290
大概是一种包络
该行把它关联

385
00:17:49,290 --> 00:17:50,890
我的节目的本质。

386
00:17:50,890 --> 00:17:54,890
所以实际上，这个关键字为主，
这是在那里上三线，

387
00:17:54,890 --> 00:17:59,450
你能想到的，作为等价物
的，当绿旗点击，

388
00:17:59,450 --> 00:18:01,080
阻止划伤。

389
00:18:01,080 --> 00:18:05,280
所以，这就是我们这里有，是当
绿旗点击，打印，或者说，

390
00:18:05,280 --> 00:18:06,700
你好世界。

391
00:18:06,700 --> 00:18:11,210
>> 但是，让我们来猜测，现在，在什么
这第一个，更神秘的线，是。

392
00:18:11,210 --> 00:18:15,100
夏普包括，开成角
支架，标准I / O点H，

393
00:18:15,100 --> 00:18:17,320
关闭尖括号。

394
00:18:17,320 --> 00:18:19,850
什么，也许这样做，
特别是如果你编程

395
00:18:19,850 --> 00:18:21,390
之前在某些其它语言。

396
00:18:21,390 --> 00:18:21,890
是吗？

397
00:18:21,890 --> 00:18:22,765
>> 听众：[听不清]

398
00:18:22,765 --> 00:18:25,095

399
00:18:25,095 --> 00:18:25,970
DAVID J.马兰：是的。

400
00:18:25,970 --> 00:18:26,470
没错。

401
00:18:26,470 --> 00:18:29,455
因此，这是给你访问
图书馆，可以这么说的功能。

402
00:18:29,455 --> 00:18:31,830
和函数库是
功能别人

403
00:18:31,830 --> 00:18:34,406
中写道，无论是近期
还是很久以前，这样你

404
00:18:34,406 --> 00:18:35,780
不必推倒重来。

405
00:18:35,780 --> 00:18:39,020
举例来说，我们不这样做
要知道，在2015年，

406
00:18:39,020 --> 00:18:42,280
如何编写代码，这使
字符我的屏幕上。

407
00:18:42,280 --> 00:18:44,820
别人已经想通了
用printf函数

408
00:18:44,820 --> 00:18:47,280
这样我可以排序的抽象
远离，或层

409
00:18:47,280 --> 00:18:49,350
之上他或她的
代码，而现在只取

410
00:18:49,350 --> 00:18:52,760
理所当然地认为，任何程序我写的
可以打印东西到屏幕上。

411
00:18:52,760 --> 00:18:58,150
因此，在第一步中这第一行
包括所谓的头文件

412
00:18:58,150 --> 00:18:59,980
为标准库。

413
00:18:59,980 --> 00:19:02,630
所以看到的，在语言
这是我们现在工作

414
00:19:02,630 --> 00:19:05,010
有一个标准库
有很多的功能。

415
00:19:05,010 --> 00:19:07,240
PRINTF就是其中之一，和
该代码的第一行

416
00:19:07,240 --> 00:19:10,040
指给我的访问
这些功能，让我

417
00:19:10,040 --> 00:19:12,300
不必重新发明该车轮。

418
00:19:12,300 --> 00:19:15,940
>> 现在，让我们去下面的窗口
做正是我以前那样。

419
00:19:15,940 --> 00:19:18,520
刚才，当我
通过代码呼啸，

420
00:19:18,520 --> 00:19:24,540
打字出来的第一次，
我很快打字，让你好。

421
00:19:24,540 --> 00:19:28,250
那是什么一回事，你会猜到的？

422
00:19:28,250 --> 00:19:29,150
我到底在做什么？

423
00:19:29,150 --> 00:19:29,649
是吗？

424
00:19:29,649 --> 00:19:31,810

425
00:19:31,810 --> 00:19:32,310
没关系。

426
00:19:32,310 --> 00:19:32,970
没关系。

427
00:19:32,970 --> 00:19:33,492
是啊。

428
00:19:33,492 --> 00:19:34,450
听众：编译它。

429
00:19:34,450 --> 00:19:34,700
DAVID J.马兰：是的。

430
00:19:34,700 --> 00:19:35,770
这只是编译它。

431
00:19:35,770 --> 00:19:36,270
对？

432
00:19:36,270 --> 00:19:39,280
即使这是完全不熟悉
给你，这是相当英语等。

433
00:19:39,280 --> 00:19:41,155
这当然不是零
和的，所以我还是

434
00:19:41,155 --> 00:19:44,220
需要通过所谓的运行它
程序，编译器，这是怎么回事

435
00:19:44,220 --> 00:19:46,060
把它作为输入，产生输出。

436
00:19:46,060 --> 00:19:48,270
至少，就目前而言，
这个Linux环境，

437
00:19:48,270 --> 00:19:51,030
但这不是先决条件，
这仅仅是我们将开始，

438
00:19:51,030 --> 00:19:53,960
你一般互动
计算机系统这样的

439
00:19:53,960 --> 00:19:55,770
由一个所谓的命令行。

440
00:19:55,770 --> 00:19:57,790
因此，与闪烁
及时和你的键盘，

441
00:19:57,790 --> 00:20:01,630
并没有那么多你的鼠标，而不是
如此多的窗口和图标和菜单，

442
00:20:01,630 --> 00:20:02,980
而一切都是文字。

443
00:20:02,980 --> 00:20:06,180
而且即使这样的感觉，在第一
一目了然，也许，就像一个退步，

444
00:20:06,180 --> 00:20:08,437
它实际上是一个更
强大的表达方式

445
00:20:08,437 --> 00:20:10,270
控制计算机的
尤其是你，

446
00:20:10,270 --> 00:20:12,950
自己，变得更
舒适的少。

447
00:20:12,950 --> 00:20:16,790
这将让你做了很多
不仅仅是微软更多的事情

448
00:20:16,790 --> 00:20:20,390
或者苹果可以让你做
他们的图形操作系统。

449
00:20:20,390 --> 00:20:23,270
>> 所以，当我按下回车键，现在，
什么也没发生这一次

450
00:20:23,270 --> 00:20:25,960
因为很明显的
节目你好是最新的。

451
00:20:25,960 --> 00:20:28,250
什么是命令
我跑了之后呢？

452
00:20:28,250 --> 00:20:32,370
点斜线打招呼，你好世界。

453
00:20:32,370 --> 00:20:34,350
现在，让我们退一步
回来只是一瞬间。

454
00:20:34,350 --> 00:20:39,510
事实证明，让你好只是一个
编译程序的简化的方式。

455
00:20:39,510 --> 00:20:41,670
让我们只是介绍
一块行话，

456
00:20:41,670 --> 00:20:43,470
但随后离开
从它，因为它不是

457
00:20:43,470 --> 00:20:46,640
那么有趣
对于今天的目的。

458
00:20:46,640 --> 00:20:51,000
我们要开始使用编译器
被称为铛，为C语言。

459
00:20:51,000 --> 00:20:54,280
这是所运行的只是一个程序
就像我们在命令行上。

460
00:20:54,280 --> 00:20:56,580
所以，如果我想
编译一个程序，我

461
00:20:56,580 --> 00:21:00,790
已经写在一个叫你好点文件
C，我从字面上只需要输入铛你好Ç

462
00:21:00,790 --> 00:21:02,100
进入。

463
00:21:02,100 --> 00:21:04,880
>> 有趣的是，
由于历史的原因，

464
00:21:04,880 --> 00:21:07,750
如果我不指定
该方案的名称

465
00:21:07,750 --> 00:21:11,690
我想输出，如果我不
对于那些零指定文件名

466
00:21:11,690 --> 00:21:14,990
和的，很奇怪
公约获得通过年前

467
00:21:14,990 --> 00:21:17,390
它觉得那种一
在当时很好的答案，

468
00:21:17,390 --> 00:21:21,650
那么让我们来只是随意调用
第一个程序，我们编译一个点出来。

469
00:21:21,650 --> 00:21:22,900
一个是第一位的字母。

470
00:21:22,900 --> 00:21:23,920
出，它的输出。

471
00:21:23,920 --> 00:21:26,210
因此，我们将调用程序
默认情况下，点了。

472
00:21:26,210 --> 00:21:29,550
这很好，因为如果我想
基于此文本运行程序

473
00:21:29,550 --> 00:21:33,590
环境，我只需要输入
点斜线点了进去。

474
00:21:33,590 --> 00:21:35,250
它会像之前一样，运行。

475
00:21:35,250 --> 00:21:36,880
因此，让我们看到了真正的快速。

476
00:21:36,880 --> 00:21:40,370
>> 所以，如果我回到我的
在CS50 IDE的源代码，

477
00:21:40,370 --> 00:21:47,860
我不是这样做，铛你好婴儿床
c输入，通知，似乎什么都没有发生，

478
00:21:47,860 --> 00:21:49,790
但几乎总是在
这个Linux环境，

479
00:21:49,790 --> 00:21:53,310
没事的时候不好似乎发生，那
意味着好东西居然发生了。

480
00:21:53,310 --> 00:21:56,270
如果您没有看到错误
消息，一切都可能是很好。

481
00:21:56,270 --> 00:22:01,930
事实上，如果我现在做点斜线点
出来进去，我跑我的相同的程序。

482
00:22:01,930 --> 00:22:04,610
我仍然有hello程序
从早期的，因为事实上，它是

483
00:22:04,610 --> 00:22:07,430
将这么多漂亮只是
键入make，而不是记忆

484
00:22:07,430 --> 00:22:10,240
这些咒语
命令，但让我们看看如何

485
00:22:10,240 --> 00:22:12,890
可能会改善在此，仍然。

486
00:22:12,890 --> 00:22:15,340
>> 所以，这是命令
编译代码。

487
00:22:15,340 --> 00:22:19,100
这是运行命令
此后编译代码。

488
00:22:19,100 --> 00:22:20,546
我怎么可以指定一个文件名？

489
00:22:20,546 --> 00:22:22,670
那么就让我们介绍
多一个行话。

490
00:22:22,670 --> 00:22:24,461
当你在此
基于文本的环境，

491
00:22:24,461 --> 00:22:27,400
你会想指定
东西叫做命令行参数。

492
00:22:27,400 --> 00:22:31,380
这是说只是一种奇特的方式，
换句话说在提示符

493
00:22:31,380 --> 00:22:33,860
调整的行为，无论
计划你正在运行。

494
00:22:33,860 --> 00:22:37,320
那么具体的我节目
运行时，通过输入名称铛，

495
00:22:37,320 --> 00:22:38,504
被称为锵的计划。

496
00:22:38,504 --> 00:22:40,920
因此，这是和老同学
中双击相当于

497
00:22:40,920 --> 00:22:42,860
在Microsoft Word或
有些程序的图标。

498
00:22:42,860 --> 00:22:46,360
我不是只键入其名，
但在这个版本的命令，

499
00:22:46,360 --> 00:22:51,334
然后，我有几许O空间
你好你好空间C点。

500
00:22:51,334 --> 00:22:53,500
所以，即使你从来没有
之前效力于这个世界上，

501
00:22:53,500 --> 00:22:58,160
只是采取一种猜测是什么
不划线Ø招呼吗？

502
00:22:58,160 --> 00:23:00,620
或者，究竟说明了什么铛做什么？

503
00:23:00,620 --> 00:23:01,386
是啊。

504
00:23:01,386 --> 00:23:02,455
>> 听众：[听不清]

505
00:23:02,455 --> 00:23:03,330
DAVID J.马兰：是的。

506
00:23:03,330 --> 00:23:08,614
它只是设置文件的输出为
你好，而不是愚蠢的一个点出来。

507
00:23:08,614 --> 00:23:09,780
而且，事实上，让我们试试这个。

508
00:23:09,780 --> 00:23:14,250
所以，如果我现在做的，第一
让我们做到这一点，R M你好。

509
00:23:14,250 --> 00:23:15,590
这就是删除。

510
00:23:15,590 --> 00:23:18,450
它会说删除
普通文件你好，这

511
00:23:18,450 --> 00:23:22,210
是不必要的晦涩难懂，但它只是
手段你要删除的文件，

512
00:23:22,210 --> 00:23:23,230
我键入y（是）。

513
00:23:23,230 --> 00:23:27,340
同时注意，如果你在顶部一眼
离开了，但它并从那里消失。

514
00:23:27,340 --> 00:23:32,180
现在让我做铛破折号o和
我要继续前进，做打招呼，

515
00:23:32,180 --> 00:23:34,890
全部大写，你好点以下。

516
00:23:34,890 --> 00:23:37,775
现在，如果我做点斜线
你好，你会期待什么？

517
00:23:37,775 --> 00:23:41,240

518
00:23:41,240 --> 00:23:42,430
>> 也许这是区分大小写的。

519
00:23:42,430 --> 00:23:43,070
也许这不是。

520
00:23:43,070 --> 00:23:44,030
让我们来看看。

521
00:23:44,030 --> 00:23:45,230
没有这样的文件或目录。

522
00:23:45,230 --> 00:23:47,438
我们可以种作弊被
只是看着左上角。

523
00:23:47,438 --> 00:23:49,630
我是怎么明显
拯救计划的？

524
00:23:49,630 --> 00:23:51,070
所有帽你好。

525
00:23:51,070 --> 00:23:53,020
所以事实上，这是怎么回事
有所作为。

526
00:23:53,020 --> 00:23:54,540
所以，现在的hello world又回来了。

527
00:23:54,540 --> 00:23:56,969
现在，这是一切优秀和良好，
和所有非常令人麻木，

528
00:23:56,969 --> 00:23:59,760
以获取排序在这些陷入困境
细节，但理解它们

529
00:23:59,760 --> 00:24:00,500
是好的。

530
00:24:00,500 --> 00:24:02,675
>> 键入这些越来越多
长咒语

531
00:24:02,675 --> 00:24:05,980
不会是特别
好玩的，所以人们在世界

532
00:24:05,980 --> 00:24:08,260
发明了另一种方案，
几年前，叫

533
00:24:08,260 --> 00:24:12,190
做，那很简单
可以让你输入make，

534
00:24:12,190 --> 00:24:14,530
节目的名称
你想，使

535
00:24:14,530 --> 00:24:18,580
是聪明的，因为它会查看
当前文件夹，又名目录，

536
00:24:18,580 --> 00:24:21,440
如果你有一个文件
名为hello点C，

537
00:24:21,440 --> 00:24:25,800
这是它会编译文件
你到一个名为hello程序。

538
00:24:25,800 --> 00:24:29,950
因此，它是一个更简单的方法
做更隐蔽的命令

539
00:24:29,950 --> 00:24:30,800
我们做了前面。

540
00:24:30,800 --> 00:24:34,080
我们已经预先配置
CS50 IDE知道

541
00:24:34,080 --> 00:24:38,560
它应该做短线O和一些
其他标志，或命令行参数，

542
00:24:38,560 --> 00:24:40,670
过不了多久，我们就会看到。

543
00:24:40,670 --> 00:24:43,700
>> 但是，让我们现在实际上做
更有趣的东西。

544
00:24:43,700 --> 00:24:46,950
只是打字的hello world所有
时间是不是所有的引人注目。

545
00:24:46,950 --> 00:24:52,280
因此，让我继续前进，变革
这个节目，说，你好大卫。

546
00:24:52,280 --> 00:24:54,120
现在，我要在这里下去。

547
00:24:54,120 --> 00:24:57,360
我要继续前进，做让你好。

548
00:24:57,360 --> 00:25:00,652
并再次现在你看到的
使正显示出你的时间越长

549
00:25:00,652 --> 00:25:03,360
命令序列，它的
这样做是因为我们已经预先配置

550
00:25:03,360 --> 00:25:05,200
这样的说法，但我们
不用担心，现在

551
00:25:05,200 --> 00:25:10,735
它在做什么其他的比它
编译点斜线你好，你好世界。

552
00:25:10,735 --> 00:25:14,969

553
00:25:14,969 --> 00:25:15,510
怎么了？

554
00:25:15,510 --> 00:25:16,177
是啊。

555
00:25:16,177 --> 00:25:17,370
>> 听众：[听不清]

556
00:25:17,370 --> 00:25:18,203
>> DAVID J.马兰：是的。

557
00:25:18,203 --> 00:25:19,600
因此，noobie错误。

558
00:25:19,600 --> 00:25:22,394
我注意到这是超级微妙，
但这里的星号，在标签，

559
00:25:22,394 --> 00:25:25,060
只是意味着你没有保存它，
和浏览器和其他程序

560
00:25:25,060 --> 00:25:25,930
做到这一点的时候。

561
00:25:25,930 --> 00:25:27,939
因此控制s或命令
小号应该保存它。

562
00:25:27,939 --> 00:25:29,730
现在让我继续前进
并重新运行该程序。

563
00:25:29,730 --> 00:25:33,360

564
00:25:33,360 --> 00:25:34,260
重新编译。

565
00:25:34,260 --> 00:25:36,050
对，所以这是一个多步骤的过程。

566
00:25:36,050 --> 00:25:39,400
其中没有一个是特别复杂，
但任何时候我们更改文件，

567
00:25:39,400 --> 00:25:43,450
我们需要改变由此而来
零和一，和点斜线打招呼。

568
00:25:43,450 --> 00:25:43,950
哇。

569
00:25:43,950 --> 00:25:46,450
因此，这是很给人留下深刻印象
我们刚刚打印出这一点。

570
00:25:46,450 --> 00:25:48,360
让我们把事情
多一点活力，现在。

571
00:25:48,360 --> 00:25:52,280
>> 那么事实证明，那个喜欢
从无到有，C支持变量。

572
00:25:52,280 --> 00:25:54,790
而事实证明，如果你想
为具有可变，其存储，

573
00:25:54,790 --> 00:25:57,300
不是数字像我们
通常没有与划痕，

574
00:25:57,300 --> 00:26:01,300
但像一个字，或
短语或一个名字，你

575
00:26:01,300 --> 00:26:04,837
可以指定一个可变
是string类型。

576
00:26:04,837 --> 00:26:06,670
所以，我们会看到更多的
这些一会儿就好了，

577
00:26:06,670 --> 00:26:09,090
但事实证明，C，和
很多喜欢它的语言，

578
00:26:09,090 --> 00:26:11,240
有非常特殊类型的变量。

579
00:26:11,240 --> 00:26:13,810
这不只是喜欢代数，
你在哪里得到一个x，一个y和z

580
00:26:13,810 --> 00:26:16,940
而这些都只是始终
号码，在一种编程语言

581
00:26:16,940 --> 00:26:20,030
你可以存储数字，你可以
存储单个字符，

582
00:26:20,030 --> 00:26:24,619
你可以存储整个单词，你可以
存储整个图像，整个声音文件，

583
00:26:24,619 --> 00:26:25,160
和类似物。

584
00:26:25,160 --> 00:26:28,362
因此，我们需要指定哪些
我们的变量的类型。

585
00:26:28,362 --> 00:26:31,570
而按照惯例，我会打电话给我
变量s只是因为它的简洁，

586
00:26:31,570 --> 00:26:33,510
和s代表字符串。

587
00:26:33,510 --> 00:26:36,400
>> 然后，我要保存
这个变量的内部，

588
00:26:36,400 --> 00:26:39,570
就像有划痕
当我使用了一组块，

589
00:26:39,570 --> 00:26:41,950
我将使用
赋值运算符C，

590
00:26:41,950 --> 00:26:45,290
这很好地够平等
签署，但等号做到这一点。

591
00:26:45,290 --> 00:26:53,220
它移动的东西从右侧进入
表达式的左侧。

592
00:26:53,220 --> 00:26:57,170
所以我做了什么，要清楚
五号线，是我已经声明的变量。

593
00:26:57,170 --> 00:27:01,284
我已经告诉了电脑，给我
内存变量，称之为为s，

594
00:27:01,284 --> 00:27:03,950
并且事先知道我要去
要把一个串中它。

595
00:27:03,950 --> 00:27:05,950
而一个字符串仅仅是一个
字符序列。

596
00:27:05,950 --> 00:27:09,190
这是一个词，或一个短语或段落，
但它是一个字符序列。

597
00:27:09,190 --> 00:27:10,610
这不是数字。

598
00:27:10,610 --> 00:27:13,800
是什么字符串我将是
投入的变量？

599
00:27:13,800 --> 00:27:16,185
那么，显然引述
引文结束，“汉娜”。

600
00:27:16,185 --> 00:27:17,810
现在可以看到的新兴模式。

601
00:27:17,810 --> 00:27:19,260
有一个左手的表达。

602
00:27:19,260 --> 00:27:21,810
有一个右手的表情，
由等号分隔。

603
00:27:21,810 --> 00:27:24,390
而只是采取一种猜测，如果
陌生尽管如此，

604
00:27:24,390 --> 00:27:27,430
什么分号做。

605
00:27:27,430 --> 00:27:28,865
什么是它大概是做给我们？

606
00:27:28,865 --> 00:27:29,365
是吗？

607
00:27:29,365 --> 00:27:29,840
>> 听众：[听不清]

608
00:27:29,840 --> 00:27:29,980
>> DAVID J.马兰：是的。

609
00:27:29,980 --> 00:27:31,170
这只是终止该行。

610
00:27:31,170 --> 00:27:31,669
对？

611
00:27:31,669 --> 00:27:34,260
这些计算机想要成为直言
告诉记者，从字面上看，该怎么办。

612
00:27:34,260 --> 00:27:36,343
象花生酱和
果冻三明治的例子，

613
00:27:36,343 --> 00:27:39,360
如果不指定
正是你想要，

614
00:27:39,360 --> 00:27:42,190
它可能会留下来判断或错误。

615
00:27:42,190 --> 00:27:44,890
分号表示，
这就是它的这个命令。

616
00:27:44,890 --> 00:27:48,310
它是超精密，它的
一个很容易的事情离开了。

617
00:27:48,310 --> 00:27:52,240
所以，现在这个计划似乎并没有不
以不同方式表现任何直到我

618
00:27:52,240 --> 00:27:53,500
使其更具活力。

619
00:27:53,500 --> 00:27:57,107
因此，而不是硬可能我自己
名字，让我把一个占位符值。

620
00:27:57,107 --> 00:28:00,190
而事实证明，我知道这
从已经阅读文档，

621
00:28:00,190 --> 00:28:04,080
和所使用的功能为年，即
printf的被设计为动态的。

622
00:28:04,080 --> 00:28:07,510
你不必预先知道
你想要的话把它。

623
00:28:07,510 --> 00:28:11,290
你可以代替有
占位符，比如％的s，这

624
00:28:11,290 --> 00:28:15,500
是要告诉
电脑，放了串在这里。

625
00:28:15,500 --> 00:28:17,740
>> 这串做的，我们要放在那里？

626
00:28:17,740 --> 00:28:22,430
威尔原来，这两者之间
括号，这还记得，划定

627
00:28:22,430 --> 00:28:28,020
的输入的函数，如果有
逗号分隔的事情列表在这里，

628
00:28:28,020 --> 00:28:31,790
我们实际上通过在多个
输入到一个函数。

629
00:28:31,790 --> 00:28:33,901
所以就像一些划痕
块，你可能不

630
00:28:33,901 --> 00:28:36,150
已经打了他们
您的项目还没有或根本，

631
00:28:36,150 --> 00:28:38,250
一些划痕块有两个输入。

632
00:28:38,250 --> 00:28:41,220
两个白色的盒子，你可以
输入数字或单词之中。

633
00:28:41,220 --> 00:28:45,210
因此，为了不C已将类似的功能
printf的，可以采取两个输入。

634
00:28:45,210 --> 00:28:48,050
再次，这个逗号
被隔开。

635
00:28:48,050 --> 00:28:51,070
因此，在英语，再有就是
你从来没有编程之前，

636
00:28:51,070 --> 00:28:55,320
由逻辑printf的是一个函数，
采用两个输入，其中之一

637
00:28:55,320 --> 00:28:58,810
是一个占位符，你会希望
printf的是要与此输入？

638
00:28:58,810 --> 00:29:01,470

639
00:29:01,470 --> 00:29:03,220
这是怎么回事打招呼
汉娜，有希望。

640
00:29:03,220 --> 00:29:05,274
因此，要做到这一点，我们需要保存它。

641
00:29:05,274 --> 00:29:06,190
我要缩小。

642
00:29:06,190 --> 00:29:10,701
我要背下来去这里
并说，让你好进入。

643
00:29:10,701 --> 00:29:11,200
呵呵。

644
00:29:11,200 --> 00:29:14,830
什么是错的，而实际上
这是一个相当巨大。

645
00:29:14,830 --> 00:29:18,400
我有6行代码
而像12行错误。

646
00:29:18,400 --> 00:29:22,120
因此，期待这一点。

647
00:29:22,120 --> 00:29:24,260
所以，这是怎么回事吗？

648
00:29:24,260 --> 00:29:27,370
因此，拇指这里最好的规则，
特别是当你开始了，

649
00:29:27,370 --> 00:29:29,370
不要被分心
东西在底部。

650
00:29:29,370 --> 00:29:31,220
其实，我很刻意
只是向上滚动

651
00:29:31,220 --> 00:29:33,930
因为很多时候，一台电脑
不是所有的明亮的装置。

652
00:29:33,930 --> 00:29:35,054
这将混淆。

653
00:29:35,054 --> 00:29:37,220
如果它看到一件事，
它不理解，

654
00:29:37,220 --> 00:29:40,030
它可能会误以为其他
行代码是不正确的，

655
00:29:40,030 --> 00:29:41,649
即使他们是完美的罚款。

656
00:29:41,649 --> 00:29:43,940
所以，你总是想工作
在错误自上而下。

657
00:29:43,940 --> 00:29:47,850
诚然，这是
超级神秘的时刻。

658
00:29:47,850 --> 00:29:50,830
>> 错误，使用未申报
标识字符串。

659
00:29:50,830 --> 00:29:52,130
难道我的意思是标准？

660
00:29:52,130 --> 00:29:53,720
不，我的意思是字符串。

661
00:29:53,720 --> 00:29:55,830
而它的指向，也许这是一个错字。

662
00:29:55,830 --> 00:30:00,570
有点像，拼写检查的
十分怪异的方式，但在这里的原因，

663
00:30:00,570 --> 00:30:02,840
你就会知道这
仅仅通过实践，是

664
00:30:02,840 --> 00:30:06,390
它原来是串
在C中不存在事实上，C

665
00:30:06,390 --> 00:30:08,820
是一个非常古老的语言，
而且这是非常低的水平，

666
00:30:08,820 --> 00:30:11,361
而且它不会很多功能
您可能已经长大了

667
00:30:11,361 --> 00:30:14,620
有，如果你有，事实上，程序
在Java中，因为一些你有，

668
00:30:14,620 --> 00:30:16,980
但你可以教它新的东西。

669
00:30:16,980 --> 00:30:20,900
事实上，我们已经做到了这一点CS50，
即使在学期结束时，

670
00:30:20,900 --> 00:30:23,512
所有这些培训车轮
将已取消，

671
00:30:23,512 --> 00:30:25,220
我们所做的这些
最初几周

672
00:30:25,220 --> 00:30:29,830
最初是我们还
你包括CS50点小时。

673
00:30:29,830 --> 00:30:31,230
这是一个头文件。

674
00:30:31,230 --> 00:30:32,440
更上的未来。

675
00:30:32,440 --> 00:30:36,430
>> 这是一个包含函数的文件
我们已为你写好。

676
00:30:36,430 --> 00:30:39,180
而这些功能中的
获取输入功能

677
00:30:39,180 --> 00:30:43,520
从用户，像字符串，和
号，和实数，等等。

678
00:30:43,520 --> 00:30:45,550
但它也有一些快捷方式。

679
00:30:45,550 --> 00:30:48,200
它定义了布尔作为数据类型。

680
00:30:48,200 --> 00:30:50,340
C没有真的还是假的。

681
00:30:50,340 --> 00:30:53,880
但是，我们可以给它的概念
真的还是假的这个库的方式。

682
00:30:53,880 --> 00:30:57,670
它也没有一个串
内置的，直到我们有这条线。

683
00:30:57,670 --> 00:31:01,090
因此，这行代码指示
编译器，哎，铛，看

684
00:31:01,090 --> 00:31:03,570
在这个文件中的一个整体
一串代码CS50

685
00:31:03,570 --> 00:31:06,330
写这样
使用此文件的人

686
00:31:06,330 --> 00:31:09,330
可以认为是理所当然的
他们已经添加的功能。

687
00:31:09,330 --> 00:31:11,220
>> 所以，现在让我继续前进
并清屏，

688
00:31:11,220 --> 00:31:14,178
如果好奇，我只是说控制
l每个时间来清除屏幕，

689
00:31:14,178 --> 00:31:15,500
或者你可以键入清晰。

690
00:31:15,500 --> 00:31:19,220
我只是现在要继续前进，
类型做出招呼，一切都很好。

691
00:31:19,220 --> 00:31:22,550
还有一个神秘的输出，但
这不是一个错误的信息。

692
00:31:22,550 --> 00:31:28,300
现在，如果我做点斜线打招呼，并作为
一旁，点斜线是不熟悉的大多数。

693
00:31:28,300 --> 00:31:30,430
这只是意味着，点手段
当前目录。

694
00:31:30,430 --> 00:31:33,120
所以，如果你曾经使用过
DOS或Linux或UNIX

695
00:31:33,120 --> 00:31:35,410
你可能做了什么
如CD点点，哪里

696
00:31:35,410 --> 00:31:39,220
点点意味着倒退
时间，或者倒退，或者更高了

697
00:31:39,220 --> 00:31:40,370
在目录中。

698
00:31:40,370 --> 00:31:43,090
点只是意味着看在
当前目录。

699
00:31:43,090 --> 00:31:45,670
我希望你好，这是在这里。

700
00:31:45,670 --> 00:31:47,750
事实上，现在它汉娜说你好。

701
00:31:47,750 --> 00:31:51,120
如果我再改
玛丽亚，重新编译

702
00:31:51,120 --> 00:31:55,650
它将使你好，点斜线
你好，该计划不断变化。

703
00:31:55,650 --> 00:31:58,060
>> 但是，这仍然是一个
非常愚蠢的计划。

704
00:31:58,060 --> 00:32:00,972
如果我想船这个程序，
或者把它送给一个朋友，

705
00:32:00,972 --> 00:32:03,430
还是把它给玛丽亚和汉娜
对于这个问题，这很好。

706
00:32:03,430 --> 00:32:07,300
我可以自定义为他们两个，
但它永远不会是动态的。

707
00:32:07,300 --> 00:32:10,870
一旦它编写的，他们不能改变它
下到这些零和一。

708
00:32:10,870 --> 00:32:12,350
所以，我们做了一些更聪明？

709
00:32:12,350 --> 00:32:17,100
如果有什么，而不是硬编码
到程序这个人的姓名，

710
00:32:17,100 --> 00:32:20,890
如果我们只是得到了什么
对需求的字符串？

711
00:32:20,890 --> 00:32:22,430
>> 因此，换句话说，让我做到这一点。

712
00:32:22,430 --> 00:32:24,030
我要重新编译该程序。

713
00:32:24,030 --> 00:32:25,710
让我放大在底部了。

714
00:32:25,710 --> 00:32:29,920
让你好点斜线打招呼。

715
00:32:29,920 --> 00:32:31,710
现在什么也没有发生。

716
00:32:31,710 --> 00:32:35,860
我们可以得到一个快速的志愿者
使事情发生？

717
00:32:35,860 --> 00:32:36,360
上来吧。

718
00:32:36,360 --> 00:32:37,020
你叫什么名字？

719
00:32:37,020 --> 00:32:37,445
>> PANCHO：潘乔。

720
00:32:37,445 --> 00:32:38,361
>> DAVID J.马兰：Pacho？

721
00:32:38,361 --> 00:32:39,609
上来吧。

722
00:32:39,609 --> 00:32:42,150
一旦你在这里得到了，这是
将是非常给人留下深刻印象，

723
00:32:42,150 --> 00:32:44,060
但它更有趣
比我打字吧。

724
00:32:44,060 --> 00:32:49,007
如果你想继续前进，键入您
名字，我做了这个节目只为你。

725
00:32:49,007 --> 00:32:49,840
只要输入你的名字。

726
00:32:49,840 --> 00:32:52,380

727
00:32:52,380 --> 00:32:53,900
输入。

728
00:32:53,900 --> 00:32:54,489
太好了。

729
00:32:54,489 --> 00:32:55,780
好，非常感谢你。

730
00:32:55,780 --> 00:32:56,708
>> PANCHO：非常感谢你。

731
00:32:56,708 --> 00:32:57,636
>> DAVID J.马兰：OK。

732
00:32:57,636 --> 00:32:59,028
>> [掌声]

733
00:32:59,028 --> 00:33:00,884

734
00:33:00,884 --> 00:33:01,840
>> 这是很亲切。

735
00:33:01,840 --> 00:33:03,145
干得好。

736
00:33:03,145 --> 00:33:03,770
我们做了什么？

737
00:33:03,770 --> 00:33:05,930
因此，我们终于，至少
做这个节目的动态。

738
00:33:05,930 --> 00:33:08,400
现在，它仍然是肯定
设计给人留下深刻印象，

739
00:33:08,400 --> 00:33:11,480
但我们终于有能力
现在写代码提前，多

740
00:33:11,480 --> 00:33:13,770
如printf的作者，
然后动态地

741
00:33:13,770 --> 00:33:17,550
适应基于输入已是
递，或者由程序员，

742
00:33:17,550 --> 00:33:20,610
或由人谁实际上
与节目进行交互。

743
00:33:20,610 --> 00:33:22,990
因此，让我们其实现在就试试
做一些其他结构

744
00:33:22,990 --> 00:33:26,625
看看如果我们不能使节目
自己更复杂。

745
00:33:26,625 --> 00:33:29,250
因此，让我们继续前进，而不是
写这篇从头开始，

746
00:33:29,250 --> 00:33:31,540
我要进入​​今天的
源代码，而这一切

747
00:33:31,540 --> 00:33:34,290
可在球场上的
网站，你可以将它拖放

748
00:33:34,290 --> 00:33:36,590
到你自己的环境
周五来一次问题

749
00:33:36,590 --> 00:33:38,506
集1给你
说明，或者你可以

750
00:33:38,506 --> 00:33:41,200
这样做在命令行
很好，但更多的惊喜P中设置1。

751
00:33:41,200 --> 00:33:44,940
>> 让我们来看看这是什么程序
这里所说的，加法器C点。

752
00:33:44,940 --> 00:33:47,970
现在，我已经评论
它，但什么是新的？

753
00:33:47,970 --> 00:33:51,230
乍看之下，什么线
代码是完全新的？

754
00:33:51,230 --> 00:33:53,930

755
00:33:53,930 --> 00:33:56,780
也许不能从根本上
陌生了。

756
00:33:56,780 --> 00:33:58,417
>> 听众：[听不清]

757
00:33:58,417 --> 00:34:00,250
DAVID J.马兰：是啊，
因此INT x等于得到n个。

758
00:34:00,250 --> 00:34:03,760
我们从来没有看到任何这
前，但int是可能

759
00:34:03,760 --> 00:34:08,179
什么样的符号
变量，[？从？]一个整数。

760
00:34:08,179 --> 00:34:09,040
所以诠释的整数。

761
00:34:09,040 --> 00:34:11,420
这只是更加
简洁。 x只是随意的。

762
00:34:11,420 --> 00:34:13,920
x和y和z是仍然
对数字相当合理，

763
00:34:13,920 --> 00:34:16,790
但一般我们使用的话，一旦
我们的程序变得更复杂。

764
00:34:16,790 --> 00:34:18,940
获取当然，INT，
就像GET字符串，

765
00:34:18,940 --> 00:34:21,629
很可能会得到
从用户一个int，

766
00:34:21,629 --> 00:34:23,670
然后我们要
做同样的事情与年。

767
00:34:23,670 --> 00:34:27,610
而且显然，尽管这
最后一行，24，看起来比较复杂，

768
00:34:27,610 --> 00:34:32,679
它会说，这个总和
而且，它是此其他东西。

769
00:34:32,679 --> 00:34:35,840
>> 而百分之通知我
大概是指什么呢？

770
00:34:35,840 --> 00:34:38,190
什么样的角色％的
我显然是服务？

771
00:34:38,190 --> 00:34:40,739

772
00:34:40,739 --> 00:34:41,719
这只是占位符。

773
00:34:41,719 --> 00:34:42,219
对？

774
00:34:42,219 --> 00:34:45,149
百分比S为字符串，
％的i是整数。

775
00:34:45,149 --> 00:34:47,690
还有的将是百分之˚F
对于浮点值，这

776
00:34:47,690 --> 00:34:49,273
仅仅是一个数字带小数点。

777
00:34:49,273 --> 00:34:50,590
换言之，一个实数。

778
00:34:50,590 --> 00:34:55,270
因此，让我们实际编译这个
真正的编程速度快，不作加法。

779
00:34:55,270 --> 00:34:57,962
哎呦。

780
00:34:57,962 --> 00:34:58,670
好机会。

781
00:34:58,670 --> 00:35:02,970
所以注意在这里，这段时间我的用户
名称此帐户jharvard。

782
00:35:02,970 --> 00:35:06,620
我是在CS50 IDE，又名IDE50。

783
00:35:06,620 --> 00:35:11,030
而现在这里用蓝色，是一提，但
从环境中我的。

784
00:35:11,030 --> 00:35:16,050
而事实上，如果我放大到顶部
在这里，请注意，我有一个IDE50

785
00:35:16,050 --> 00:35:19,490
我看你种这个词，
把你的头转向一侧，工作区。

786
00:35:19,490 --> 00:35:23,890
概括地说，事实上，
我看到波浪线斜线工作区

787
00:35:23,890 --> 00:35:26,910
意味着，在这个文本
基于命令的环境，

788
00:35:26,910 --> 00:35:32,300
我在文中相当于
这种图形文件夹在这里。

789
00:35:32,300 --> 00:35:35,730
所以，当我做点斜线
加法器，它说没有规则

790
00:35:35,730 --> 00:35:37,372
使目标加法器停止。

791
00:35:37,372 --> 00:35:39,830
我不知道这意味着什么，
但它的坏的某些原因。

792
00:35:39,830 --> 00:35:43,310
没有这样的文件或目录
更清晰。

793
00:35:43,310 --> 00:35:45,670
它在哪里呢？

794
00:35:45,670 --> 00:35:47,820
根据我的点击
前面打开该文件。

795
00:35:47,820 --> 00:35:49,442
哪里会是什么？

796
00:35:49,442 --> 00:35:52,050
>> 这可能是在源
1瓦特，周三，

797
00:35:52,050 --> 00:35:53,960
我可以看到它，的确，
如果我打开了。

798
00:35:53,960 --> 00:35:57,220
还有加法点C，但在
这种基于文本的环境，

799
00:35:57,220 --> 00:35:59,380
再次，我必须要超明确。

800
00:35:59,380 --> 00:36:03,950
如果我想改变目录到
源的1个星期三，我需要输入，

801
00:36:03,950 --> 00:36:07,210
CD空间源的1个
周三进入现在

802
00:36:07,210 --> 00:36:09,810
我迅速变化
给我一个视觉提示

803
00:36:09,810 --> 00:36:12,330
我，真的，别的地方
在我的环境，

804
00:36:12,330 --> 00:36:15,710
但现在我能做到让
加法器，它似乎工作，

805
00:36:15,710 --> 00:36:18,190
点斜线加法，给我一个整数。

806
00:36:18,190 --> 00:36:19,080
一。

807
00:36:19,080 --> 00:36:20,070
二。

808
00:36:20,070 --> 00:36:21,630
一和二的总和为3。

809
00:36:21,630 --> 00:36:24,140
但是，如果我不配合，
让我们看看得到INT一样。

810
00:36:24,140 --> 00:36:25,200
给我一个整数。

811
00:36:25,200 --> 00:36:26,590
第

812
00:36:26,590 --> 00:36:27,350
重试。

813
00:36:27,350 --> 00:36:29,060
行。

814
00:36:29,060 --> 00:36:30,520
精细。

815
00:36:30,520 --> 00:36:32,130
50。

816
00:36:32,130 --> 00:36:32,680
50。

817
00:36:32,680 --> 00:36:33,010
好吧。

818
00:36:33,010 --> 00:36:34,055
因此，它终于合作。

819
00:36:34,055 --> 00:36:36,430
而这部分的
功能，这些功能

820
00:36:36,430 --> 00:36:37,760
可以有内置的为您服务。

821
00:36:37,760 --> 00:36:43,330
>> 因此，实现内部
弄INT，什么编程

822
00:36:43,330 --> 00:36:47,990
上周构造可能是在
有强迫重试的这种行为，

823
00:36:47,990 --> 00:36:49,962
重试，重试？

824
00:36:49,962 --> 00:36:51,670
是的，有可能是
某种循环。

825
00:36:51,670 --> 00:36:54,160
这将看语法
从头开始的块不同，

826
00:36:54,160 --> 00:36:55,880
但是这确实是
什么是里面的文件。

827
00:36:55,880 --> 00:36:58,505
而在几个星期的时间，我们将
其实看看CS50库

828
00:36:58,505 --> 00:37:02,000
至于里面有什么，但有
一个循环气势正是这么做的。

829
00:37:02,000 --> 00:37:04,840
>> 让我们玩一个愚蠢的小
比赛在这里与此文件。

830
00:37:04,840 --> 00:37:06,550
零点零一C点。

831
00:37:06,550 --> 00:37:08,960
我们只是去一般
从零开始计数。

832
00:37:08,960 --> 00:37:11,220
我一直滚动过去
有些东西在上面。

833
00:37:11,220 --> 00:37:15,390
在这里用蓝色，划定了所有
这些明星和斜线，

834
00:37:15,390 --> 00:37:17,310
你们谁编程
之前，那是什么？

835
00:37:17,310 --> 00:37:18,690
为什么我们保持跳过它？

836
00:37:18,690 --> 00:37:19,110
什么？

837
00:37:19,110 --> 00:37:19,490
>> 听众：这是一个注释。

838
00:37:19,490 --> 00:37:19,800
>> DAVID J.马兰：是的。

839
00:37:19,800 --> 00:37:20,633
这只是一个评论。

840
00:37:20,633 --> 00:37:24,160
这是对人类评论
阅读，在我们的情况下，

841
00:37:24,160 --> 00:37:27,120
告诉我们的文件的名
是谁写的，和它做什么，

842
00:37:27,120 --> 00:37:28,610
这样你就不必
通读代码

843
00:37:28,610 --> 00:37:30,110
知道这个文件是一回事。

844
00:37:30,110 --> 00:37:33,110
这只是一个说明，但
在功能上它是无关紧要的。

845
00:37:33,110 --> 00:37:35,930
而且我甚至可以从删除
我的文件，并没有任何影响。

846
00:37:35,930 --> 00:37:38,740
该多汁线是这些
前两个在这里，现在。

847
00:37:38,740 --> 00:37:41,405
INT主要空隙是等效
我们当绿旗点击，

848
00:37:41,405 --> 00:37:44,030
所以我们要离开的是
今天，我们会回来的，

849
00:37:44,030 --> 00:37:46,940
最终，至于是什么
int和无效的，但现在，

850
00:37:46,940 --> 00:37:49,500
请注意我做了什么
在这里，你还可以，

851
00:37:49,500 --> 00:37:51,736
如果你有一个在网上
发表评论，如果您有

852
00:37:51,736 --> 00:37:54,670
一想到要分享
关于一个特定的代码行，

853
00:37:54,670 --> 00:37:58,910
在C约定是做斜线
斜线，然后几个简洁的话，

854
00:37:58,910 --> 00:38:01,500
不是一个完整的句子，
一般不是一个段落，

855
00:38:01,500 --> 00:38:05,310
这只是说明了你，或者你
TF，或其他读者或同事，

856
00:38:05,310 --> 00:38:06,990
你的代码做。

857
00:38:06,990 --> 00:38:10,150
因此，而不是一定要看
在这一点，从线推断

858
00:38:10,150 --> 00:38:12,550
9和10中，是什么
该做的，八线

859
00:38:12,550 --> 00:38:14,945
我只是给了评论
问用户的一个整数，

860
00:38:14,945 --> 00:38:17,820
然后，我没有想太多硬
什么线九10的。

861
00:38:17,820 --> 00:38:19,720
我只知道，那是什么
总的来说，他们正在做的。

862
00:38:19,720 --> 00:38:20,460
>> 怎么样？

863
00:38:20,460 --> 00:38:22,060
那么，这里的提示。

864
00:38:22,060 --> 00:38:23,610
下面是整型的获得。

865
00:38:23,610 --> 00:38:25,984
以及基于所述前一
的行为，好像GET INT

866
00:38:25,984 --> 00:38:29,080
是足够聪明，以确保
人类配合并给它

867
00:38:29,080 --> 00:38:30,090
一个整数。

868
00:38:30,090 --> 00:38:32,270
但是，现在我们看到的这个。

869
00:38:32,270 --> 00:38:33,740
这让人想起划伤。

870
00:38:33,740 --> 00:38:36,140
我声称我
分析用户的输入，

871
00:38:36,140 --> 00:38:39,050
但有些不准确。

872
00:38:39,050 --> 00:38:43,200
而这显然是在C是怎么
我们表示了，如果其他人的一个分支，

873
00:38:43,200 --> 00:38:46,320
一个岔路，但我
说有点不准确。

874
00:38:46,320 --> 00:38:50,470
这是什么程序的错误吗？

875
00:38:50,470 --> 00:38:51,610
关于进一退？

876
00:38:51,610 --> 00:38:52,223
是啊。

877
00:38:52,223 --> 00:38:53,150
>> 听众：[听不清]为零。

878
00:38:53,150 --> 00:38:54,025
>> DAVID J.马兰：是的。

879
00:38:54,025 --> 00:38:57,630
所以，如果我输入零，让我们考虑
正是这样的情况下，或墙角的情况下，

880
00:38:57,630 --> 00:38:58,450
如果你愿意。

881
00:38:58,450 --> 00:39:02,790
如果我输入为零，因此它的
块将会显然抓住它？

882
00:39:02,790 --> 00:39:04,660
该如果还是别的？

883
00:39:04,660 --> 00:39:07,340
在其他，它会说，
你选择了一个负数。

884
00:39:07,340 --> 00:39:10,476
事实上，零是不应该
是正或负，

885
00:39:10,476 --> 00:39:11,850
因此，这将是错误。

886
00:39:11,850 --> 00:39:12,930
这将是一个错误。

887
00:39:12,930 --> 00:39:14,580
那么，如何才能解决这个问题？

888
00:39:14,580 --> 00:39:16,360
有人谁以前从来没有编程？

889
00:39:16,360 --> 00:39:16,570
你想要 - 

890
00:39:16,570 --> 00:39:17,480
>> 听众：[听不清]

891
00:39:17,480 --> 00:39:17,990
>> DAVID J.马兰：缩回？

892
00:39:17,990 --> 00:39:18,570
>> 听众：[听不清]

893
00:39:18,570 --> 00:39:18,930
>> DAVID J.马兰：哦，你有吗？

894
00:39:18,930 --> 00:39:20,350
有人谁以前从未编程。

895
00:39:20,350 --> 00:39:21,750
想试试你的手在
这一点，在红色的衬衫吗？

896
00:39:21,750 --> 00:39:22,600
上来吧。

897
00:39:22,600 --> 00:39:25,320
哦对了，上来吧，如果你不介意的话。

898
00:39:25,320 --> 00:39:27,586
所以从未编程
之前，你叫什么名字？

899
00:39:27,586 --> 00:39:28,210
LAUREN：劳伦。

900
00:39:28,210 --> 00:39:29,626
DAVID J.马兰：劳伦，没事的。

901
00:39:29,626 --> 00:39:31,150
因此，修复这个bug给我们。

902
00:39:31,150 --> 00:39:35,070
你从来没见过C，据推测，
大概没有其他语言。

903
00:39:35,070 --> 00:39:38,380
因此，解决这个问题的程序我们。

904
00:39:38,380 --> 00:39:39,100
很高兴见到你。

905
00:39:39,100 --> 00:39:39,615
无压力。

906
00:39:39,615 --> 00:39:40,156
LAUREN：是的。

907
00:39:40,156 --> 00:39:43,350

908
00:39:43,350 --> 00:39:46,270
>> DAVID J.马兰：但同样，如果这
豪赌按计划进行，

909
00:39:46,270 --> 00:39:48,350
外卖，这里将
是，刚刚再次启动

910
00:39:48,350 --> 00:39:51,080
注意图案和
从现有的语法推断

911
00:39:51,080 --> 00:39:55,420
怎么回事，你可以表达
你自己，没有双关语意，为了

912
00:39:55,420 --> 00:39:58,410
捕捉到一些额外的场景。

913
00:39:58,410 --> 00:39:59,603
因此，我们说，否则，如果。

914
00:39:59,603 --> 00:40:04,040

915
00:40:04,040 --> 00:40:05,230
printf的，不错。

916
00:40:05,230 --> 00:40:09,120
而与CS50通知
IDE和frankly-- IDE

917
00:40:09,120 --> 00:40:11,110
代表综合
开发环境。

918
00:40:11,110 --> 00:40:14,110
这说法只是一种奇特的方式
一个程序，可以帮助你的程序。

919
00:40:14,110 --> 00:40:16,779
它确实人性化之类的东西
当你打印一份括号，

920
00:40:16,779 --> 00:40:18,320
它会自动给你其他的。

921
00:40:18,320 --> 00:40:20,760
该假设是，你是
最终将要键入，

922
00:40:20,760 --> 00:40:22,400
而且还做它用引号。

923
00:40:22,400 --> 00:40:24,190
>> 所以，我很喜欢23行。

924
00:40:24,190 --> 00:40:26,400
99％的存在的方式。

925
00:40:26,400 --> 00:40:29,920
有人想附和小费？

926
00:40:29,920 --> 00:40:31,420
我听到分号观众。

927
00:40:31,420 --> 00:40:32,080
好。

928
00:40:32,080 --> 00:40:33,260
这样就完成了。

929
00:40:33,260 --> 00:40:37,930
而现在，我只是有一点点
惊愕与线21。

930
00:40:37,930 --> 00:40:41,370
我们想得到怎样的表现呢？

931
00:40:41,370 --> 00:40:43,370
什么样的问题，我们希望
问，你觉得呢？

932
00:40:43,370 --> 00:40:46,870

933
00:40:46,870 --> 00:40:50,330
所以以前我们问的问题，
如果n大于零，做到这一点。

934
00:40:50,330 --> 00:40:51,870
否则，做到这一点。

935
00:40:51,870 --> 00:40:54,317
因此，我们需要选择一个
要问的问题在这里。

936
00:40:54,317 --> 00:40:55,192
听众：[听不清]

937
00:40:55,192 --> 00:40:56,530
DAVID J.马兰：好。

938
00:40:56,530 --> 00:40:58,290
因此，如果n等于零。

939
00:40:58,290 --> 00:41:01,140

940
00:41:01,140 --> 00:41:02,100
优秀的。

941
00:41:02,100 --> 00:41:03,080
因此，让我们暂停一下。

942
00:41:03,080 --> 00:41:04,850
谢谢你这么多顶着这一点。

943
00:41:04,850 --> 00:41:10,890
让我给你一个小当之无愧
压力球，或许还有。

944
00:41:10,890 --> 00:41:11,900
因此，我们快到了。

945
00:41:11,900 --> 00:41:14,790
事实上，劳伦，如果你不
心，让我做一个调整位置，

946
00:41:14,790 --> 00:41:17,850
刚需，甚至一致
我们在划痕看到的，是什么

947
00:41:17,850 --> 00:41:21,080
做我想做的事与线
21和24，只需再次基础

948
00:41:21,080 --> 00:41:23,290
我们如何在划痕这样做，也许？

949
00:41:23,290 --> 00:41:24,230
>> 听众：移动它。

950
00:41:24,230 --> 00:41:25,605
>> DAVID J.马兰：是啊，动不起来。

951
00:41:25,605 --> 00:41:30,260
所以其他条件，第三，或
第四或第五或最终分支，

952
00:41:30,260 --> 00:41:34,100
应该已经来了以后，
这还只是按照惯例，

953
00:41:34,100 --> 00:41:36,047
只是因为如果你愿意。

954
00:41:36,047 --> 00:41:37,380
所以，我需要做这样的修改。

955
00:41:37,380 --> 00:41:39,660
我需要把我的
大括号回到这里。

956
00:41:39,660 --> 00:41:42,700
而现在，这一计划将编译。

957
00:41:42,700 --> 00:41:46,140
我们是如此接近，但有
一个非常，非常微妙的错误。

958
00:41:46,140 --> 00:41:47,200
让我们看看会发生什么。

959
00:41:47,200 --> 00:41:49,660
>> 首先，让我继续前进，缩小。

960
00:41:49,660 --> 00:41:53,405
我要继续前进，
键入使病情为零。

961
00:41:53,405 --> 00:41:55,070
哦，我撒谎了。

962
00:41:55,070 --> 00:41:58,760
现在，编译器
其实很聪明。

963
00:41:58,760 --> 00:42:00,950
我真的不明白
它的错误消息。

964
00:42:00,950 --> 00:42:04,310
使用赋值的结果
作为不带括号的条件，

965
00:42:04,310 --> 00:42:05,740
显然是不好的。

966
00:42:05,740 --> 00:42:07,100
但是，这是什么意思？

967
00:42:07,100 --> 00:42:10,860
>> 好了，寻找模式
在代码中，我们以前见过，

968
00:42:10,860 --> 00:42:16,640
什么是17行实际上做，
尽管劳伦稍微意

969
00:42:16,640 --> 00:42:18,790
除此以外？

970
00:42:18,790 --> 00:42:19,290
是啊。

971
00:42:19,290 --> 00:42:21,565
>> 听众：[听不清]

972
00:42:21,565 --> 00:42:22,440
DAVID J.马兰：是的。

973
00:42:22,440 --> 00:42:26,610
所以请记住等号，显然
正如我们以前使用过它，不等于。

974
00:42:26,610 --> 00:42:29,240
它的任务，由右至左。

975
00:42:29,240 --> 00:42:33,810
因此，线17的那一刻
是一个条件，它的

976
00:42:33,810 --> 00:42:37,890
括号内执行代码，
但该代码执行时，

977
00:42:37,890 --> 00:42:42,140
什么是发生在零值？

978
00:42:42,140 --> 00:42:45,250
什么是发生在n的值？

979
00:42:45,250 --> 00:42:46,810
成为零。

980
00:42:46,810 --> 00:42:50,520
因此，如果n变为零，
并再次，根据上周，

981
00:42:50,520 --> 00:42:54,690
我们一般说是零
是假的，一个是真实的，

982
00:42:54,690 --> 00:42:57,410
或者是一个没有为零。

983
00:42:57,410 --> 00:42:59,590
所以，真与假，一年0。

984
00:42:59,590 --> 00:43:06,090
如果n为17行的已
给出的值0，是零真的吗？

985
00:43:06,090 --> 00:43:06,590
第

986
00:43:06,590 --> 00:43:08,280
根据定义，零是假的。

987
00:43:08,280 --> 00:43:10,860
这是我们的约定
要坚持前进。

988
00:43:10,860 --> 00:43:17,320
所以才会线18，19和20
现在以往任何时候都适用，逻辑？

989
00:43:17,320 --> 00:43:18,320
他们不能。

990
00:43:18,320 --> 00:43:21,640
因此，我们问的问题
但不太精确，

991
00:43:21,640 --> 00:43:25,620
你不会不知道这一点，除非
你已经看到了，在C解决方案

992
00:43:25,620 --> 00:43:29,610
就是当你想表达
平等，你说等于平等的。

993
00:43:29,610 --> 00:43:33,140
所以等号已经用完
通过转让，由右至左。

994
00:43:33,140 --> 00:43:35,110
等于等于手段平等的。

995
00:43:35,110 --> 00:43:37,950
如果你真的想你的心
弯曲，JavaScript和PHP，

996
00:43:37,950 --> 00:43:40,490
还有等于等于平等，这
意思是另一回事，

997
00:43:40,490 --> 00:43:41,990
但我们会去，不久。

998
00:43:41,990 --> 00:43:45,760
>> 所以这是一个简单的修补程序，但实现
超级容易犯这个错误，

999
00:43:45,760 --> 00:43:48,700
然后不知道奋斗
对于分钟，如果没有一个小时，

1000
00:43:48,700 --> 00:43:51,490
为什么我的代码不
执行我打算？

1001
00:43:51,490 --> 00:43:54,140
这是因为你没有告诉
它正是你的意思。

1002
00:43:54,140 --> 00:43:56,450
所以这几乎是
完美的，这是伟大的

1003
00:43:56,450 --> 00:44:00,760
我们跨越这两个小迷迷糊糊
的事情，因为现在如果我们解决这些问题，

1004
00:44:00,760 --> 00:44:06,240
我做的做条件为零
点斜线条件为零，

1005
00:44:06,240 --> 00:44:07,490
我想一个整数吧。

1006
00:44:07,490 --> 00:44:08,090
让我们来看看。

1007
00:44:08,090 --> 00:44:09,160
第

1008
00:44:09,160 --> 00:44:10,740
它会强迫我去做。

1009
00:44:10,740 --> 00:44:11,990
所以42。

1010
00:44:11,990 --> 00:44:13,590
我挑了个正数。

1011
00:44:13,590 --> 00:44:16,470
所以，现在我该怎么办证明
这个程序正确吗？

1012
00:44:16,470 --> 00:44:19,990
如果你是一个数学家，你不能
真正通过反复试验证明了这一点，

1013
00:44:19,990 --> 00:44:20,490
对？

1014
00:44:20,490 --> 00:44:23,180
你不能只是校对
例子，但至少

1015
00:44:23,180 --> 00:44:25,494
作为一个程序员，我们不是
要试图证明现在

1016
00:44:25,494 --> 00:44:27,660
这其实是
正确的，但我也许应该

1017
00:44:27,660 --> 00:44:29,470
测试一些代表性的案例。

1018
00:44:29,470 --> 00:44:31,070
>> 我测试过42。

1019
00:44:31,070 --> 00:44:33,030
我可以测试43。

1020
00:44:33,030 --> 00:44:34,910
我可以测试44。

1021
00:44:34,910 --> 00:44:35,640
测试45。

1022
00:44:35,640 --> 00:44:36,140
对？

1023
00:44:36,140 --> 00:44:37,860
但我可以这样做很长一段时间。

1024
00:44:37,860 --> 00:44:39,925
什么会更多一些
有趣的情况来试试呢？

1025
00:44:39,925 --> 00:44:41,050
听众：[听不清]为零。

1026
00:44:41,050 --> 00:44:41,740
DAVID J.马兰：所以零。

1027
00:44:41,740 --> 00:44:42,297
当然可以。

1028
00:44:42,297 --> 00:44:44,880
不错，我们已经知道了这个时候，
由于劳伦的新代码。

1029
00:44:44,880 --> 00:44:46,213
什么是另一个很好的例子来试试呢？

1030
00:44:46,213 --> 00:44:47,320
听众：消极的。

1031
00:44:47,320 --> 00:44:50,070
>> DAVID J.马兰：负之一，
或许真的有点大，

1032
00:44:50,070 --> 00:44:52,617
所以也许负42，
但在一般情况下，当

1033
00:44:52,617 --> 00:44:54,450
测试你的程序
向前走，你

1034
00:44:54,450 --> 00:44:56,325
将要思考
给自己，喜欢什么

1035
00:44:56,325 --> 00:44:58,050
是根本不同的情况。

1036
00:44:58,050 --> 00:45:01,720
我敢说负的情况下，
一个正的情况下，和一个零的情况下

1037
00:45:01,720 --> 00:45:03,365
相当多轮这些了。

1038
00:45:03,365 --> 00:45:04,990
让我们来看看这虽然的一个变种。

1039
00:45:04,990 --> 00:45:06,930
条件之一。

1040
00:45:06,930 --> 00:45:11,224
这是一个正确的解决方案在这里，
所以，你会看到两个和网上，

1041
00:45:11,224 --> 00:45:13,390
如果通过行走
演练，一般会

1042
00:45:13,390 --> 00:45:18,090
这些增量逐步直到我们
得到完全正确的方法。

1043
00:45:18,090 --> 00:45:20,070
如果我们想问问
两个问题在一次？

1044
00:45:20,070 --> 00:45:22,200
>> 让我开了这个代替。

1045
00:45:22,200 --> 00:45:26,740
非开关，其原因
我们会看到另一个时间。

1046
00:45:26,740 --> 00:45:29,610
什么是新的语法吗？

1047
00:45:29,610 --> 00:45:32,760
目前，我正在玩游戏
其中，电脑提示

1048
00:45:32,760 --> 00:45:35,550
我，给我一个整数
1和10之间，

1049
00:45:35,550 --> 00:45:37,180
然后我判断用户的输入。

1050
00:45:37,180 --> 00:45:39,180
在英语的基础上，
你在这里看到的代码

1051
00:45:39,180 --> 00:45:41,530
在蓝色的，这是什么程序在做什么？

1052
00:45:41,530 --> 00:45:44,256

1053
00:45:44,256 --> 00:45:46,380
听众：[听不清]挑
一个或大或小的数目。

1054
00:45:46,380 --> 00:45:46,484
DAVID J.马兰：是的。

1055
00:45:46,484 --> 00:45:49,450
这只是裁定是否
我挑了个大，或中，

1056
00:45:49,450 --> 00:45:53,900
或基于一个非常小的数
小，中任意定义，

1057
00:45:53,900 --> 00:45:58,510
和大型这里，但通知
语法这就是新的就是这个。

1058
00:45:58,510 --> 00:46:02,340
有没有比int或等于少
签，或大于或等于签名，

1059
00:46:02,340 --> 00:46:05,430
其中一个是比其他，您
可以表达如Microsoft Word。

1060
00:46:05,430 --> 00:46:08,180
因此，在一种编程语言，你
通常只是做两个字符，

1061
00:46:08,180 --> 00:46:09,450
一前一后。

1062
00:46:09,450 --> 00:46:12,695
又是什么这可能
代表，符号与符号。

1063
00:46:12,695 --> 00:46:13,570
听众：[听不清]

1064
00:46:13,570 --> 00:46:13,680
DAVID J.马兰：是的。

1065
00:46:13,680 --> 00:46:16,910
这只是意味着因为它
事实证明，C的作者

1066
00:46:16,910 --> 00:46:19,120
使用单一符号，
你可能会认为

1067
00:46:19,120 --> 00:46:22,430
将是完美的概念
的和，已经用完，

1068
00:46:22,430 --> 00:46:27,300
居然这么符号与符号
抓住我们真正想要的情况。

1069
00:46:27,300 --> 00:46:30,610
>> 现在让我们在两个东西绊倒。

1070
00:46:30,610 --> 00:46:32,640
让我去进取，不断开拓的。

1071
00:46:32,640 --> 00:46:36,590
东西是有点令人担忧。

1072
00:46:36,590 --> 00:46:37,970
不精确C点。

1073
00:46:37,970 --> 00:46:40,260
让我介绍了两件事情。

1074
00:46:40,260 --> 00:46:44,720
一，请注意，我们所能做的
数学，因为就像以前一样，当

1075
00:46:44,720 --> 00:46:47,797
我们做了加两个数，x和y的。

1076
00:46:47,797 --> 00:46:49,380
这是什么程序显然是在做什么？

1077
00:46:49,380 --> 00:46:52,140
我不评论它，
我已经介绍％的楼

1078
00:46:52,140 --> 00:46:55,720
但我很快前面说
百分比f为浮点

1079
00:46:55,720 --> 00:46:56,970
值，这是实数。

1080
00:46:56,970 --> 00:46:59,520
东西带小数
点，这不是整数。

1081
00:46:59,520 --> 00:47:02,270
你觉得这个计划是
试图证明我在屏幕上？

1082
00:47:02,270 --> 00:47:05,060

1083
00:47:05,060 --> 00:47:06,050
是吗？

1084
00:47:06,050 --> 00:47:07,550
听众：一个比10的结果。

1085
00:47:07,550 --> 00:47:07,780
DAVID J.马兰：是的。

1086
00:47:07,780 --> 00:47:09,680
什么是1的结果除以10。

1087
00:47:09,680 --> 00:47:12,721
对，因为大家都有可能
长大了知道一个超过10

1088
00:47:12,721 --> 00:47:14,502
是什么？

1089
00:47:14,502 --> 00:47:16,220
是的，这只是1/10或0.1。

1090
00:47:16,220 --> 00:47:16,720
对？

1091
00:47:16,720 --> 00:47:19,010
因此，让我们看看这实际上是。

1092
00:47:19,010 --> 00:47:21,010
因此，让我继续前进，并保存。

1093
00:47:21,010 --> 00:47:21,970
让我去到这里。

1094
00:47:21,970 --> 00:47:26,360
请不精确点斜杠
不精确，并且还请注意，

1095
00:47:26,360 --> 00:47:29,380
在Linux环境下，你不
必须输入了不准确，并采取

1096
00:47:29,380 --> 00:47:30,010
整天。

1097
00:47:30,010 --> 00:47:32,910
它通常，如果你按下Tab键，就
将完成你的思想给你，

1098
00:47:32,910 --> 00:47:36,660
基于那些词语
可在当前目录。

1099
00:47:36,660 --> 00:47:37,160
行。

1100
00:47:37,160 --> 00:47:37,970
所以，你是对的。

1101
00:47:37,970 --> 00:47:41,239
一个除以10，事实上，0.1。

1102
00:47:41,239 --> 00:47:42,280
不过，我有点好奇。

1103
00:47:42,280 --> 00:47:44,196
而事实证明的printf
支持某些功能

1104
00:47:44,196 --> 00:47:48,700
因此，你可以指定不止
小数点的默认数量。

1105
00:47:48,700 --> 00:47:52,140
所以，如果我想看到10进制
点我可以做个百分点，

1106
00:47:52,140 --> 00:47:55,510
为占位符，点
10，给我10小数点，

1107
00:47:55,510 --> 00:47:58,140
然后还是浮点
值，和，为一边，

1108
00:47:58,140 --> 00:48:01,550
这是什么反斜线Ñ
显然，我们一直使用的是？

1109
00:48:01,550 --> 00:48:03,450
事实证明，这是一个
符号为一个新的生产线。

1110
00:48:03,450 --> 00:48:05,970
这是非常明确的方式
说法到计算机，

1111
00:48:05,970 --> 00:48:08,759
将光标移动到下一个
之后，你行就大功告成了。

1112
00:48:08,759 --> 00:48:10,800
我们将看看会发生什么
当我们不这样做。

1113
00:48:10,800 --> 00:48:12,430
>> 让我重新编译做出不准确。

1114
00:48:12,430 --> 00:48:15,320

1115
00:48:15,320 --> 00:48:18,356
现在点斜线不精确。

1116
00:48:18,356 --> 00:48:18,930
行。

1117
00:48:18,930 --> 00:48:19,780
仍然是对的。

1118
00:48:19,780 --> 00:48:21,512
一个除以10。

1119
00:48:21,512 --> 00:48:23,220
现在，我得到一个
有点好奇，但。

1120
00:48:23,220 --> 00:48:27,599
如果我看20十进制
指出，重新编译，重新运行，

1121
00:48:27,599 --> 00:48:29,390
并作为预留
速度快，你也可以使用

1122
00:48:29,390 --> 00:48:31,800
你的向上和向下箭头
翻阅历史记录，

1123
00:48:31,800 --> 00:48:35,476
所以你不必守
重新输入这些命令，回车。

1124
00:48:35,476 --> 00:48:36,910
呵呵。

1125
00:48:36,910 --> 00:48:39,220
我不知道在小学。

1126
00:48:39,220 --> 00:48:43,260
好了，所以让我
看到像29的地方了。

1127
00:48:43,260 --> 00:48:44,300
也许这只是一个侥幸。

1128
00:48:44,300 --> 00:48:46,907
也许我的电脑怪怪的。

1129
00:48:46,907 --> 00:48:47,990
这不是一个东西，对不对？

1130
00:48:47,990 --> 00:48:50,300
它做的事情确定性。

1131
00:48:50,300 --> 00:48:53,410
因此，请不精确。

1132
00:48:53,410 --> 00:48:54,890
OK，这是搞砸了。

1133
00:48:54,890 --> 00:48:57,620
那么到底是怎么回事？

1134
00:48:57,620 --> 00:49:00,160
>> 因此很明显，你
老师一直趴

1135
00:49:00,160 --> 00:49:03,900
给你这一切时间
原因，我们不久就会看到。

1136
00:49:03,900 --> 00:49:05,569
但是，让我们结束与另一个程序。

1137
00:49:05,569 --> 00:49:07,860
这是一个小程序
有人在几年前写的，

1138
00:49:07,860 --> 00:49:08,990
它实际上是一个比赛的一部分。

1139
00:49:08,990 --> 00:49:11,198
没有人真正编写代码
这样，如果你这样做，

1140
00:49:11,198 --> 00:49:12,880
这是文体上的问题。

1141
00:49:12,880 --> 00:49:14,660
但人们做到这一点的吹牛的权利。

1142
00:49:14,660 --> 00:49:17,260
要写出最混乱
看程序，

1143
00:49:17,260 --> 00:49:19,110
但是做一些有趣的事情。

1144
00:49:19,110 --> 00:49:23,930
和记我以为我们会离开
今天，在科尔顿发挥我们在这里，

1145
00:49:23,930 --> 00:49:27,840
要运行这个程序，
其中，即使在只使用

1146
00:49:27,840 --> 00:49:31,450
下在该文本为基础的
环境，给了我们这一点。

1147
00:49:31,450 --> 00:49:32,264
该死。

1148
00:49:32,264 --> 00:49:34,930
>> [笑]

1149
00:49:34,930 --> 00:49:36,800
>> 支持。

1150
00:49:36,800 --> 00:49:39,340
[听不清]Ç破折号L M。

1151
00:49:39,340 --> 00:49:42,885
你会看到神奇
咒语，我们不久就会看到。

1152
00:49:42,885 --> 00:49:45,780
[听不清]好吧。

1153
00:49:45,780 --> 00:49:51,592
现在，你甚至可以
做这样的事情。

1154
00:49:51,592 --> 00:49:52,340
就是这样。

1155
00:49:52,340 --> 00:49:56,410
对于CS50，我们将看到你在星期五。

1156
00:49:56,410 --> 00:49:58,910
>> [音乐播放]

1157
00:49:58,910 --> 00:52:38,390

1158
00:52:38,390 --> 00:52:41,440
>> [掌声]

1159
00:52:41,440 --> 00:52:42,812