1
00:00:11,375 --> 00:00:14,430
欢迎来到CS50 今天是本学期第一周的开始

2
00:00:14,430 --> 00:00:17,930
而我们想做的 是向你们展示

3
00:00:17,930 --> 00:00:20,970
一个你们也许每天都会遇到 但并不真正了解

4
00:00:20,970 --> 00:00:22,280
它是什么的的设备

5
00:00:22,280 --> 00:00:26,000
这个设备你们现在大概都很熟悉

6
00:00:26,000 --> 00:00:32,972
[播放视频]

7
00:00:32,972 --> 00:00:36,150
这个是数学与机械技术的巨大成就

8
00:00:36,150 --> 00:00:39,120
在哈佛大学的全新自动计算机

9
00:00:39,120 --> 00:00:43,220
把编码后复杂的数学问题通过磁带放入这台机器

10
00:00:43,220 --> 00:00:47,840
问题就会被正确解决 而所用的时间仅为人手计算

11
00:00:47,840 --> 00:00:49,090
的千百分之一

12
00:01:00,090 --> 00:01:04,080
为了加快所有类型的数学与科学研究

13
00:01:04,080 --> 00:01:07,860
这台巨型大脑会为美国海军工作

14
00:01:07,860 --> 00:01:09,180
直到战争结束

15
00:01:18,180 --> 00:01:18,600
[视频播放结束]

16
00:01:18,600 --> 00:01:21,980
这就是你们可以在

17
00:01:21,980 --> 00:01:23,540
哈佛科学中心看到的东西

18
00:01:23,540 --> 00:01:25,910
实际上 你们看到的只是它的一部分

19
00:01:25,910 --> 00:01:28,800
展示出来的只是机器的一部分这台设备叫做

20
00:01:28,800 --> 00:01:31,970
Mark I，而它本质上就是一台巨大的计算器

21
00:01:31,970 --> 00:01:36,250
它的下一代是Mark II 从Mark II身上我们

22
00:01:36,250 --> 00:01:39,210
真正开始可以学到一些词汇

23
00:01:39,210 --> 00:01:43,780
这个视频是首次记录下的东西 你们在

24
00:01:43,780 --> 00:01:45,860
本学期的课程中会逐渐了解

25
00:01:45,860 --> 00:01:48,460
这样东西 就是故障(Bug)

26
00:01:48,460 --> 00:01:52,030
某一天 Mark II无法正常运转

27
00:01:52,030 --> 00:01:55,930
在仔细检查过后 人们发现 确实有个故障(Bug/昆虫)－－一只蛾子

28
00:01:55,930 --> 00:01:56,910
那只蛾子

29
00:01:56,910 --> 00:01:57,610
在机器里

30
00:01:57,610 --> 00:02:03,130
从那之后 我们就将程序中的问题叫做故障/昆虫

31
00:02:03,130 --> 00:02:05,330
关于这我们以后还会讲到

32
00:02:05,330 --> 00:02:08,919
说到视频 如果你们还不知道的话 CS50

33
00:02:08,919 --> 00:02:09,669
会被录下来

34
00:02:09,669 --> 00:02:13,330
在一节课结束后 我们一般会发布一个经过

35
00:02:13,330 --> 00:02:17,240
初校的版本 一两天之后 我们会上传一个更高清

36
00:02:17,240 --> 00:02:18,490
也更高质量的版本

37
00:02:18,490 --> 00:02:21,800
你们也许记得Vanessa 就是先前体验了Google Glass的

38
00:02:21,800 --> 00:02:23,540
这一次我想起来向她收费了

39
00:02:23,540 --> 00:02:26,450
所以如果课后你们也想要体验一下 今天应该是可以的

40
00:02:26,450 --> 00:02:30,816
如果你们想知道Vanessa那一天看到了什么

41
00:02:30,816 --> 00:02:35,260
让我把我笔记本电脑的声音调高些

42
00:02:35,260 --> 00:02:35,690
[视频回放]

43
00:02:35,690 --> 00:02:37,620
让我把它调好

44
00:02:37,620 --> 00:02:38,070
好的

45
00:02:38,070 --> 00:02:40,930
所以碰一下它

46
00:02:40,930 --> 00:02:41,720
好

47
00:02:41,720 --> 00:02:43,470
好的 Glass

48
00:02:43,470 --> 00:02:44,720
录视频

49
00:02:47,240 --> 00:02:48,640
好的

50
00:02:48,640 --> 00:02:50,446
Vanessa?

51
00:02:50,446 --> 00:02:50,870
[视频回放结束]

52
00:02:50,870 --> 00:02:53,485
好 所以在课程结束后 你们当中的大多数人

53
00:02:53,485 --> 00:02:56,540
都没法体验的原因 就是因为我把Glass放下后

54
00:02:56,540 --> 00:02:59,505
又录了一个小时的视频 都是录的我自己

55
00:02:59,505 --> 00:03:04,010
所以今天 我会把它关掉 不过谢谢Vanessa

56
00:03:04,010 --> 00:03:05,420
这么好地配合

57
00:03:05,420 --> 00:03:08,330
同时 在继续今天课程之间 我有一些通知

58
00:03:08,330 --> 00:03:11,120
首先 CS50的一项传统 就是尽我们所能

59
00:03:11,120 --> 00:03:12,630
让这么大的课堂变小

60
00:03:12,630 --> 00:03:16,640
为了达到这个目标 基本上每周五 我们会

61
00:03:16,640 --> 00:03:20,160
在哈佛广场边上的Fire and Ice 餐厅聚餐 每周会有30－40个学生 我

62
00:03:20,160 --> 00:03:22,520
一些助教参加 非常轻松的午餐

63
00:03:22,520 --> 00:03:26,280
我们经常会邀请业内的朋友 上过这堂课的校友

64
00:03:26,280 --> 00:03:30,340
学校的校友 来聊聊天 讲一讲在学校时

65
00:03:30,340 --> 00:03:32,260
及从学校毕业后的生活

66
00:03:32,260 --> 00:03:35,570
所以如果你想参加第一场聚餐

67
00:03:35,570 --> 00:03:38,640
会在周五下午1:15举行的话 请点击此链接

68
00:03:38,640 --> 00:03:40,830
位置有限 所以先到先得

69
00:03:40,830 --> 00:03:43,880
但是我们会经常举办这个活动 所以如果你没能参加这一次聚餐的话

70
00:03:43,880 --> 00:03:45,800
也不用担心

71
00:03:45,800 --> 00:03:48,960
现在 说到这门课提供的课程资源

72
00:03:48,960 --> 00:03:51,500
真的很多 而且如果你还没有上课程网站上看过

73
00:03:51,500 --> 00:03:54,310
在"讲课"条目下的话的资源的话 你能在

74
00:03:54,310 --> 00:03:57,070
视频或者其他电子资源中

75
00:03:57,070 --> 00:03:58,435
找到我们上周所做的所有事

76
00:03:58,435 --> 00:04:01,210
除了视频 你也会发现 所有的讲课都有

77
00:04:01,210 --> 00:04:03,290
全文文本可以看

78
00:04:03,290 --> 00:04:08,260
所以如果我们回到视频有Vanessa的这里

79
00:04:08,260 --> 00:04:12,010
然后看一下屏幕的底下 实际上 不是周五的课

80
00:04:12,010 --> 00:04:15,060
让我们看下周三的课  因为这项功能

81
00:04:15,060 --> 00:04:17,870
需要一些时间才能完成

82
00:04:17,870 --> 00:04:22,260
不过好歹你们能够看到我 或者志愿者们说的每一个字

83
00:04:22,260 --> 00:04:23,270
不仅如此

84
00:04:23,270 --> 00:04:25,700
你还可以搜索它 你可以随便点击一句话

85
00:04:25,700 --> 00:04:29,250
跳转到视频的相应位置 这样我们的资源就

86
00:04:29,250 --> 00:04:30,620
更容易操作使用了

87
00:04:30,620 --> 00:04:34,550
不过如果你不想要这么仔细地去看 你会发现

88
00:04:34,550 --> 00:04:39,710
这里有一个小菜单 上面写着 1.5倍速 2倍速 或者如果

89
00:04:39,710 --> 00:04:42,100
你觉得我已经说得太快了 0.75倍速

90
00:04:42,100 --> 00:04:45,190
所以请记住有这些功能你们可以利用

91
00:04:45,190 --> 00:04:49,120
除此之外 在每堂课中 我们也

92
00:04:49,120 --> 00:04:50,530
给大家提供很多资源

93
00:04:50,530 --> 00:04:55,240
幻灯片 代码示例 所以我在台上演示的 或者在课前做好的东西

94
00:04:55,240 --> 00:04:58,160
我们都会提供给大家 这样你就可以在家或者在课堂上使用它们了

95
00:04:58,160 --> 00:05:01,280
不过我们想到 今年我们会首次尝试

96
00:05:01,280 --> 00:05:04,240
给大家提供如何使用这些示例的教学

97
00:05:04,240 --> 00:05:08,120
我一直都在想CS50课堂内容价值在哪里

98
00:05:08,120 --> 00:05:11,450
我在想你们现在这样坐在这里 看着我站在这儿

99
00:05:11,450 --> 00:05:15,020
跟你们讲话 当我们的材料 我们的示例

100
00:05:15,020 --> 00:05:17,020
变得更复杂的时候 究竟多少用

101
00:05:17,020 --> 00:05:20,790
因为不可避免的 在一段时间后 有些人就会走神

102
00:05:20,790 --> 00:05:24,310
然后你就会错过一些示例的关键点 而课程接下来的部分

103
00:05:24,310 --> 00:05:27,720
你也就没法跟上了 这并不是时间的

104
00:05:27,720 --> 00:05:31,330
最佳利用方式 不论对于你还是对于整个课堂来说

105
00:05:31,330 --> 00:05:33,920
所以我们想要尝试的 特别是针对一些

106
00:05:33,920 --> 00:05:37,700
比较复杂的示例 因为我有可能没法面面俱到

107
00:05:37,700 --> 00:05:41,560
或是我没有足够的时间去讲解时 或是你们听的时候正好走神了

108
00:05:41,560 --> 00:05:45,500
对于这些示例 我们会做一些教学 所以如果你们去看

109
00:05:45,500 --> 00:05:51,410
上周五的视频页面 在"示例"一栏底下 你会发现

110
00:05:51,410 --> 00:05:54,050
在周五的课程下 有一个链接指向"教学"

111
00:05:54,050 --> 00:05:55,780
它们的形式会随时间而变

112
00:05:55,780 --> 00:05:58,080
当下 我们在用You Tube视频播放列表

113
00:05:58,080 --> 00:06:00,980
但我和我们的制作组之后会做的

114
00:06:00,980 --> 00:06:04,480
是为每一个示例都制作新的教学 希望我们能更

115
00:06:04,480 --> 00:06:07,550
清晰地指出 从每一个示例中 你应该能学到什么

116
00:06:07,550 --> 00:06:10,560
所以你会发现 上一周 我们在课上讲的所有的Scratch示例

117
00:06:10,560 --> 00:06:12,950
都按时间顺序列出了

118
00:06:12,950 --> 00:06:15,840
所以请按需要自行取用这些资源

119
00:06:15,840 --> 00:06:19,140
说真的 这门课的一个主题 就是

120
00:06:19,140 --> 00:06:21,870
多种多样的资源

121
00:06:21,870 --> 00:06:23,260
会比你一学期能学到的都要多

122
00:06:23,260 --> 00:06:23,980
但这是有意为之

123
00:06:23,980 --> 00:06:26,990
我们希望你们每一个人 基于自己的学习习惯

124
00:06:26,990 --> 00:06:28,070
都可以自行选择

125
00:06:28,070 --> 00:06:29,790
所以如果你觉得课堂上的讲课对你有帮助 非常好

126
00:06:29,790 --> 00:06:31,090
如果小班课适合你 也很好

127
00:06:31,090 --> 00:06:32,930
如果示例教学更适合你 也很好

128
00:06:32,930 --> 00:06:36,980
真的 就看你觉得哪一种形式更适合你

129
00:06:36,980 --> 00:06:40,380
最后 感谢一位这门课的校友 我们还会提供

130
00:06:40,380 --> 00:06:41,890
课程的官方版笔记

131
00:06:41,890 --> 00:06:46,270
所以你们不用低着头飞速记下

132
00:06:46,270 --> 00:06:49,880
在课上听到的东西了 我们会为你们提供

133
00:06:49,880 --> 00:06:53,410
我们认为最重要的笔记 这样你们在课上就不会分心

134
00:06:53,410 --> 00:06:57,150
也就是说如果你在课堂上真正想投入 你就能真正投入

135
00:06:57,150 --> 00:07:00,110
有时间看看课上在发生什么 你的同学们在台上做什么 屏幕上在放什么

136
00:07:00,110 --> 00:07:03,570
而不只是把我说的话记下来

137
00:07:03,570 --> 00:07:06,730
所以请记住所有这资源你们都可以利用

138
00:07:06,730 --> 00:07:09,210
回答一位同学的问题 小班课 这周三会开始

139
00:07:09,210 --> 00:07:12,050
我们会等到其他课都定下来后再开始

140
00:07:12,050 --> 00:07:14,420
这样我们就可以减少要做的改动

141
00:07:14,420 --> 00:07:20,010
不过这周末 从周日开始 会有一场仅有一次的活动

142
00:07:20,010 --> 00:07:21,360
我们把它叫做超级讨论课

143
00:07:21,360 --> 00:07:23,990
我们会把它录下来 这样无法参加的人也能看到

144
00:07:23,990 --> 00:07:28,880
这门课的助教们会帮大家了解这门课中C语言的部分

145
00:07:28,880 --> 00:07:32,330
在第一个练习 也就是我们的第一个C语言练习

146
00:07:32,330 --> 00:07:33,140
布置下来的时候

147
00:07:33,140 --> 00:07:36,240
我们会有非强制性的小班课程

148
00:07:36,240 --> 00:07:40,010
而每周 我们超50个助教们

149
00:07:40,010 --> 00:07:41,600
还会带内容相同的小班课

150
00:07:41,600 --> 00:07:45,130
在周日 周一或周二 我们有90分钟 非常传统的小班课

151
00:07:45,130 --> 00:07:48,020
可以让同学们实际操作

152
00:07:48,020 --> 00:07:50,800
以及加深对课程材料的理解

153
00:07:50,800 --> 00:07:53,820
不再赘言 让我向大家介绍这门课的核心班底

154
00:07:53,820 --> 00:07:57,380
他们和我一样 位居幕后 让一切得以实现

155
00:07:57,380 --> 00:08:02,670
Rob Lauren Joseph和Lucas

156
00:08:02,670 --> 00:08:05,770
他们都为这门课辛苦了很久了

157
00:08:05,770 --> 00:08:08,450
RJ是我们团队的另一名成员

158
00:08:08,450 --> 00:08:11,720
他今天不能到场 但是他叫我带一张他的照片过来

159
00:08:11,720 --> 00:08:14,600
我不知道他是不是想要我带这张 不过这就是他

160
00:08:14,600 --> 00:08:18,350
请让我们的团队和大家问好 并介绍一下自己

161
00:08:18,350 --> 00:08:22,260
这样你们就不仅认识自己的助教 也认识他们了

162
00:08:22,260 --> 00:08:23,490
大家好

163
00:08:23,490 --> 00:08:24,740
我叫Lauren Carvalho

164
00:08:24,740 --> 00:08:26,900
我是Leverett宿舍的舍管

165
00:08:26,900 --> 00:08:31,120
同时 我也很高兴今年能当CS50的核心助教

166
00:08:31,120 --> 00:08:35,830
CS50很有挑战性 而且课堂上人数很多

167
00:08:35,830 --> 00:08:38,780
所以你们如果有任何疑问 如果觉得自己掉队了

168
00:08:38,780 --> 00:08:43,840
你可以联系我们当中的任何一个 只要发邮件至heads@cs50.net 或者你也可以联系我

169
00:08:43,840 --> 00:08:46,330
如果你想和我的金毛狗宝宝玩的话

170
00:08:46,330 --> 00:08:48,060
这是Lucas

171
00:08:48,060 --> 00:08:48,560
大家好

172
00:08:48,560 --> 00:08:49,330
我是Lucas Freitas

173
00:08:49,330 --> 00:08:51,880
我现在大三

174
00:08:51,880 --> 00:08:53,630
专业是计算机与语言学

175
00:08:53,630 --> 00:08:58,030
我来自巴西 但我对东亚研究也有兴趣

176
00:08:58,030 --> 00:09:00,740
所以如果你对计算机或者语言学

177
00:09:00,740 --> 00:09:01,870
或者任何什么事有问题的话 请尽管问我

178
00:09:01,870 --> 00:09:05,630
当然 特别是对CS50的问题

179
00:09:05,630 --> 00:09:05,880
大家好

180
00:09:05,880 --> 00:09:06,265
我是 Joseph

181
00:09:06,265 --> 00:09:11,360
我今年大四 专业是计算机 住在Elliott宿舍

182
00:09:11,360 --> 00:09:13,500
嗯 就…

183
00:09:13,500 --> 00:09:16,530
你们会看到我带着一个那种特别大的相机在旁边

184
00:09:16,530 --> 00:09:21,110
我是CS50的摄影师 而学生们

185
00:09:21,110 --> 00:09:25,140
经常以为我是个亚洲来的游客

186
00:09:25,140 --> 00:09:29,220
所以 如果你们看到我带着相机 请不要跑开

187
00:09:29,220 --> 00:09:32,960
只要微笑就行了 不用害羞

188
00:09:32,960 --> 00:09:34,870
我希望你们会喜欢CS50

189
00:09:34,870 --> 00:09:38,690
我上这个课时就非常喜欢它 所以我已经

190
00:09:38,690 --> 00:09:41,164
当了三年助教了

191
00:09:41,164 --> 00:09:41,570
大家好

192
00:09:41,570 --> 00:09:42,550
我是Rob

193
00:09:42,550 --> 00:09:46,240
这是我第四个学期教CS50了

194
00:09:46,240 --> 00:09:47,430
我五月刚刚毕业

195
00:09:47,430 --> 00:09:49,650
原来住在Kirkland

196
00:09:49,650 --> 00:09:53,670
我对这一学期感到很兴奋 我希望你们也一样

197
00:09:53,670 --> 00:09:56,650
谢谢今年的核心助教们 当然 还有RJ

198
00:09:59,910 --> 00:10:02,310
关于资源 我还有几点要提下

199
00:10:02,310 --> 00:10:04,090
首先 练习0已经在发在网上了

200
00:10:04,090 --> 00:10:06,620
这个练习只有一个版本 也就是说 这是给

201
00:10:06,620 --> 00:10:07,610
这是给全班人的

202
00:10:07,610 --> 00:10:10,940
从练习1开始 大多数的练习都会有黑客版

203
00:10:10,940 --> 00:10:14,660
这种版本会增加一点挑战

204
00:10:14,660 --> 00:10:17,400
但涵盖的内容是相同的

205
00:10:17,400 --> 00:10:21,400
请上课程网站看一下练习0的具体要求

206
00:10:21,400 --> 00:10:25,140
这星期 办公室时间也会开始 今晚 明天和周三

207
00:10:25,140 --> 00:10:27,670
周四则是在校园里众多个食堂

208
00:10:27,670 --> 00:10:32,140
请点击cs50.net/ohs查看办公室时间 而且要知道

209
00:10:32,140 --> 00:10:34,430
这是个非正式的场合 在学期开始的时候

210
00:10:34,430 --> 00:10:37,190
你的头脑需要休息一下时 你可以带着笔记本过来

211
00:10:37,190 --> 00:10:40,500
带上几个朋友 和课程的助教及助理聊聊天

212
00:10:40,500 --> 00:10:41,750
有什么问题 都可以问

213
00:10:41,750 --> 00:10:45,320
我必须再次强调 就算是针对Scratch和练习0

214
00:10:45,320 --> 00:10:47,110
也没有什么问题是蠢问题

215
00:10:47,110 --> 00:10:51,200
作为学生 没有什么问题是不好意思问的

216
00:10:51,200 --> 00:10:53,940
请好好利用这项资源

217
00:10:53,940 --> 00:10:56,430
这学期 办公室时间会一直开放

218
00:10:56,430 --> 00:10:57,840
CS50 论坛 也一样

219
00:10:57,840 --> 00:11:00,900
这是课程的网上论坛链接在这里

220
00:11:00,900 --> 00:11:04,490
得益于我们的教学团队

221
00:11:04,490 --> 00:11:05,580
我们在上课时也会同时关注这个论坛

222
00:11:05,580 --> 00:11:08,390
所以如果在课程进行中你有问题 因为我有东西没讲清楚

223
00:11:08,390 --> 00:11:11,690
或者根本没讲到 请一定即时在网上

224
00:11:11,690 --> 00:11:15,700
用你的笔记本 手机把问题问出来 我们会尽力在当下就

225
00:11:15,700 --> 00:11:17,410
回应这些问题

226
00:11:17,410 --> 00:11:21,500
对CS50还有什么问题么?

227
00:11:21,500 --> 00:11:23,930
最后一点

228
00:11:23,930 --> 00:11:25,530
修课时选择 过 /不过 这个问题

229
00:11:25,530 --> 00:11:28,550
在你们最终确定学习卡时 你们会发现

230
00:11:28,550 --> 00:11:32,360
所有学生都可以选择过/不过

231
00:11:32,360 --> 00:11:36,350
而这个选择其实是为了帮助人适应像CS50这样的课的

232
00:11:36,350 --> 00:11:40,510
也就是说 如果你发现自己在半夜2点 3点仍在苦苦纠结

233
00:11:40,510 --> 00:11:43,960
因为你离成功只有1%了

234
00:11:43,960 --> 00:11:47,510
但你却还有很多其他的事要做 我想最好利用时间的方式

235
00:11:47,510 --> 00:11:51,260
是去完成其他那些事

236
00:11:51,260 --> 00:11:52,780
这样你可以最有效地利用你的时间

237
00:11:52,780 --> 00:11:56,950
而选择 过/不过 就可以让你安心 因为你知道

238
00:11:56,950 --> 00:12:00,530
99%的情况下你都做得很好了

239
00:12:00,530 --> 00:12:03,790
同样 如果你在上这门课前没有任何背景知识

240
00:12:03,790 --> 00:12:07,960
或者你觉得你了解的不如你的同学多

241
00:12:07,960 --> 00:12:13,210
不管怎么样 这都是一个让你切身感受

242
00:12:13,210 --> 00:12:16,590
实际体验课程 勇敢尝试 就像

243
00:12:16,590 --> 00:12:18,500
我许多年以前 上课时选择及格/不及格一样

244
00:12:18,500 --> 00:12:21,850
就像我上周所说的 如果这门课像其他课一样

245
00:12:21,850 --> 00:12:25,090
不能用及格/不及格修的话 我也许就不会上这门课了

246
00:12:25,090 --> 00:12:28,310
虽然我在上了五星期后就改变了主意

247
00:12:28,310 --> 00:12:32,400
换成了等第成绩 当然 你们也可以这样做

248
00:12:32,400 --> 00:12:32,990
好的

249
00:12:32,990 --> 00:12:37,380
所以我们上这周看了这个 而今天我们会马上

250
00:12:37,380 --> 00:12:39,890
来看一些更难懂的东西

251
00:12:39,890 --> 00:12:42,300
不过基本的想法还是一样

252
00:12:42,300 --> 00:12:45,540
我们用什么词来形容

253
00:12:45,540 --> 00:12:47,690
这样的一片拼图呢

254
00:12:47,690 --> 00:12:48,510
一个语句

255
00:12:48,510 --> 00:12:50,020
你可以管它叫很多东西

256
00:12:50,020 --> 00:12:51,870
不过我们就叫它一个语句好了

257
00:12:51,870 --> 00:12:53,200
一个语句可以告诉程序

258
00:12:53,200 --> 00:12:55,290
或者在Scratch里 告诉sprite

259
00:12:55,290 --> 00:12:56,520
去做某件事

260
00:12:56,520 --> 00:12:58,430
在这里 是说大家好

261
00:12:58,430 --> 00:13:01,450
那这个我们叫做什么呢?

262
00:13:01,450 --> 00:13:03,560
没错 是个布尔表达式

263
00:13:03,560 --> 00:13:07,380
布尔表达式只有真假两个取值

264
00:13:07,380 --> 00:13:10,530
所以Scratch将它们画成这个形状 而且加了一个问号

265
00:13:10,530 --> 00:13:14,510
表示这个问题的答案非真即假 是或者否

266
00:13:14,510 --> 00:13:15,910
1或者是0

267
00:13:15,910 --> 00:13:19,290
我们把这些布尔表达式放在这种建构中

268
00:13:19,290 --> 00:13:21,010
这种建构叫做

269
00:13:21,010 --> 00:13:22,460
条件 或者 分支

270
00:13:22,460 --> 00:13:25,600
而在Scratch里的这个条件 有个位置可以

271
00:13:25,600 --> 00:13:28,260
放刚才的种形状 这个位置可以让你

272
00:13:28,260 --> 00:13:32,670
把布尔表达式拖过来 然后告诉程序

273
00:13:32,670 --> 00:13:36,410
如果布尔表达式是真的 那么就执行这一组命令 这一组语句

274
00:13:36,410 --> 00:13:39,320
否则 就执行另一组命令

275
00:13:39,320 --> 00:13:41,270
而且要记住 你可以嵌套这些东西

276
00:13:41,270 --> 00:13:44,170
尽管视觉上来看 这片拼图上没多大空间

277
00:13:44,170 --> 00:13:47,820
但是Scratch会放大或缩小你选择的拼图

278
00:13:47,820 --> 00:13:51,410
这样你可以通过嵌套得到一个三叉路口

279
00:13:51,410 --> 00:13:53,870
if(如果), else if(否则), else(其他情况)

280
00:13:53,870 --> 00:13:58,100
你可还以继续不断嵌套

281
00:13:58,100 --> 00:14:02,520
所以最后 我们会看到这样一个建构 也就是一个循环

282
00:14:02,520 --> 00:14:05,690
也就是说 它会不断重复做某件事

283
00:14:05,690 --> 00:14:09,250
在这里 它正好会执行有限次

284
00:14:09,250 --> 00:14:12,890
但我们也看过一个例子 那里面执行的次数来自一个变量

285
00:14:12,890 --> 00:14:13,690
所以它会变

286
00:14:13,690 --> 00:14:16,910
我们还看过一个永久循环块

287
00:14:16,910 --> 00:14:19,590
它会让我们无限次循环

288
00:14:19,590 --> 00:14:23,300
所以Scratch 2.0有的另一个建构 那些已经

289
00:14:23,300 --> 00:14:26,330
已经懂得一些背景知识的人应该

290
00:14:26,330 --> 00:14:27,080
对这个建构已经很熟悉了

291
00:14:27,080 --> 00:14:29,910
我们把这种东西叫做什么

292
00:14:29,910 --> 00:14:32,540
我们把它们叫做功能 也叫做子程序

293
00:14:32,540 --> 00:14:35,030
字义上来说它们有一点点不同 不过我们就叫它们功能 好了

294
00:14:35,030 --> 00:14:39,950
在Scratch中功能 是一片自己定制的拼图

295
00:14:39,950 --> 00:14:43,670
你可以自己造出一片新拼图

296
00:14:43,670 --> 00:14:47,190
在这里 它叫做 cough 会出现在其他

297
00:14:47,190 --> 00:14:48,730
Scratch中已有的拼图中

298
00:14:48,730 --> 00:14:52,010
MIT没有造出这一块拼图 造出它的人是你

299
00:14:52,010 --> 00:14:57,600
所以一个功能可以让你创造出新的动作 你可以为它命名

300
00:14:57,600 --> 00:14:59,200
然后去使用它

301
00:14:59,200 --> 00:15:04,690
真正地在程序中 一次又一次地使用它 让你不用

302
00:15:04,690 --> 00:15:08,600
等着MIT之类的在Scratch中开发新功能

303
00:15:08,600 --> 00:15:12,460
你可以自己造出一片片拼图 然后

304
00:15:12,460 --> 00:15:13,600
在你自己的程序中重复使用它

305
00:15:13,600 --> 00:15:17,520
我们会在今天及以后重复看见一个相关的例子

306
00:15:17,520 --> 00:15:20,960
所以在今天 我们会转向一些更复杂难懂的东西

307
00:15:20,960 --> 00:15:24,350
但也是更有用 更有表现力

308
00:15:24,350 --> 00:15:28,110
更能代表我们本学期前进的方向－－

309
00:15:28,110 --> 00:15:28,800
学习不同的

310
00:15:28,800 --> 00:15:30,800
表示代码及源代码的语言

311
00:15:30,800 --> 00:15:34,720
实际上 源代码 不是电脑

312
00:15:34,720 --> 00:15:37,400
一般会运行的东西

313
00:15:37,400 --> 00:15:39,860
源代码看上去是这样的

314
00:15:39,860 --> 00:15:43,010
所以这大概是我们用C语言写出的最简单的程序了

315
00:15:43,010 --> 00:15:46,670
我们马上会把这个程序拆分

316
00:15:46,670 --> 00:15:49,260
如果现在它看起来还像希腊文那么难懂的话 相信我

317
00:15:49,260 --> 00:15:54,040
一两周之后 你就会觉得它再熟悉不过了

318
00:15:54,040 --> 00:15:57,780
而这也很有代表性 代表你们将会不断适应

319
00:15:57,780 --> 00:15:59,870
越来越复杂的例子们

320
00:15:59,870 --> 00:16:03,100
但通常 你不能直接跑这个代码

321
00:16:03,100 --> 00:16:06,750
你得将它变成电脑能读懂的东西

322
00:16:06,750 --> 00:16:09,840
所以 我们需要一个叫做 编译器 的东西

323
00:16:09,840 --> 00:16:13,910
编译器是一个将你们刚刚看到的源代码

324
00:16:13,910 --> 00:16:17,680
输入 输出0和1

325
00:16:17,680 --> 00:16:19,210
也就是目标代码的程序

326
00:16:19,210 --> 00:16:23,190
那些0和1

327
00:16:23,190 --> 00:16:26,310
就是最终能被你的Mac或是PC读懂的东西

328
00:16:26,310 --> 00:16:30,050
如果你听过因特尔公司的Intel Inside广告运动

329
00:16:30,050 --> 00:16:32,800
这是说一家叫因特尔的公司 制造了

330
00:16:32,800 --> 00:16:34,130
你电脑的大脑

331
00:16:34,130 --> 00:16:37,270
也就是CPU 中央处理器

332
00:16:37,270 --> 00:16:39,640
而它读得懂

333
00:16:39,640 --> 00:16:40,880
0与1

334
00:16:40,880 --> 00:16:46,330
将源代码转换成目标代码的这项过程

335
00:16:46,330 --> 00:16:49,130
我们马上会通过一些命令来完成

336
00:16:49,130 --> 00:16:53,070
而你会得到一堆0与1 它们代表着特定的语句

337
00:16:53,070 --> 00:16:56,000
而这是由因特尔的员工们决定的

338
00:16:56,000 --> 00:16:58,810
现在 我只是看一眼这些0和1的话

339
00:16:58,810 --> 00:16:59,890
我并不知道它们代表着什么

340
00:16:59,890 --> 00:17:01,420
当今大多数人都做不到

341
00:17:01,420 --> 00:17:04,900
但在其中 有一个排列代表着

342
00:17:04,900 --> 00:17:06,349
打印输出

343
00:17:06,349 --> 00:17:10,460
某处也有另一个组0与1代表着

344
00:17:10,460 --> 00:17:16,940
永久循环或者重复10次或者甚至是 喵

345
00:17:16,940 --> 00:17:20,000
如果那也是一个能包含声音的程序的话

346
00:17:20,000 --> 00:17:24,390
长话短说 人们决定 就像我们对ASCII做的那样

347
00:17:24,390 --> 00:17:27,480
--上周我们讲到的字母--人们决定

348
00:17:27,480 --> 00:17:32,200
用更复杂的0与1的排列来表示更复杂的动作

349
00:17:32,200 --> 00:17:35,650
例如打印输出 或者说话 或者 喵

350
00:17:35,650 --> 00:17:38,640
所以今天 以及今后的课程中

351
00:17:38,640 --> 00:17:41,820
我们就默认已经有人知道两者如何匹配

352
00:17:41,820 --> 00:17:45,560
我们 虽然知道我们站在前人的肩膀上

353
00:17:45,560 --> 00:17:49,340
但却还是认为这一切都是

354
00:17:49,340 --> 00:17:50,300
在魔术师的斗篷下神秘进行的

355
00:17:50,300 --> 00:17:53,840
但我们更感兴趣的 是如何在前人的基础上

356
00:17:53,840 --> 00:17:55,880
创造更多有趣的东西

357
00:17:55,880 --> 00:17:58,900
我们在Scratch中写出的第一个程序  就是这个

358
00:17:58,900 --> 00:18:00,600
特别简单的 hello world

359
00:18:00,600 --> 00:18:05,100
你可以把它看做 上周五支配Scratch行动

360
00:18:05,100 --> 00:18:07,280
的主要程序

361
00:18:07,280 --> 00:18:11,510
今天 我们会开始把Scratch中的拼图翻译成

362
00:18:11,510 --> 00:18:16,040
用C语言写出的源代码 这样一来 上周五看上去是这样的东西

363
00:18:16,040 --> 00:18:20,230
从今天起 就会是这样了

364
00:18:20,230 --> 00:18:21,860
当然 也更难懂了

365
00:18:21,860 --> 00:18:25,010
看着这么多引号 分号 括号 确实很容易

366
00:18:25,010 --> 00:18:27,760
让人分心又糊涂

367
00:18:27,760 --> 00:18:32,350
但如果你不去看那些你不懂的 而是

368
00:18:32,350 --> 00:18:35,960
关注其中的精华的话 你一定像我一样 会看见

369
00:18:35,960 --> 00:18:40,360
hello, world 这句话在上面是一个紫色的语句

370
00:18:40,360 --> 00:18:44,790
而关键词 main 概念上来说 就等同于

371
00:18:44,790 --> 00:18:46,350
"当点击绿色旗子时"

372
00:18:46,350 --> 00:18:49,820
也就是说 在Scratch中 我们执行了 hello world 这个程序

373
00:18:49,820 --> 00:18:53,360
用了两片拼图 而在C中 我们要用

374
00:18:53,360 --> 00:18:55,510
这四行有些难懂的话来执行

375
00:18:55,510 --> 00:18:58,130
但若我们更深入地研究一下 你会发现这些白色的字

376
00:18:58,130 --> 00:19:02,730
每一个都有重要的含义

377
00:19:02,730 --> 00:19:05,880
而大多数我们的程序也都会看上去与之类似

378
00:19:05,880 --> 00:19:08,980
所以一个语句 也就是在周五看上去还是说 hello world

379
00:19:08,980 --> 00:19:12,020
的东西 在周一就会看上去像这样了

380
00:19:12,020 --> 00:19:15,250
printf ("hello, world").

381
00:19:15,250 --> 00:19:17,700
这里还有一个怪怪的\n 有括号

382
00:19:17,700 --> 00:19:18,490
还有分号

383
00:19:18,490 --> 00:19:21,950
但是 今天我们学到的最重要的一点就是

384
00:19:21,950 --> 00:19:25,710
将图像格式的东西翻译成文字格式

385
00:19:25,710 --> 00:19:28,820
所以上周看上去像这样的一个循环

386
00:19:28,820 --> 00:19:30,140
在这周看上去就会是这样

387
00:19:30,140 --> 00:19:33,020
我必须要说清楚 就像Scratch一样 我们有

388
00:19:33,020 --> 00:19:34,110
不同的方法可以达到相同的目的

389
00:19:34,110 --> 00:19:38,860
在C中也是这样 我要给你们看的不是唯一的方法

390
00:19:38,860 --> 00:19:43,230
而是把这个永久循环翻译成C语言的方法之一

391
00:19:43,230 --> 00:19:44,980
这个循环 会重复10次

392
00:19:44,980 --> 00:19:47,580
第一次看这些代码确实会很让人费解

393
00:19:47,580 --> 00:19:49,860
但为了在之后执行它

394
00:19:49,860 --> 00:19:51,990
我们要来用一个 for循环

395
00:19:51,990 --> 00:19:56,150
显然 这里有些语法有点复杂 又有i＝

396
00:19:56,150 --> 00:19:59,740
还有0 但是今天在我们研究过它之后

397
00:19:59,740 --> 00:20:04,260
你就会发现这都只是在做一些简单的算法

398
00:20:04,260 --> 00:20:07,720
在这里 目的是要让我们从0升到9或是10

399
00:20:07,720 --> 00:20:11,570
最后 变量 变量是一种储存器

400
00:20:11,570 --> 00:20:14,290
左边是上周我们看到的

401
00:20:14,290 --> 00:20:15,920
而这周 它就会变成这样

402
00:20:15,920 --> 00:20:17,870
但我们后面还会介绍给多

403
00:20:17,870 --> 00:20:20,700
上周 布尔表达式看上去是这样的

404
00:20:20,700 --> 00:20:23,370
这一周 它们会变成这样

405
00:20:23,370 --> 00:20:24,890
而这一个其实挺让人安心的

406
00:20:24,890 --> 00:20:27,680
因为它基本上和绿色的区块一样简单

407
00:20:27,680 --> 00:20:31,115
不过又一次 我们看到了一些复杂的语法 有&

408
00:20:31,115 --> 00:20:35,390
不过你大概可以猜到 在Scratch中 我们说A-N-D 在C中

409
00:20:35,390 --> 00:20:37,070
我们会说&&

410
00:20:37,070 --> 00:20:39,650
不过很快 你们就会觉得这些很自然了

411
00:20:39,650 --> 00:20:40,680
条件

412
00:20:40,680 --> 00:20:42,610
上周 它看上去像是左边这样

413
00:20:42,610 --> 00:20:44,800
这周 它会像右边这样

414
00:20:44,800 --> 00:20:48,560
但是 这里最重要的是 当你看到像右边这样的代码

415
00:20:48,560 --> 00:20:51,950
特别是如果你觉得它看起来不太舒服

416
00:20:51,950 --> 00:20:54,950
是因为你不适应 你不知道要怎样

417
00:20:54,950 --> 00:20:58,420
将Scratch一点一点变成那样

418
00:20:58,420 --> 00:20:59,500
(make sth from scratch在英文里表示 从头做起 此处为双关)

419
00:20:59,500 --> 00:21:05,300
请记住 基本想法其实是一样的

420
00:21:05,300 --> 00:21:06,760
只是前一周的让人觉得更自然而已

421
00:21:06,760 --> 00:21:10,960
就算你还没有开始做练习0 我敢说

422
00:21:10,960 --> 00:21:13,790
你会觉得那些拼图很容易理解 或者至少

423
00:21:13,790 --> 00:21:16,050
经过一段时间后就很容易理解了

424
00:21:16,050 --> 00:21:16,990
所以让我们开始吧

425
00:21:16,990 --> 00:21:20,760
就让我们从第一个简单的程序开始

426
00:21:20,760 --> 00:21:22,410
当然 这个简单是相对的

427
00:21:22,410 --> 00:21:25,190
我需要切换一下屏幕 转到

428
00:21:25,190 --> 00:21:26,150
CS50工具上去

429
00:21:26,150 --> 00:21:29,700
CS50工具是一个在我的Mac上一个窗口中运行的软件

430
00:21:29,700 --> 00:21:33,920
当然 你也可以在你PC上运行

431
00:21:33,920 --> 00:21:38,720
它可以让我和课上的每一个助教 每一个助理

432
00:21:38,720 --> 00:21:40,940
每一个学生都拥有相同的电脑环境

433
00:21:40,940 --> 00:21:44,590
因为CS50工具实际上是另一个操作系统

434
00:21:44,590 --> 00:21:45,410
也就是Linux

435
00:21:45,410 --> 00:21:47,160
准确的说 是Fedora Linux

436
00:21:47,160 --> 00:21:51,320
我们为这个系统配置了一个安装过程

437
00:21:51,320 --> 00:21:55,200
所以一 它中间有个小小的CS50标志

438
00:21:55,200 --> 00:21:59,240
二 底部有一个个性化菜单 三 为了教学

439
00:21:59,240 --> 00:22:02,570
我们把用户界面尽可能地简化

440
00:22:02,570 --> 00:22:05,540
所以当你第一次在你的Mac或PC上安装它时

441
00:22:05,540 --> 00:22:08,280
你会和别人有一样的电脑环境 你也会拥有上这门课

442
00:22:08,280 --> 00:22:11,390
所需一切 你自己还不用去想

443
00:22:11,390 --> 00:22:13,280
每样东西要怎么安装

444
00:22:13,280 --> 00:22:15,840
所以它看上去和Mac操作系统或是Windows有几分类似

445
00:22:15,840 --> 00:22:18,760
在左下角 你有一个开始菜单

446
00:22:18,760 --> 00:22:20,280
或是一个Apple菜单

447
00:22:20,280 --> 00:22:23,700
然后有三个我们认为你们最常用的图标

448
00:22:23,700 --> 00:22:24,460
一个是Chrome

449
00:22:24,460 --> 00:22:26,460
是浏览器

450
00:22:26,460 --> 00:22:29,970
第二个是Gedit 我们上周短暂地见过它

451
00:22:29,970 --> 00:22:31,310
它是个图像处理器

452
00:22:31,310 --> 00:22:35,350
第三个是一个终端程序 是一个老式的黑白窗口

453
00:22:35,350 --> 00:22:39,860
你可以在里面用键盘输入更难懂

454
00:22:39,860 --> 00:22:40,660
但也更有用的命令

455
00:22:40,660 --> 00:22:44,220
所以让我先行一步 打开 Gedit 放心

456
00:22:44,220 --> 00:22:48,520
周五会发下来的练习1中 我们会教你怎样重复这些步骤

457
00:22:48,520 --> 00:22:51,730
你们看到 这里的用户界面很简单 由三部分组成

458
00:22:51,730 --> 00:22:54,990
左边 一个空的窗口叫源代码

459
00:22:54,990 --> 00:22:58,930
在这儿我会看见我写出的代码的总结

460
00:22:58,930 --> 00:23:01,990
右手边 是一个大标签页 马上代码就会写在这里

461
00:23:01,990 --> 00:23:03,510
现在还没有保存

462
00:23:03,510 --> 00:23:06,780
在底下 我有一个内嵌的终端窗口

463
00:23:06,780 --> 00:23:12,060
它是一个黑白的提示 让你把命令输入其中这样就能编译及执行我的程序了

464
00:23:12,060 --> 00:23:14,110
也就是说 能让我写程序及跑程序

465
00:23:14,110 --> 00:23:15,170
就让我们从简单的开始

466
00:23:15,170 --> 00:23:17,700
点击文件 保存

467
00:23:17,700 --> 00:23:20,530
然后我会进入jharvard

468
00:23:20,530 --> 00:23:24,320
无论你们是谁 这个工具都属于

469
00:23:24,320 --> 00:23:28,250
一个叫John Harvard的人 他有一个jharvard主目录 你们的文件

470
00:23:28,250 --> 00:23:29,100
都会被存到这个目录下

471
00:23:29,100 --> 00:23:31,640
你们每人都有他帐户的一部分 所以我们并没有

472
00:23:31,640 --> 00:23:33,530
共享同一个硬盘

473
00:23:33,530 --> 00:23:35,580
你只是感觉John Harvard拥有它而已

474
00:23:35,580 --> 00:23:38,350
另外 我还装好了Dropbox

475
00:23:38,350 --> 00:23:42,600
这个工具已经装了Dropbox所以如果学期中

476
00:23:42,600 --> 00:23:45,950
有什么出了问题 如果你设置好了一个免费的Dropbox帐户的话

477
00:23:45,950 --> 00:23:48,950
你所有的文件都会自动备份

478
00:23:48,950 --> 00:23:50,430
这样你就很容易恢复它们了

479
00:23:50,430 --> 00:23:53,980
我要打开我的Dropbox目录

480
00:23:53,980 --> 00:23:55,530
这里面已经有一些东西了

481
00:23:55,530 --> 00:24:02,090
不过我要先点击文件 保存

482
00:24:02,090 --> 00:24:05,930
然后到jharvard目录的Dropbox目录下

483
00:24:05,930 --> 00:24:10,590
给我的程序一个非常简单的名字 hello.c 然后保存

484
00:24:10,590 --> 00:24:11,810
用户界面还是一样的

485
00:24:11,810 --> 00:24:14,190
唯一变化的就是在这个标签顶端

486
00:24:14,190 --> 00:24:17,170
我会迅速重新写出

487
00:24:17,170 --> 00:24:19,060
刚才幻灯片上的程序

488
00:24:19,060 --> 00:24:25,690
输入  into main(void) 然后是printf, "hello, world,"

489
00:24:25,690 --> 00:24:29,920
跟着一个很难懂的\n 引号 括号 分号

490
00:24:29,920 --> 00:24:32,030
然后按Ctrl S保存

491
00:24:32,030 --> 00:24:34,860
请注意刚刚在左上角出现了什么

492
00:24:34,860 --> 00:24:37,490
这个在今天不重要 但是对以后会很有用

493
00:24:37,490 --> 00:24:40,160
你刚才看到了这一段代码的一个总结

494
00:24:40,160 --> 00:24:43,320
因为我写下了 main 所以main这个词

495
00:24:43,320 --> 00:24:44,030
在这里出现了

496
00:24:44,030 --> 00:24:46,610
不过今天我们不用管那个

497
00:24:46,610 --> 00:24:51,130
好的 这是我用C语言写出的第一个程序

498
00:24:51,130 --> 00:24:54,620
上周五 我们就知道了 我在跑这个程序时

499
00:24:54,620 --> 00:24:58,450
它就会展示出

500
00:24:58,450 --> 00:25:01,270
或者用计算机科学家的话说 输出

501
00:25:01,270 --> 00:25:03,310
你好世界 在屏幕上

502
00:25:03,310 --> 00:25:06,800
所以我这样做后 你会发现我要到终端这里

503
00:25:06,800 --> 00:25:09,250
在这里现在有一个闪烁的光标

504
00:25:09,250 --> 00:25:15,480
这是我的 John Harvard主目录在键盘版本

505
00:25:15,480 --> 00:25:19,610
这样我可以用键盘来控制我的硬盘

506
00:25:19,610 --> 00:25:25,380
所以我不能像我上周那样打字输入 hello

507
00:25:25,380 --> 00:25:27,230
因为它会告诉我 无法找到目标文件

508
00:25:27,230 --> 00:25:27,950
有什么地方出错了

509
00:25:27,950 --> 00:25:31,690
我并不知道这条信息具体什么意思 但这是因为在默认条件下

510
00:25:31,690 --> 00:25:35,350
当这个黑白窗口被打开时 我就在

511
00:25:35,350 --> 00:25:36,160
John Harvard的主目录里了

512
00:25:36,160 --> 00:25:39,180
但我把这个程序保存到哪里了呢

513
00:25:39,180 --> 00:25:40,440
保存在我的Dropbox文件夹里

514
00:25:40,440 --> 00:25:43,110
我们从小到大 用电脑时都是双击

515
00:25:43,110 --> 00:25:45,610
文件夹图标 打开它 就像这样

516
00:25:45,610 --> 00:25:48,280
那个叫hellp.c文件就会在那儿了

517
00:25:48,280 --> 00:25:49,470
那就让我们来试试吧

518
00:25:49,470 --> 00:25:51,610
让我把Gegit最小化 就像你们在

519
00:25:51,610 --> 00:25:52,990
Windows或Mac操作系统上会做的那样

520
00:25:52,990 --> 00:25:56,160
让我去左上角的主文件夹

521
00:25:56,160 --> 00:25:57,620
这里有一堆文件夹

522
00:25:57,620 --> 00:25:58,870
这是我的Dopbox文件夹

523
00:25:58,870 --> 00:26:00,770
这个小标识表示它已经同步好了

524
00:26:00,770 --> 00:26:04,040
这里面已经有一些东西了 不过请注意 hello.c

525
00:26:04,040 --> 00:26:04,960
就在这儿

526
00:26:04,960 --> 00:26:08,050
所以在Mac和Windows系统里 我们通常会双击它 它就会打开

527
00:26:08,050 --> 00:26:10,220
不论是什么程序 这样就好了

528
00:26:10,220 --> 00:26:13,370
但现在 至少从今天开始 我们需要退后一步

529
00:26:13,370 --> 00:26:16,960
给你们一些基本的工具 让你们能够

530
00:26:16,960 --> 00:26:18,980
在不远的将来用它做出更强大的事

531
00:26:18,980 --> 00:26:22,280
所以现在 我需要做与双击Dopbox文件夹

532
00:26:22,280 --> 00:26:23,560
能达到同样效果的事

533
00:26:23,560 --> 00:26:29,900
所以我要输入CD来更改目录 Dropbox 回车

534
00:26:29,900 --> 00:26:36,100
现在请注意 我的提示这里出现了括号

535
00:26:36,100 --> 00:26:38,470
还有波浪线 这个在我键盘左上角的

536
00:26:38,470 --> 00:26:40,860
弯曲的小符号 /Dropbox

537
00:26:40,860 --> 00:26:45,200
这只是一个缩写 告诉人类说 你现在在Dopbox

538
00:26:45,200 --> 00:26:48,650
文件夹里了 就好像你刚刚双击了一样的

539
00:26:48,650 --> 00:26:54,610
所以现在如果我再来输入 make hello 回车 我会看见一个非常难懂的命令

540
00:26:54,610 --> 00:26:57,450
但不再是一条表示错误的信息了 然后

541
00:26:57,450 --> 00:26:59,020
就会出现另一个闪烁提示

542
00:26:59,020 --> 00:27:04,470
如果你们还想得起来的话 我们在上周五 是这样做的 ./hello

543
00:27:04,470 --> 00:27:10,000
你们马上会看见我跑了这个程序后的结果 或者 在Mac

544
00:27:10,000 --> 00:27:14,310
和Windows系统中 我双击一个.app或是.exe程序后的结果

545
00:27:14,310 --> 00:27:17,620
它会打开一个窗口然后执行程序

546
00:27:17,620 --> 00:27:21,920
输入./hello就相当于双击打开程序

547
00:27:21,920 --> 00:27:23,280
但是是用我的键盘完成的

548
00:27:23,280 --> 00:27:25,410
回车 hello world

549
00:27:25,410 --> 00:27:26,150
这样就行了

550
00:27:26,150 --> 00:27:29,150
让我们来将拆分下 以免听上去太像希腊文

551
00:27:29,150 --> 00:27:31,370
所以 ./ 表示什么呢

552
00:27:31,370 --> 00:27:34,120
用键盘在这样的环境下操作过的人

553
00:27:34,120 --> 00:27:36,690
点代表什么呢

554
00:27:36,690 --> 00:27:37,800
是当下的目录

555
00:27:37,800 --> 00:27:41,320
所以 当下的目录实际上是一个文件夹的简称

556
00:27:41,320 --> 00:27:46,230
./就表示我在说 在当下的目录

557
00:27:46,230 --> 00:27:47,250
中去找一个

558
00:27:47,250 --> 00:27:48,540
叫做hello的程序

559
00:27:48,540 --> 00:27:50,480
换句话说 就是在我的Dopbox文件夹里找

560
00:27:50,480 --> 00:27:54,220
所以这就是为什么在之后敲回车就会打开那个程序

561
00:27:54,220 --> 00:27:58,790
如果我现在输入 LS 请注意我现在能看到我Dropbox里的所有东西了

562
00:27:58,790 --> 00:28:02,000
有Started.pdf 这是Dropbox免费给你的 我的照片目录

563
00:28:02,000 --> 00:28:05,450
一个公共目录 未保存文件1  这是我刚才

564
00:28:05,450 --> 00:28:09,730
不小心按到的 foo.c 这是我先前保存的 然后两行东西

565
00:28:09,730 --> 00:28:12,090
hello.c和hello

566
00:28:12,090 --> 00:28:17,280
hello.c是我刚才在Gedit里写的程序 那这个绿色的hello是什么呢

567
00:28:20,920 --> 00:28:22,940
绿色的hello是可执行文件

568
00:28:22,940 --> 00:28:27,020
也就是说 我刚才执行了这条命令时

569
00:28:27,020 --> 00:28:28,040
让我们回放一下

570
00:28:28,040 --> 00:28:32,400
当我执行了make hello 时 就等于做了中间的这一步

571
00:28:32,400 --> 00:28:34,410
它把hello.c当成输入

572
00:28:34,410 --> 00:28:39,910
也就是源代码 然后生成了一个文件 把hello作为输出

573
00:28:39,910 --> 00:28:42,510
这个输出中包含了一堆0和1

574
00:28:42,510 --> 00:28:47,640
这也就是为什么 最后 我可以成功执行./hello这样的命令

575
00:28:47,640 --> 00:28:53,310
因为在因特尔处理器中 我的操作系统 Linux 打开了这堆

576
00:28:53,310 --> 00:28:55,820
0和1  把它们喂到了我电脑的脑子

577
00:28:55,820 --> 00:28:56,580
也就是CPU里

578
00:28:56,580 --> 00:29:00,460
CPU就知道 哦 这里有组0和1 表示

579
00:29:00,460 --> 00:29:02,800
的是把这个东西输出到屏幕上

580
00:29:02,800 --> 00:29:04,450
是什么东西呢

581
00:29:04,450 --> 00:29:07,650
当然就是 hello world

582
00:29:07,650 --> 00:29:12,100
好的 简单总结一下刚才这些命令 这样我们

583
00:29:12,100 --> 00:29:13,350
就能自然运用它们了

584
00:29:13,350 --> 00:29:15,550
让我跳到我们刚才在讲的地方

585
00:29:15,550 --> 00:29:22,230
你们还记得 我们刚才输入了CD

586
00:29:22,230 --> 00:29:24,880
我敢说 这大概是今天

587
00:29:24,880 --> 00:29:29,010
或者是这周 除了make之外

588
00:29:29,010 --> 00:29:30,580
我们需要输入的命令了

589
00:29:30,580 --> 00:29:34,510
所以CD代表什么呢

590
00:29:34,510 --> 00:29:35,180
更改目录

591
00:29:35,180 --> 00:29:38,010
就等同于双击一个文件夹

592
00:29:38,010 --> 00:29:41,320
顺便提一句 如果你在使用这个工具时有什么不清楚的

593
00:29:41,320 --> 00:29:43,430
比如说在用Dropbox时

594
00:29:43,430 --> 00:29:45,420
我想返回我的jharvard目录

595
00:29:45,420 --> 00:29:50,490
如果不确定 就按CD 回车 不用做其他事 它就会把你带回

596
00:29:50,490 --> 00:29:53,110
最开始的地方 这是很蛮好用的捷径

597
00:29:53,110 --> 00:29:54,840
好 另一个命令

598
00:29:54,840 --> 00:29:55,660
LS

599
00:29:55,660 --> 00:29:56,840
我刚才输入了它

600
00:29:56,840 --> 00:29:59,500
LS表示什么呢

601
00:29:59,500 --> 00:30:00,470
列出

602
00:30:00,470 --> 00:30:03,300
以前 当人们想出这些命令时

603
00:30:03,300 --> 00:30:07,180
他们想要尽可能高效 所以他们没有输入L-I-S-T 回车

604
00:30:07,180 --> 00:30:08,470
而是决定用LS

605
00:30:08,470 --> 00:30:09,080
这没什么问题

606
00:30:09,080 --> 00:30:10,420
听起来和list很相近

607
00:30:10,420 --> 00:30:13,870
那我们就输入LS 回车 然后它就会列出我当前文件夹中所有的文件

608
00:30:13,870 --> 00:30:15,000
和文件夹

609
00:30:15,000 --> 00:30:17,530
mkdir 你们大概可以猜到

610
00:30:17,530 --> 00:30:18,440
创建目录

611
00:30:18,440 --> 00:30:22,010
所以在这里 你不用去什么文件菜单然后选择新建文件夹了

612
00:30:22,010 --> 00:30:27,410
你要做的 是输入mkdir 空格 然后接上你想要创建的

613
00:30:27,410 --> 00:30:29,850
文件夹的名称 然后就好了

614
00:30:29,850 --> 00:30:32,380
rm 你们也可以猜到

615
00:30:32,380 --> 00:30:33,480
移除或删除

616
00:30:33,480 --> 00:30:36,740
如果你们想删除一个文件 你们可以在练习中找到

617
00:30:36,740 --> 00:30:37,240
要怎样做

618
00:30:37,240 --> 00:30:39,510
还有rmdir 删除目录

619
00:30:39,510 --> 00:30:42,320
同样 我会略去一些细节 因为一

620
00:30:42,320 --> 00:30:46,010
花时间在这些上面好像并不太有趣 二 我们会在

621
00:30:46,010 --> 00:30:48,720
练习中提供更多的信息 特别是

622
00:30:48,720 --> 00:30:52,370
普通版的练习 这些步骤 你都要自己输入

623
00:30:52,370 --> 00:30:54,830
这样你才能越来越适应这类事情

624
00:30:54,830 --> 00:30:57,430
但现在让我再来分解另一个事情

625
00:30:57,430 --> 00:31:02,580
先前 我们输入make hello的时候 我们看到了一堆难懂的命令

626
00:31:02,580 --> 00:31:04,805
又一次 我们看到了 make hello

627
00:31:07,640 --> 00:31:08,520
好 让我们这样做

628
00:31:08,520 --> 00:31:11,840
我差点犯了个错 不过现在我要故意犯

629
00:31:11,840 --> 00:31:14,400
这个错

630
00:31:14,400 --> 00:31:15,810
我哪里做错了呢

631
00:31:18,680 --> 00:31:21,060
是的 我不在Dropbox目录下 因为 刚才

632
00:31:21,060 --> 00:31:22,720
我输入了CD然后按了回车

633
00:31:22,720 --> 00:31:25,480
它把我带到了最开始的地方 而我的文件不在这

634
00:31:25,480 --> 00:31:31,720
所以我要做的是 CD Dropbox 回车 现在我就可以

635
00:31:31,720 --> 00:31:34,060
输入 rm hello 回车 把普通文件hello删除

636
00:31:34,060 --> 00:31:35,200
我不知道这为什么这么复杂

637
00:31:35,200 --> 00:31:37,600
这只是在问你是否确定要删除hello

638
00:31:37,600 --> 00:31:41,510
你可以输入y表示是 现在它就被删掉了

639
00:31:41,510 --> 00:31:46,010
所以现在如果我再次输入make hello 它就会重新写出我的目标码

640
00:31:46,010 --> 00:31:47,460
重新创造那些0和1

641
00:31:47,460 --> 00:31:51,070
但这条特别长的命令又是怎么回事

642
00:31:51,070 --> 00:31:53,960
我们马上会讲到这个 不过

643
00:31:53,960 --> 00:31:55,500
我前面好像说了个善意的谎言

644
00:31:55,500 --> 00:31:56,880
make不是一个编译器

645
00:31:56,880 --> 00:32:00,350
make是一个程序 它会自动想出要怎样

646
00:32:00,350 --> 00:32:02,060
为你运行一个编译器

647
00:32:02,060 --> 00:32:07,490
所以你要把hello.c转换成hello 真正要输入的命令

648
00:32:07,490 --> 00:32:11,240
事实上应该要长这样

649
00:32:11,240 --> 00:32:15,900
但它实在太长了

650
00:32:15,900 --> 00:32:17,280
我们不太可能真正去记怎样输入这一堆命令

651
00:32:17,280 --> 00:32:21,360
所以make的意义就在于 让我们了解问题的复杂程度

652
00:32:21,360 --> 00:32:24,470
然后帮我们自动处理那些非常复杂的步骤

653
00:32:24,470 --> 00:32:26,040
不过我可以尝试一下

654
00:32:26,040 --> 00:32:29,960
对于这里 我就可以猜一下 只要

655
00:32:29,960 --> 00:32:33,960
输入clang 也就是我们这学期所用的编译器的

656
00:32:33,960 --> 00:32:35,170
名字

657
00:32:35,170 --> 00:32:38,500
如果你们当中谁开发过iphone或ipad的ios程序

658
00:32:38,500 --> 00:32:42,930
clang就你们在xcode中写代码的程序

659
00:32:42,930 --> 00:32:46,360
不过clang只是一个可以在命令中输入的程序名称而已

660
00:32:46,360 --> 00:32:49,210
我们现在介绍它 是为了以后可以

661
00:32:49,210 --> 00:32:52,410
介绍一些更有代表性的命令

662
00:32:52,410 --> 00:32:53,910
让我来手动演示一下

663
00:32:53,910 --> 00:32:59,240
rm hello 检查一下 然后

664
00:32:59,240 --> 00:33:03,180
./hello 你觉得下面我会看到什么

665
00:33:03,180 --> 00:33:04,060
某种错误

666
00:33:04,060 --> 00:33:05,110
目录中无此文件

667
00:33:05,110 --> 00:33:06,740
这个错误还挺直观的

668
00:33:06,740 --> 00:33:08,110
现在让我清理一下屏幕

669
00:33:08,110 --> 00:33:11,370
Ctrl S会把屏幕上干扰人的东西都清掉

670
00:33:11,370 --> 00:33:17,160
然后我会手动输入 clang -o hello hello.c.

671
00:33:17,160 --> 00:33:18,890
所以下面会怎样呢

672
00:33:18,890 --> 00:33:23,820
就是make帮我们做到的事 但是我用更复杂的

673
00:33:23,820 --> 00:33:25,430
文字做到了

674
00:33:25,430 --> 00:33:28,570
clang这个程序会把一个.c文件输入  然后输出

675
00:33:28,570 --> 00:33:30,110
0和1

676
00:33:30,110 --> 00:33:35,120
但是-o是一个 switch 或者叫flag

677
00:33:35,120 --> 00:33:39,080
这是个技术术语 意思是你输入的提示会

678
00:33:39,080 --> 00:33:42,590
影响到你今后要执行的程序

679
00:33:42,590 --> 00:33:47,180
所以有人想要猜下-o代表什么呢

680
00:33:47,180 --> 00:33:47,840
输出

681
00:33:47,840 --> 00:33:52,670
其实就是有人决定了-o代表输出一个叫hello的文件

682
00:33:52,670 --> 00:33:56,440
然后把提示上最后一个词 无论它是什么 在这里 是 hello.c 输入

683
00:33:56,440 --> 00:33:58,930
所以如果我敲回车的在 看起来不会有什么

684
00:33:58,930 --> 00:34:02,010
但在编程的奇怪世界里 什么都没有发生

685
00:34:02,010 --> 00:34:03,980
也有可能是件好事 因为这表示屏幕上

686
00:34:03,980 --> 00:34:05,350
没有显示错误

687
00:34:05,350 --> 00:34:07,190
hello 回车

688
00:34:07,190 --> 00:34:08,670
我的程序现在已经运行了

689
00:34:08,670 --> 00:34:14,517
但我可以做件很笨的事 比如 clang -o, hihihi, hello.c

690
00:34:14,517 --> 00:34:18,590
回车 现在我就有了一个一模一样的 叫做hihihi的程序

691
00:34:18,590 --> 00:34:20,739
它们完全相同 只是名字不同

692
00:34:20,739 --> 00:34:23,360
所以我只是想说 如果你想要改变一个程序的功能

693
00:34:23,360 --> 00:34:25,909
我们会不断见到一个叫做

694
00:34:25,909 --> 00:34:27,739
指令列参数的东西

695
00:34:27,739 --> 00:34:28,639
这是一个列

696
00:34:28,639 --> 00:34:29,580
你在输入指令

697
00:34:29,580 --> 00:34:30,969
所以叫指令列

698
00:34:30,969 --> 00:34:35,690
而指令列参数就是一些会影响到程序功能

699
00:34:35,690 --> 00:34:40,840
的文字或者词语

700
00:34:40,840 --> 00:34:44,639
好 这大概是我们能写出或看见的最无聊的程序了

701
00:34:44,639 --> 00:34:46,670
现在让我们做一些更有趣的

702
00:34:46,670 --> 00:34:49,420
让我来创建一个新文件

703
00:34:49,420 --> 00:34:53,139
我会把它保存在John Harvard的主目录里

704
00:34:53,139 --> 00:34:58,670
叫做custom.c 是一个个性化程序

705
00:34:58,670 --> 00:35:01,920
让我放大一下这边然后重来一次

706
00:35:01,920 --> 00:35:03,730
包括 standard stdio.h

707
00:35:03,730 --> 00:35:04,990
这我们过一会儿会讲到

708
00:35:04,990 --> 00:35:08,240
int main(void)这待会也会讲到

709
00:35:08,240 --> 00:35:09,490
printf ("hello, David").

710
00:35:12,810 --> 00:35:14,560
有趣多了 对吧

711
00:35:14,560 --> 00:35:20,690
所以现在 不是因为我的名字有趣 是因为它不同 才有趣

712
00:35:20,690 --> 00:35:24,950
make custom 回车

713
00:35:24,950 --> 00:35:26,780
Custom, hello, David.

714
00:35:26,780 --> 00:35:28,020
但这也还是个善意的谎言

715
00:35:28,020 --> 00:35:30,850
这个程序也可以叫david.c

716
00:35:30,850 --> 00:35:31,880
因为我们并没有自定义性能

717
00:35:31,880 --> 00:35:35,080
我想要的 是一个会问用户名字的程序

718
00:35:35,080 --> 00:35:36,320
我要怎样才能做到呢

719
00:35:36,320 --> 00:35:38,520
让我往上拉到这边

720
00:35:38,520 --> 00:35:42,960
在我用Scratch语句之前 用printf之前

721
00:35:42,960 --> 00:35:47,600
也就是在这个功能之前 让我先向用户要些东西

722
00:35:47,600 --> 00:35:49,690
我得做下面几件事

723
00:35:49,690 --> 00:35:53,360
首先 在我问用户名字后

724
00:35:53,360 --> 00:35:54,510
我需要有个地方可以存储它们

725
00:35:54,510 --> 00:36:00,120
为了存储这样的值 我应该用什么建构呢

726
00:36:00,120 --> 00:36:00,910
一个变量

727
00:36:00,910 --> 00:36:05,130
不像在Scratch里你可以直接拿一片拼图 这里

728
00:36:05,130 --> 00:36:07,620
显然 我们需要用文字来表达

729
00:36:07,620 --> 00:36:11,510
所以 当你在编程时 如果你想要一个词或是一个短语

730
00:36:11,510 --> 00:36:13,090
我们叫它字串

731
00:36:13,090 --> 00:36:14,990
字串就是一个词或是一个短语

732
00:36:14,990 --> 00:36:18,170
它是由0个或多个字符组成的序列

733
00:36:18,170 --> 00:36:22,520
如果你想以这个变量存在的话 你必须要说 给我一个变量

734
00:36:22,520 --> 00:36:27,490
你要做的 就是说 string s 分号 s可以是

735
00:36:27,490 --> 00:36:28,740
你想要的任何东西

736
00:36:28,740 --> 00:36:30,510
事实上 s有点不够厉害

737
00:36:30,510 --> 00:36:33,250
为了更清楚些 让我叫它name

738
00:36:33,250 --> 00:36:36,570
给我一个叫name的字串

739
00:36:36,570 --> 00:36:40,180
现在 这个人的名字默认是什么

740
00:36:40,180 --> 00:36:42,930
当然 如果那个用户没有输入任何东西的话

741
00:36:42,930 --> 00:36:44,310
名字显然是不会有任何值的

742
00:36:44,310 --> 00:36:48,120
在C中 如果你不给一个变量一个值

743
00:36:48,120 --> 00:36:49,180
它会有一个无效的值

744
00:36:49,180 --> 00:36:51,650
它可能会一堆随机的0和1 所以如果你尝试在屏幕上显示它

745
00:36:51,650 --> 00:36:54,570
你就会看到无用的东西

746
00:36:54,570 --> 00:36:59,800
但我可以修正它 在name中储存

747
00:36:59,800 --> 00:37:01,400
下面这个值

748
00:37:01,400 --> 00:37:09,240
想要在变量中储存值 你就把变量名称放在左边

749
00:37:09,240 --> 00:37:13,370
你得想办法把你想要储存的东西放在右边

750
00:37:13,370 --> 00:37:17,650
为了完成这个 语法是这样的

751
00:37:17,650 --> 00:37:22,120
我们还没有看过这个 不过请相信

752
00:37:22,120 --> 00:37:26,270
这世界上有另一个语句 我还是叫它功能

753
00:37:26,270 --> 00:37:28,310
这个功能叫做 get string

754
00:37:28,310 --> 00:37:29,670
它的作用就是表面意思那样 获取字串

755
00:37:29,670 --> 00:37:34,680
如果一个人从另一个人那儿得到了一组字

756
00:37:34,680 --> 00:37:36,380
然后对这些字进行了一些处理

757
00:37:36,380 --> 00:37:38,410
这确实看上去是很难懂的语法

758
00:37:38,410 --> 00:37:40,880
一般 如果你在用等于号 比如说

759
00:37:40,880 --> 00:37:43,740
在代数中 你就在说 x等于1

760
00:37:43,740 --> 00:37:46,570
在这里 我们不是在说 name 等于get string

761
00:37:46,570 --> 00:37:51,270
我们是在说 把等于号右边的东西存储到

762
00:37:51,270 --> 00:37:52,400
name里

763
00:37:52,400 --> 00:37:55,030
等于号代表的是赋值运算符

764
00:37:55,030 --> 00:37:58,240
这个语法表示把右边的东西放到

765
00:37:58,240 --> 00:37:59,090
左边去

766
00:37:59,090 --> 00:38:03,040
所以get string是一个新的功能 它不

767
00:38:03,040 --> 00:38:03,670
只会

768
00:38:03,670 --> 00:38:05,000
叫用户给字符串

769
00:38:05,000 --> 00:38:08,500
也就是说 会把字符串返还

770
00:38:08,500 --> 00:38:10,690
那就让我们来看看会发生什么

771
00:38:10,690 --> 00:38:14,300
我会缩小界面 然后在我的提示里

772
00:38:14,300 --> 00:38:15,780
弄出很多错误

773
00:38:15,780 --> 00:38:18,750
我会输入make custom 回车

774
00:38:18,750 --> 00:38:19,230
哇

775
00:38:19,230 --> 00:38:20,500
有这么多错误

776
00:38:20,500 --> 00:38:23,120
好 一开始 这确实会有点让人不知所措

777
00:38:23,120 --> 00:38:27,220
但实际上 时间一长 我们就发现这些很难懂的错误信息

778
00:38:27,220 --> 00:38:30,700
有着某种固定的格式

779
00:38:30,700 --> 00:38:32,600
我就拿这个来说 因为它是第一个

780
00:38:32,600 --> 00:38:35,700
使用未申报标识字串

781
00:38:35,700 --> 00:38:39,400
这表示Gedit 或者Clang 不知道

782
00:38:39,400 --> 00:38:40,780
我说的字串是什么意思

783
00:38:40,780 --> 00:38:43,880
这是因为在C这个编程语言中

784
00:38:43,880 --> 00:38:47,750
没有字串变量

785
00:38:47,750 --> 00:38:49,810
C并不知道字串的存在

786
00:38:49,810 --> 00:38:52,260
但是我们 CS50团队 知道

787
00:38:52,260 --> 00:38:57,080
所以在课程开始之前 我们创建了一个叫CS50.h.的文件

788
00:38:57,080 --> 00:39:00,060
在这个文件里  我们后面会细说语法

789
00:39:00,060 --> 00:39:03,730
在这个文件里是我口头刚才

790
00:39:03,730 --> 00:39:05,340
对字串的定义

791
00:39:05,340 --> 00:39:09,100
所以我在总结我程序的这一行代码

792
00:39:09,100 --> 00:39:14,620
就在轮流教Gedit make和Clang字串是什么

793
00:39:14,620 --> 00:39:15,475
我还不知道这要怎么做

794
00:39:15,475 --> 00:39:17,110
不过几周会 我们会再回来看这个问题

795
00:39:17,110 --> 00:39:20,340
不过现在 只要知道 这是教编译器

796
00:39:20,340 --> 00:39:22,020
字串是什么就可以了

797
00:39:22,020 --> 00:39:24,230
所以现在让我清理一下底下的终端

798
00:39:24,230 --> 00:39:28,530
让我重新跑一下make custom 然后我已经解决了所有问题

799
00:39:28,530 --> 00:39:30,210
这也会是一个我们会重复看见的主题

800
00:39:30,210 --> 00:39:34,190
我这个程序里只写了9行代码 但我却有18行的错误

801
00:39:34,190 --> 00:39:35,650
这有点令人害怕

802
00:39:35,650 --> 00:39:39,260
不过要记住 这些错误往往有连锁效应 一个小错误

803
00:39:39,260 --> 00:39:43,070
会扰乱编译器 使它看上去比实际上更糟

804
00:39:43,070 --> 00:39:47,460
所以如果你观察仔细的话 你就知道我们要从用户中取得

805
00:39:47,460 --> 00:39:51,460
字串 但我却少做了什么呢

806
00:39:51,460 --> 00:39:53,570
我实际上什么都没做

807
00:39:53,570 --> 00:40:01,240
所以如果我再跑一次custom的话 它不会有任何反应

808
00:40:01,240 --> 00:40:03,380
是怎么回事呢

809
00:40:03,380 --> 00:40:07,990
我的程序好像卡在某一行上了 你们觉不觉得

810
00:40:07,990 --> 00:40:09,860
事实上 它是卡在第七行了

811
00:40:09,860 --> 00:40:13,600
我们前面没遇过 但是第七行上 又出现了

812
00:40:13,600 --> 00:40:14,650
这个语句 get string

813
00:40:14,650 --> 00:40:15,930
它的目的就是获取字串

814
00:40:15,930 --> 00:40:18,480
它现在在等待一个人来拿字串

815
00:40:18,480 --> 00:40:22,230
这对我 一个人 来说 并不很好理解 因为

816
00:40:22,230 --> 00:40:23,040
没有人告诉我要做什么

817
00:40:23,040 --> 00:40:27,320
但就让我有一点信心 然后让我假装自己是Rob

818
00:40:27,320 --> 00:40:28,500
回车

819
00:40:28,500 --> 00:40:30,930
这并不是我想要的程序

820
00:40:30,930 --> 00:40:32,350
所以 我们有了第一个bug

821
00:40:32,350 --> 00:40:34,390
不过让我们试着弄清楚为什么会这样

822
00:40:34,390 --> 00:40:36,940
首先 让我修正第一个错误

823
00:40:36,940 --> 00:40:44,690
让我在这儿加一行 printf 你的名字是什么

824
00:40:44,690 --> 00:40:47,700
下引号 右半括号

825
00:40:47,700 --> 00:40:51,350
现在让我重跑一下程序

826
00:40:51,350 --> 00:40:51,760
有问题

827
00:40:51,760 --> 00:40:54,690
我没想到这会发生

828
00:40:54,690 --> 00:40:54,930
对了

829
00:40:54,930 --> 00:40:55,990
我没有对它进行再次编译

830
00:40:55,990 --> 00:40:59,800
所以在C这样的语言中 你改变了源代码

831
00:40:59,800 --> 00:41:03,170
并不意味着你改变了那个会产生新目标代码的目标代码

832
00:41:03,170 --> 00:41:04,330
新的0－和1们

833
00:41:04,330 --> 00:41:05,590
你必须重新编译

834
00:41:05,590 --> 00:41:10,300
如果现在重新跑一下 按回车 啊 这下比较明朗了

835
00:41:10,300 --> 00:41:11,890
我的名字是Rob

836
00:41:11,890 --> 00:41:12,760
但仍然有错

837
00:41:12,760 --> 00:41:14,170
我会说现在的一些错误

838
00:41:14,170 --> 00:41:15,450
说实话 看上去真的很可笑

839
00:41:15,450 --> 00:41:18,980
比如 这里我应该加个空格

840
00:41:18,980 --> 00:41:20,330
或者要把鼠标移到新一行上去

841
00:41:20,330 --> 00:41:21,370
新一行

842
00:41:21,370 --> 00:41:24,660
在这里是一个关键词 不过我们还没有定义它

843
00:41:24,660 --> 00:41:28,560
你让文字从一行变到新一行

844
00:41:28,560 --> 00:41:29,480
并不是这样做的

845
00:41:29,480 --> 00:41:31,070
这会给电脑造成混乱

846
00:41:31,070 --> 00:41:33,830
这看上去像是两行分开的代码

847
00:41:33,830 --> 00:41:35,010
它们都不完全正确

848
00:41:35,010 --> 00:41:39,380
相反 你得说得更明确些 你要说 给我新一行

849
00:41:39,380 --> 00:41:41,810
在C里面 我们用\n表示

850
00:41:41,810 --> 00:41:43,230
所以这儿有几个这样的字符

851
00:41:43,230 --> 00:41:45,080
\n会让它们看上去更美观些

852
00:41:49,640 --> 00:41:50,870
让我重新编译一下我的程序

853
00:41:50,870 --> 00:41:52,300
让我重跑一下我的程序

854
00:41:52,300 --> 00:41:53,520
看上去好多了

855
00:41:53,520 --> 00:41:56,960
这个还是很原始 也还是错误很多

856
00:41:56,960 --> 00:41:58,090
所以呢 有一个－－

857
00:41:58,090 --> 00:42:01,680
即使你从没有编程过 你大概也可以猜一下

858
00:42:01,680 --> 00:42:04,960
这个程序为什么还是有问题

859
00:42:04,960 --> 00:42:08,540
有什么是我需要做但还没做的?

860
00:42:08,540 --> 00:42:10,450
我得对 name 做点什么

861
00:42:10,450 --> 00:42:14,190
就像在 Scratch中一样 你可能得给变量n或者

862
00:42:14,190 --> 00:42:16,150
像我们上周讲的计数变量赋一个值

863
00:42:16,150 --> 00:42:18,930
如果你什么都不做的话 什么都不会发生

864
00:42:18,930 --> 00:42:20,210
好 所以我们来修正这个问题

865
00:42:20,210 --> 00:42:23,670
让我在这输入我的变量 然后到下边来

866
00:42:23,670 --> 00:42:29,120
重新编译 重新跑一下 Rob

867
00:42:29,120 --> 00:42:30,540
现在我就是个白痴 是不是

868
00:42:30,540 --> 00:42:33,280
这好像并没有带来太多帮助

869
00:42:33,280 --> 00:42:35,850
但我得说 刚才所做的是天性使然 对不对

870
00:42:35,850 --> 00:42:39,340
如果这个变量叫name 我把它放到那里去

871
00:42:39,340 --> 00:42:40,200
为什么我不直接在那里输入它呢

872
00:42:40,200 --> 00:42:42,210
当然 我们现在对它和

873
00:42:42,210 --> 00:42:44,070
字串得做一个区分

874
00:42:44,070 --> 00:42:47,060
注意到这里的 hello name了么

875
00:42:47,060 --> 00:42:48,960
这本身其实是一个字串

876
00:42:48,960 --> 00:42:49,820
它是个硬编码

877
00:42:49,820 --> 00:42:50,690
不是人为生成的

878
00:42:50,690 --> 00:42:54,020
而是我 最初的编程者创造的 不过它仍然是个字串

879
00:42:54,020 --> 00:42:58,300
所以如果你在字串里真的写下N-A-M-E 会

880
00:42:58,300 --> 00:42:59,120
输出什么呢

881
00:42:59,120 --> 00:43:03,660
会输出 N-A-M-E 而我们需要告诉printf 不要

882
00:43:03,660 --> 00:43:04,870
输出N－A－M－E这四个字母

883
00:43:04,870 --> 00:43:06,680
而是要输出名字的值

884
00:43:06,680 --> 00:43:08,410
我们需要这样做

885
00:43:08,410 --> 00:43:09,800
这只是一个习惯

886
00:43:09,800 --> 00:43:14,990
我们要说%s 这代表字串

887
00:43:14,990 --> 00:43:19,810
在我下引号结束这里 我要放一个逗号

888
00:43:19,810 --> 00:43:23,790
然后在这个语句里放第二个参数

889
00:43:23,790 --> 00:43:25,970
我会在这里输入name

890
00:43:25,970 --> 00:43:27,960
注意到这儿我们有个新的语法

891
00:43:27,960 --> 00:43:32,320
我们还是有两个括号 所以我要说

892
00:43:32,320 --> 00:43:36,830
括号中间的东西代表着参数到功能输入

893
00:43:36,830 --> 00:43:39,730
的转换 而这会影响到它的性能

894
00:43:39,730 --> 00:43:43,010
按这个逻辑 printf现在

895
00:43:43,010 --> 00:43:45,450
在考虑多少个参数?

896
00:43:45,450 --> 00:43:48,370
看起来是两个

897
00:43:48,370 --> 00:43:49,570
从这里的逗号可以看出

898
00:43:49,570 --> 00:43:51,640
所以这是在引号中的一个参数

899
00:43:51,640 --> 00:43:54,540
虽然其中有个逗号 但所有的东西都所在引号里

900
00:43:54,540 --> 00:43:56,230
这意味着这是一个很长的字串

901
00:43:56,230 --> 00:43:58,280
逗号 变量name

902
00:43:58,280 --> 00:44:00,680
现在我们缩小它

903
00:44:00,680 --> 00:44:02,240
然后重跑下

904
00:44:02,240 --> 00:44:03,490
Rob

905
00:44:03,490 --> 00:44:06,520
真是的 我到底做错什么了

906
00:44:06,520 --> 00:44:07,920
好 所以你需要重新编译

907
00:44:07,920 --> 00:44:11,030
又一次 这是刚开始时容易重复犯的错误

908
00:44:11,030 --> 00:44:15,280
现在再重跑下 Rob 回车 好咧

909
00:44:15,280 --> 00:44:17,110
我们现在就有一个自定义的程序了

910
00:44:17,110 --> 00:44:21,660
我现在有个程序 它运用到了一些特性

911
00:44:21,660 --> 00:44:22,520
我们需要提一下

912
00:44:22,520 --> 00:44:27,850
首先 我在用 CS50.h 也就是CS50图书馆

913
00:44:27,850 --> 00:44:33,050
在CS50图书馆中 有其他人 也就是我们的团队

914
00:44:33,050 --> 00:44:33,980
写好的功能

915
00:44:33,980 --> 00:44:36,620
可供你们使用 然后get string是其中的一个

916
00:44:36,620 --> 00:44:41,310
在第二行中 是 stdio.h 这个为什么会在这里?

917
00:44:41,310 --> 00:44:42,070
猜一猜

918
00:44:42,070 --> 00:44:46,200
在常规的输入输出里会有什么?

919
00:44:46,200 --> 00:44:46,940
printf

920
00:44:46,940 --> 00:44:49,600
所以printf 你不会在屏幕其他地方看到它

921
00:44:49,600 --> 00:44:51,870
它必须是电脑自带的

922
00:44:51,870 --> 00:44:54,870
所以它到底从哪来的呢

923
00:44:54,870 --> 00:44:57,660
它在一个叫做

924
00:44:57,660 --> 00:44:59,890
stdio.h的文件里

925
00:44:59,890 --> 00:45:02,670
我们后面还会回到这个问题上 不过现在

926
00:45:02,670 --> 00:45:03,930
它有点让人分心

927
00:45:03,930 --> 00:45:05,490
这代表我们的返回类型

928
00:45:05,490 --> 00:45:07,660
这代表一个参数

929
00:45:07,660 --> 00:45:10,230
不过今天 我们只关注这些代码行

930
00:45:10,230 --> 00:45:13,280
所以 string name 我们来回忆下 能帮我做什么

931
00:45:16,940 --> 00:45:19,560
它会表示这个变量的类型是字串

932
00:45:19,560 --> 00:45:22,630
所以说 这个变量是给文字的 而非数字

933
00:45:22,630 --> 00:45:25,530
顺便提一句 如果我想要它是数字 我会说

934
00:45:25,530 --> 00:45:26,560
int.

935
00:45:26,560 --> 00:45:29,740
如果我想要它是个浮点数 也就是带小数点的东西

936
00:45:29,740 --> 00:45:30,600
我会说float.

937
00:45:30,600 --> 00:45:32,640
不过今天 我刚说了 string

938
00:45:32,640 --> 00:45:35,940
我把这个变量的名字叫做name 不过

939
00:45:35,940 --> 00:45:37,240
我可以给它取任何名字

940
00:45:37,240 --> 00:45:39,340
事实上 一开始 我叫它S

941
00:45:39,340 --> 00:45:41,050
这里是另一个语句

942
00:45:41,050 --> 00:45:44,170
这个语句里有多少个参数?

943
00:45:44,170 --> 00:45:47,890
只有一个 而对于我来说 这只是一个

944
00:45:47,890 --> 00:45:49,610
在屏幕上显示东西时关乎美观的细节

945
00:45:49,610 --> 00:45:54,750
对一般人来说 第八行在做什么

946
00:45:54,750 --> 00:45:57,320
它在从用户那里得到一个值 也就是一个字串

947
00:45:57,320 --> 00:45:58,770
那它会对字串做什么呢

948
00:45:58,770 --> 00:46:02,450
是把它交到等于号左边的人手中

949
00:46:02,450 --> 00:46:07,100
在这里 也就是变量name手中 这样它就可以被储存了

950
00:46:07,100 --> 00:46:10,020
然后printf是另一个功能

951
00:46:10,020 --> 00:46:11,870
运用一个功能时 我们会说

952
00:46:11,870 --> 00:46:13,870
call 一个功能

953
00:46:13,870 --> 00:46:15,640
它显然有两个参数

954
00:46:15,640 --> 00:46:18,100
一个 逗号 然后第二个

955
00:46:18,100 --> 00:46:20,910
这个本身只是一个包含占位符字串

956
00:46:20,910 --> 00:46:23,860
%s 表示在这里放另一个字串

957
00:46:23,860 --> 00:46:27,360
所以在逗号后放name 代表着

958
00:46:27,360 --> 00:46:29,420
在这里插入这个东西

959
00:46:29,420 --> 00:46:31,300
这样我还可以做其他事

960
00:46:31,300 --> 00:46:36,820
让我来弄一个有点傻的程序 不过先让我删掉这个

961
00:46:36,820 --> 00:46:38,880
然后让我创建一个循环

962
00:46:38,880 --> 00:46:41,390
当为真是

963
00:46:41,390 --> 00:46:45,210
真 这个符号显然一直都会是真的

964
00:46:45,210 --> 00:46:49,830
那么我写了写一行 做出了什么循环呢

965
00:46:49,830 --> 00:46:51,070
一个无限循环 对不对

966
00:46:51,070 --> 00:46:52,090
只有 当为真 时

967
00:46:52,090 --> 00:46:56,210
我不可能把 真 这个词变成其他任何东西

968
00:46:56,210 --> 00:46:57,310
所以它就会一直跑下去

969
00:46:57,310 --> 00:46:59,960
所以如果你在你的Mac或PC上发现有个程序

970
00:46:59,960 --> 00:47:02,480
好像锁住了 或者它在做的事

971
00:47:02,480 --> 00:47:05,500
你没法让它停 只能重开机的话

972
00:47:05,500 --> 00:47:08,360
或者把任务管理器调出来 这边有个例子

973
00:47:08,360 --> 00:47:14,340
我可以说 "我是个有问题的程序" 下引号

974
00:47:14,340 --> 00:47:15,780
或括号 分号

975
00:47:15,780 --> 00:47:17,010
所以我们又一次发现了这个规律

976
00:47:17,010 --> 00:47:21,440
虽然一些语法是新的 关键词 当 关键词 真

977
00:47:21,440 --> 00:47:23,590
注意我都有加这种大括号

978
00:47:23,590 --> 00:47:25,890
分号和括号

979
00:47:25,890 --> 00:47:28,000
现在让我们来编译它

980
00:47:28,000 --> 00:47:29,630
make custom, custom

981
00:47:32,690 --> 00:47:36,660
现在 你不需要重启这个工具

982
00:47:36,660 --> 00:47:39,925
简单的方法是 用两根手指 Ctrl C

983
00:47:39,925 --> 00:47:41,230
我们会退出这个程序

984
00:47:41,230 --> 00:47:45,430
不过你们可以看出 这个东西为什么会一直重复自己

985
00:47:45,430 --> 00:47:48,080
我可以弄出更复杂一点的例子

986
00:47:48,080 --> 00:47:49,600
我下面要说

987
00:47:49,600 --> 00:47:55,210
For int 也就是整数 i是我们在编程时想要计数时

988
00:47:55,210 --> 00:47:59,500
给一般变量的名字 等于0

989
00:47:59,500 --> 00:48:08,640
while i 小于100 i++

990
00:48:08,640 --> 00:48:10,240
让我们重新看一下这个语法 它表示

991
00:48:10,240 --> 00:48:12,270
不断增加i的值

992
00:48:12,270 --> 00:48:14,200
那么这里我想要做什么呢

993
00:48:14,200 --> 00:48:21,130
printf 我可以数到i 这是个有问题的程序

994
00:48:21,130 --> 00:48:22,450
我实际上是想做什么呢

995
00:48:25,220 --> 00:48:30,940
%加上不是S 而是d 你们不会想到这个 %d是小数还是整数

996
00:48:30,940 --> 00:48:32,720
,i

997
00:48:32,720 --> 00:48:34,340
这我回到这

998
00:48:34,340 --> 00:48:37,170
用make重新编译

999
00:48:37,170 --> 00:48:39,280
用custom重新跑一下

1000
00:48:39,280 --> 00:48:42,410
当我写这样的程序时 我可以数的很快

1001
00:48:42,410 --> 00:48:45,480
下面我们要做件不是故意为之的事

1002
00:48:45,480 --> 00:48:51,220
当i大于等于0时好了

1003
00:48:51,220 --> 00:48:53,630
它会产生什么呢

1004
00:48:53,630 --> 00:49:01,030
从逻辑上来说 这么做并不聪明 因为如果我现在重跑 重数一次

1005
00:49:01,030 --> 00:49:05,050
我可以数到很大很大的数字

1006
00:49:05,050 --> 00:49:08,850
不幸的是 我大概可以数到40亿 所以

1007
00:49:08,850 --> 00:49:10,140
这会花我很久的时间

1008
00:49:10,140 --> 00:49:13,440
我们不如在这留个悬念 我保证

1009
00:49:13,440 --> 00:49:15,650
在周三 我们会来看看这个程序有没有跑完

1010
00:49:15,650 --> 00:49:19,260
其次 我们会教大家如何自己写一个功能

1011
00:49:19,260 --> 00:49:22,930
这样很快 在周三 当我们从Scratch 转向C时

1012
00:49:22,930 --> 00:49:25,880
可以开始写出越来越杂的

1013
00:49:25,880 --> 00:49:27,070
比这个高级很多的程序

1014
00:49:27,070 --> 00:49:28,766
到时候见

1015
00:49:28,766 --> 00:49:31,580
[掌声]

1016
00:49:31,580 --> 00:49:34,690
在下一堂CS50中 我们会看见Puzzle Day大获成功