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

2
00:00:11,952 --> 00:00:13,800
>> 戴维·J·马兰：所以这是CS50。

3
00:00:13,800 --> 00:00:18,970
这是CS50自己的科尔顿奥格登
更多的是谁的音乐，你可以

4
00:00:18,970 --> 00:00:22,820
下载的soundcloud.com/cs50。

5
00:00:22,820 --> 00:00:26,690
>> 所以今天我们重点更
编程的艺术。

6
00:00:26,690 --> 00:00:28,980
我们需要在我们离开
关闭上周，重点

7
00:00:28,980 --> 00:00:31,660
上划痕，这是该
图形化编程语言。

8
00:00:31,660 --> 00:00:35,490
走下来，以一个较低的水平，
使用更传统的编程

9
00:00:35,490 --> 00:00:38,420
被誉为C.语言，但
一路走来，实现

10
00:00:38,420 --> 00:00:40,730
，同样的想法，我们
谈到上周五

11
00:00:40,730 --> 00:00:44,390
不仅会在此复发
C语言，但在大多数每隔

12
00:00:44,390 --> 00:00:46,350
我们看看这个学期。

13
00:00:46,350 --> 00:00:50,247
>> 因此，我们呼吁这件事
这里过去是什么时间呢？

14
00:00:50,247 --> 00:00:51,830
这是代表发言的。

15
00:00:51,830 --> 00:00:53,080
所以我们称这个声明。

16
00:00:53,080 --> 00:00:54,100
它做一些事情。

17
00:00:54,100 --> 00:00:56,910
这是一个指令，一个
计算机或划痕可能执行。

18
00:00:56,910 --> 00:00:59,910
从今以后，我们也开始
调用这样的函数，

19
00:00:59,910 --> 00:01:02,070
对于原因，我们将很快看到。

20
00:01:02,070 --> 00:01:03,681
>> 同时，我们看到了这样的事情。

21
00:01:03,681 --> 00:01:05,680
而这些都是一般
被称为什么构造？

22
00:01:05,680 --> 00:01:06,240
>> 听众：循环。

23
00:01:06,240 --> 00:01:06,860
>> 戴维·J·马兰：所以一个循环。

24
00:01:06,860 --> 00:01:07,943
所以，很简单。

25
00:01:07,943 --> 00:01:09,470
它的字面做什么，它说。

26
00:01:09,470 --> 00:01:12,210
和划痕，如果你想
补习班更多拼图在那里，

27
00:01:12,210 --> 00:01:13,950
片将增长，以适应它。

28
00:01:13,950 --> 00:01:16,790
我们会在C中看到，
我们可以做同样的事情。

29
00:01:16,790 --> 00:01:20,000
>> 另一种类型的环，不过，
在划痕可能是永远的，

30
00:01:20,000 --> 00:01:21,820
或有任何数量
其他方法。

31
00:01:21,820 --> 00:01:24,150
但是，让我们更
多面手的样子，脸上

32
00:01:24,150 --> 00:01:27,402
这可能很熟悉，
在循环更普遍。

33
00:01:27,402 --> 00:01:29,110
马克·扎克伯格：一个
东西电脑

34
00:01:29,110 --> 00:01:31,860
是的，是真的好
重复的命令。

35
00:01:31,860 --> 00:01:33,910
作为一个人，你会得到
如果你真的很无聊

36
00:01:33,910 --> 00:01:36,730
不得不做的同样的事情
许多在一排次。

37
00:01:36,730 --> 00:01:40,530
但是，一台计算机可以做同样的事情
数百万甚至数十亿倍，

38
00:01:40,530 --> 00:01:43,290
不觉得无聊，并且能够
开展了这一点真的很好。

39
00:01:43,290 --> 00:01:45,650
>> 因此，举例来说，如果我
想祝大家

40
00:01:45,650 --> 00:01:48,840
Facebook上的生日快乐
通过向他们发送一封电子邮件，

41
00:01:48,840 --> 00:01:51,550
这可能要花费一个多
世纪真正写出来

42
00:01:51,550 --> 00:01:53,000
所有这些邮件给大家。

43
00:01:53,000 --> 00:01:57,780
但是，代码只有几行，我可以
有一个系统发送一封电子邮件给大家

44
00:01:57,780 --> 00:01:59,930
在Facebook希望
他们生日快乐。

45
00:01:59,930 --> 00:02:02,730
所以，这就是循环是为什么
他们是有价值的东西

46
00:02:02,730 --> 00:02:04,740
计算机能够做的非常好。

47
00:02:04,740 --> 00:02:05,630
>> 戴维·J·马兰：所以，如果
你去过收件人

48
00:02:05,630 --> 00:02:07,820
一些CS50的和
后期的Dropbox的空间，

49
00:02:07,820 --> 00:02:10,590
这其实正是我们
这样做，使用代码挺喜欢的。

50
00:02:10,590 --> 00:02:12,600
我们基本上有一个大的
表格成

51
00:02:12,600 --> 00:02:15,016
人们已经将他们的
姓名和电子邮件地址。

52
00:02:15,016 --> 00:02:18,160
我们写的代码，一点点的
可以遍历这些地址

53
00:02:18,160 --> 00:02:21,860
吐出的唯一地址的
至于有人提出多次。

54
00:02:21,860 --> 00:02:25,120
此后，我们发
从CS50的机器人自动发送的电子邮件，

55
00:02:25,120 --> 00:02:27,190
包括优惠券代码。

56
00:02:27,190 --> 00:02:29,290
>> 现在，我们还看了
这个构造最后一次。

57
00:02:29,290 --> 00:02:33,100
这是一个特殊的
比如什么？

58
00:02:33,100 --> 00:02:35,050
所以，是的，一个布尔表达式。

59
00:02:35,050 --> 00:02:37,050
和形状是指
捕捉到这一点。

60
00:02:37,050 --> 00:02:39,966
的所有这些问题，
形成真或假的划痕

61
00:02:39,966 --> 00:02:41,590
看起来有点像这样。

62
00:02:41,590 --> 00:02:43,200
我们称这是一个布尔表达式。

63
00:02:43,200 --> 00:02:46,170
这的确是真的还是假的，是或否。

64
00:02:46,170 --> 00:02:49,150
这是回答问题的方式。

65
00:02:49,150 --> 00:02:52,420
>> 而同时，你可以使用这些布尔
结构内部表达

66
00:02:52,420 --> 00:02:54,720
像这样的，它的
当然是条件

67
00:02:54,720 --> 00:02:57,259
或分支机构，谚语
岔路。

68
00:02:57,259 --> 00:02:59,550
他们不仅可以看
像这样的，但他们也可以

69
00:02:59,550 --> 00:03:02,080
他们已经偷别人的关联。

70
00:03:02,080 --> 00:03:05,820
而实际上你可以有一个三通
岔路口或四叉方式

71
00:03:05,820 --> 00:03:08,340
在路上，只要通过
筑巢这些东西，

72
00:03:08,340 --> 00:03:10,510
因为你会在看到划痕
如果你还没有。

73
00:03:10,510 --> 00:03:13,550
而且，你可以用C做的一样好。

74
00:03:13,550 --> 00:03:16,810
>> 让我们以另一种通才
看一个alumnist，还有，谁

75
00:03:16,810 --> 00:03:21,490
可能会呈现出不同的方法
这些东西叫做条件。

76
00:03:21,490 --> 00:03:24,060
>> 比尔盖茨：人们经常
每一天的决定。

77
00:03:24,060 --> 00:03:27,530
例如，在你走之前，你外面
种有一个if语句，上面写着：

78
00:03:27,530 --> 00:03:31,480
如果下雨那我
需要让我的夹克。

79
00:03:31,480 --> 00:03:36,820
和电脑是惊人的，一旦你
决定这些类型的语句，

80
00:03:36,820 --> 00:03:42,280
它们可以可靠地执行
这些东西在令人难以置信的速度。

81
00:03:42,280 --> 00:03:48,240
等计算机程序真的
是数学和一些一点点

82
00:03:48,240 --> 00:03:53,050
if语句的地方
该决定被做出。

83
00:03:53,050 --> 00:03:55,020
>> 戴维·J·马兰：那么作为
大家可能都知道，这是

84
00:03:55,020 --> 00:03:57,880
乡亲们像比尔·盖茨，
保罗·艾伦等人

85
00:03:57,880 --> 00:04:00,240
真正拉开序幕
所谓的个人计算机

86
00:04:00,240 --> 00:04:01,990
革命多年。

87
00:04:01,990 --> 00:04:04,140
我想，我们潜水前
到一些文案，

88
00:04:04,140 --> 00:04:09,920
我们希望有关的故事，从阿尔伯克基，
自然历史博物馆新墨西哥州的博物馆

89
00:04:09,920 --> 00:04:13,650
和科学，其中一些比尔·盖茨的“
和保罗·艾伦的故事最早

90
00:04:13,650 --> 00:04:17,470
是讲述我们现在怎么有
今天的PC和Mac等等。

91
00:04:17,470 --> 00:04:22,390
对于这一点，但是，我们需要两个志愿者
谁都有很好的旁白声音

92
00:04:22,390 --> 00:04:23,735
朗读的脚本。

93
00:04:23,735 --> 00:04:25,530
>> 好吧，怎么样在回到那里。

94
00:04:25,530 --> 00:04:26,120
上来吧。

95
00:04:26,120 --> 00:04:27,770
以及怎么样在前面这里。

96
00:04:27,770 --> 00:04:28,340
下来吧。

97
00:04:28,340 --> 00:04:29,600
把你的地方在这里。

98
00:04:29,600 --> 00:04:32,444
正如你们上来，一对夫妇
行政公告。

99
00:04:32,444 --> 00:04:34,360
切片时，处理
选择部分，

100
00:04:34,360 --> 00:04:36,068
将于本
周三至周五。

101
00:04:36,068 --> 00:04:38,400
更多关于这个未来
周三在演讲。

102
00:04:38,400 --> 00:04:41,770
>> 超级节，同时，在
我们下周提供的东西

103
00:04:41,770 --> 00:04:45,310
由此，整个班级的邀请
参加比较大型

104
00:04:45,310 --> 00:04:47,690
段，多了一个舒适，
少了一个舒适的。

105
00:04:47,690 --> 00:04:51,340
我们将公布详情
这一点，还有，在本周晚些时候。

106
00:04:51,340 --> 00:04:53,310
>> 同时段，
自己，将启动

107
00:04:53,310 --> 00:04:57,241
在三个课程一周，零指数，
这意味着那些一两个星期

108
00:04:57,241 --> 00:04:57,740
出来。

109
00:04:57,740 --> 00:04:58,450
所以不用担心。

110
00:04:58,450 --> 00:05:01,014
你还没有错过
沿着这些线路的东西。

111
00:05:01,014 --> 00:05:03,930
同时，在此期间，如果你
有任何问题行政，

112
00:05:03,930 --> 00:05:08,120
电子邮件我和德文郡和加布
和Rob在这里这个地址。

113
00:05:08,120 --> 00:05:10,320
>> 最后，问题集
0是当然的。

114
00:05:10,320 --> 00:05:12,320
您可能已经注意到了这一点
在球场上的网站。

115
00:05:12,320 --> 00:05:14,840
它应该为你提供
所有问题的答案

116
00:05:14,840 --> 00:05:18,250
你可能有沿途的
入门问题集。

117
00:05:18,250 --> 00:05:21,430
但是，如果你发现自己
需要援助之手的，

118
00:05:21,430 --> 00:05:25,020
通过各种手段参加工作时间，
周一，周二，周三，周四

119
00:05:25,020 --> 00:05:27,290
本周日晚
四食堂。

120
00:05:27,290 --> 00:05:31,650
看到有网址的资料
哪里办公时间应。

121
00:05:31,650 --> 00:05:34,000
>> 现在，让我们来认识我们
两位嘉宾今天。

122
00:05:34,000 --> 00:05:34,740
你叫什么名字？

123
00:05:34,740 --> 00:05:35,290
>> JAY PAUL：周杰伦保罗。

124
00:05:35,290 --> 00:05:36,880
>> 戴维·J·马兰：周杰伦
保罗，很高兴见到你。

125
00:05:36,880 --> 00:05:37,330
>> HIKARI：光速。

126
00:05:37,330 --> 00:05:37,975
>> 戴维·J·马兰：光速？

127
00:05:37,975 --> 00:05:38,250
>> HIKARI：光速。

128
00:05:38,250 --> 00:05:38,810
>> 戴维·J·马兰：光速。

129
00:05:38,810 --> 00:05:39,790
很高兴认识你。

130
00:05:39,790 --> 00:05:42,123
杰伊·保罗和阿光在
他们对这些音乐前

131
00:05:42,123 --> 00:05:45,100
站在我打印的两个脚本
今天上午从新墨西哥州

132
00:05:45,100 --> 00:05:46,692
自然历史博物馆和科学博物馆。

133
00:05:46,692 --> 00:05:48,400
而我的想法
我会做的开销

134
00:05:48,400 --> 00:05:52,830
是陪你朗诵
剧本，这段历史

135
00:05:52,830 --> 00:05:54,700
一些视觉影像，没有惊喜。

136
00:05:54,700 --> 00:05:57,512
>> 而我事先做了
是prehighlight在你的脚本

137
00:05:57,512 --> 00:05:59,470
你应该阅读，
你应该读什么。

138
00:05:59,470 --> 00:06:00,920
我们将主要
只是备用的段落。

139
00:06:00,920 --> 00:06:03,211
因此，这就像你可能会
做英语课。

140
00:06:03,211 --> 00:06:06,875
这真的迫使观众
相信你的故事在这里。

141
00:06:06,875 --> 00:06:07,600
我们可以？

142
00:06:07,600 --> 00:06:13,272
因此，这里的故事是，我们有一个
BASIC，并开始在剑桥。

143
00:06:13,272 --> 00:06:18,750
>> JAY PAUL：那是冬天，1974年，
在剑桥，马萨诸塞州

144
00:06:18,750 --> 00:06:20,240
这里冬季非常寒冷。

145
00:06:20,240 --> 00:06:22,800
一个大胡子，长头发
大学辍学命名

146
00:06:22,800 --> 00:06:27,280
保罗·艾伦是耐劳的整个哈佛
广场，专注于他的想法。

147
00:06:27,280 --> 00:06:31,050
他在那些日子里主要的当务之急
是如何让他的朋友，比尔·盖茨，

148
00:06:31,050 --> 00:06:34,974
退学去
与他的生意。

149
00:06:34,974 --> 00:06:37,890
HIKARI：两个已经走了
通过一些商业投资

150
00:06:37,890 --> 00:06:40,850
同时，开始在湖边
学校在西雅图的地方

151
00:06:40,850 --> 00:06:45,220
他们在支付了免费的电脑时间
在当地时间测试一台PDP-10电脑

152
00:06:45,220 --> 00:06:46,580
共享公司。

153
00:06:46,580 --> 00:06:50,930
最近的计划是退出
学校形成了一家软件公司。

154
00:06:50,930 --> 00:06:53,440
阿伦已经离开了华盛顿
州立大学。

155
00:06:53,440 --> 00:06:58,380
但在最后一刻，盖茨
决定坚持哈佛大学。

156
00:06:58,380 --> 00:07:02,080
>> JAY PAUL：那一天，哈佛大学渡
广场，艾伦看准一月

157
00:07:02,080 --> 00:07:07,530
1975年发行的热门电子产品
与地球停标题，

158
00:07:07,530 --> 00:07:11,900
世界上第一台小型机套件
对手的商业模式。

159
00:07:11,900 --> 00:07:14,430
下方的标题是
一个小盒子的图片

160
00:07:14,430 --> 00:07:16,160
装饰用灯和开关。

161
00:07:16,160 --> 00:07:19,770
这就是所谓的MITS牛郎星8800。

162
00:07:19,770 --> 00:07:24,100
和艾伦知道这是什么
他一直在寻找的。

163
00:07:24,100 --> 00:07:26,350
>> HIKARI：讨论天紧随其后。

164
00:07:26,350 --> 00:07:30,170
艾伦和盖茨理解
牛郎星的意义。

165
00:07:30,170 --> 00:07:32,480
他们经常讨论
关于微处理器

166
00:07:32,480 --> 00:07:35,250
并等着看
将与他们进行。

167
00:07:35,250 --> 00:07:39,770
现在有一个小型机套件
大众电子封面。

168
00:07:39,770 --> 00:07:42,830
它显然没有软件呢。

169
00:07:42,830 --> 00:07:46,830
他们想象的国度
程序员降在MITS公司。

170
00:07:46,830 --> 00:07:49,590
因此，他们被称为埃德·罗伯茨，
该公司的负责人，

171
00:07:49,590 --> 00:07:53,330
自称有一个版本的
BASIC编程语言几乎准备

172
00:07:53,330 --> 00:07:54,710
为Altair。

173
00:07:54,710 --> 00:07:55,570
他们没有。

174
00:07:55,570 --> 00:07:58,910
和罗伯茨一定知道他们没有。

175
00:07:58,910 --> 00:08:03,170
他渐渐从每天10个电话
谁的人有一个基本快好了。

176
00:08:03,170 --> 00:08:05,570
而他的股票的反应
是，“第一人

177
00:08:05,570 --> 00:08:11,090
谁显示了一个工作
基本得到了合同。“

178
00:08:11,090 --> 00:08:13,910
>> JAY PAUL：盖茨和艾伦
从来没有见过一个牵牛星。

179
00:08:13,910 --> 00:08:17,600
他们甚至从来没有见过的
英特尔8080微处理器

180
00:08:17,600 --> 00:08:19,060
在牛郎星的心脏。

181
00:08:19,060 --> 00:08:21,470
但几年前
艾伦曾编写过程序

182
00:08:21,470 --> 00:08:25,220
一台主机计算机上仿真
以前英特尔的操作

183
00:08:25,220 --> 00:08:26,217
微处理器。

184
00:08:26,217 --> 00:08:28,300
他们在这段时间
会做同样的事情。

185
00:08:28,300 --> 00:08:31,530

186
00:08:31,530 --> 00:08:34,380
>> HIKARI：随着英特尔
8080手动在他身边，

187
00:08:34,380 --> 00:08:37,770
艾伦在坐了下来
哈佛的PDP-10电脑

188
00:08:37,770 --> 00:08:42,010
并写下了仿真器和软件
必要的工具来完成编程。

189
00:08:42,010 --> 00:08:45,820
同时盖茨不再去
类和献身

190
00:08:45,820 --> 00:08:48,120
对设计的基础上，
利用一切伎俩

191
00:08:48,120 --> 00:08:53,130
他知道，以获得尺寸
向下跌破4千字节。

192
00:08:53,130 --> 00:08:55,870
>> JAY PAUL：出阿尔伯克基，
埃德·罗伯茨接到盖茨的电话

193
00:08:55,870 --> 00:08:59,754
问，详细了解如何
Altair的具体处理程序。

194
00:08:59,754 --> 00:09:01,170
从来没有人问过。

195
00:09:01,170 --> 00:09:02,670
和罗伯茨开始得到关注。

196
00:09:02,670 --> 00:09:05,240

197
00:09:05,240 --> 00:09:07,970
>> HIKARI：随着时代的发展
工具和设计准备，

198
00:09:07,970 --> 00:09:10,780
盖茨和艾伦写道：
在PDP-10中的代码，

199
00:09:10,780 --> 00:09:16,060
争取另一位哈佛大学的学生，
蒙大卫杜夫，写数学例程。

200
00:09:16,060 --> 00:09:19,450
之后的最后一晚
编程，阿伦坐上飞机

201
00:09:19,450 --> 00:09:22,970
提供基本为MITS公司。

202
00:09:22,970 --> 00:09:25,800
他花了乘坐飞机出令人担忧。

203
00:09:25,800 --> 00:09:28,490
而早在剑桥
盖茨担心。

204
00:09:28,490 --> 00:09:32,100
他们测试了他们基本的
它工作在模拟器上。

205
00:09:32,100 --> 00:09:35,444
但是，如果模拟器是错误的？

206
00:09:35,444 --> 00:09:37,360
JAY PAUL：随着飞机
走近阿尔伯克基，

207
00:09:37,360 --> 00:09:40,070
艾伦意识到，他们的
BASIC，现在整齐载

208
00:09:40,070 --> 00:09:42,460
在一个小卷
穿孔纸带，将

209
00:09:42,460 --> 00:09:44,970
将是一个没有独立没用
计划，叫装载机，那

210
00:09:44,970 --> 00:09:47,550
会告诉如何牛郎星
阅读纸带幸福

211
00:09:47,550 --> 00:09:49,620
送入电传打字机。

212
00:09:49,620 --> 00:09:52,970
他掏出笔记本，并迅速
潦草下来loader程序

213
00:09:52,970 --> 00:09:56,819
在汇编语言，然后手动
翻译说成1和0

214
00:09:56,819 --> 00:09:57,985
牛郎星会理解的。

215
00:09:57,985 --> 00:10:00,530

216
00:10:00,530 --> 00:10:03,830
>> HIKARI：艾伦期待
干净，小，高科技公司

217
00:10:03,830 --> 00:10:05,470
男人的西装运行。

218
00:10:05,470 --> 00:10:09,210
于是，他很惊讶，当罗伯茨见面
他在机场看上去就像一个大农场

219
00:10:09,210 --> 00:10:10,270
手。

220
00:10:10,270 --> 00:10:12,070
罗伯茨还惊奇。

221
00:10:12,070 --> 00:10:16,340
当他放弃了哈佛大学
程序员在昂贵的酒店，

222
00:10:16,340 --> 00:10:20,790
艾伦不得不承认，
他买不起房。

223
00:10:20,790 --> 00:10:24,510
>> JAY PAUL：MITS公司，本身是
坐落在一个尘土飞扬的地带商场。

224
00:10:24,510 --> 00:10:27,040
在里面凌乱
工作台是一个牵牛星

225
00:10:27,040 --> 00:10:30,390
装了5千字节
存储器和通过电缆连接

226
00:10:30,390 --> 00:10:32,030
以电传打字机。

227
00:10:32,030 --> 00:10:37,200
罗伯茨和总工程师，
比尔耶茨，等待着期待

228
00:10:37,200 --> 00:10:40,660
艾伦切换自己的装载机
计划到牛郎星。

229
00:10:40,660 --> 00:10:44,980
电传开始隆隆，因为它拉
纸带通过纸带阅读机。

230
00:10:44,980 --> 00:10:47,215
花了也许15分钟
加载程序。

231
00:10:47,215 --> 00:10:52,110
然后突然电传打印的
记忆的提示，然​​后一个现成的提示，

232
00:10:52,110 --> 00:10:55,340
和艾伦开始打字
一些测试命令。

233
00:10:55,340 --> 00:10:57,400
为了大家的惊愕，
该软件的工作。

234
00:10:57,400 --> 00:10:58,525
有当然的错误。

235
00:10:58,525 --> 00:11:02,070
更主要的是它的工作。

236
00:11:02,070 --> 00:11:06,570
>> HIKARI：后来，在他们的途中到
3.00美元午餐潘乔的，马蜂飞

237
00:11:06,570 --> 00:11:10,470
在拾取器的窗口
卡车和刺痛了艾伦的手臂。

238
00:11:10,470 --> 00:11:13,070
但在这一点上没有什么
会破坏心情。

239
00:11:13,070 --> 00:11:17,210
牛郎星现在有了基本的
一个家庭的第一商业软件

240
00:11:17,210 --> 00:11:23,260
计算机，由保罗·艾伦和比尔做
盖茨，做生意微软。

241
00:11:23,260 --> 00:11:25,336
>> 戴维·J·马兰：很多
由于我们两国的读者。

242
00:11:25,336 --> 00:11:30,690
>> [掌声]

243
00:11:30,690 --> 00:11:32,520
>> 戴维·J·马兰：现在
你有你的选择，

244
00:11:32,520 --> 00:11:35,880
你离开的闪闪发光，前
或者在dark--哦辉光，

245
00:11:35,880 --> 00:11:40,810
等待一秒钟，wait--闪闪发光
在黑暗的大象辉光

246
00:11:40,810 --> 00:11:42,534
从CS50自己的成功。

247
00:11:42,534 --> 00:11:43,450
HIKARI：哦，谢谢。

248
00:11:43,450 --> 00:11:45,324
戴维·J·马兰：全部
好，谢谢你这么多。

249
00:11:45,324 --> 00:11:49,855
[掌声]

250
00:11:49,855 --> 00:11:51,105
戴维·J·马兰：所以真实的故事。

251
00:11:51,105 --> 00:11:54,380
这就是说所有这些是
机器和易用性，使我们

252
00:11:54,380 --> 00:11:56,270
现在使用它们，并采取
理所当然的，真的

253
00:11:56,270 --> 00:12:00,070
从这里开始，仅几步之遥
从这个实际战场。

254
00:12:00,070 --> 00:12:03,930
而现在的今天，如果你还没有去过，
这是麦克斯韦德沃金，所述计算机

255
00:12:03,930 --> 00:12:05,810
科学建设，
也蠢蠢欲动。

256
00:12:05,810 --> 00:12:09,760
而在此二楼
建筑不挂三页

257
00:12:09,760 --> 00:12:12,740
从原来的源代码的
比尔·盖茨和保罗·艾伦写道。

258
00:12:12,740 --> 00:12:14,770
事实上，如果你使用放大
在您不仅可以看到

259
00:12:14,770 --> 00:12:17,350
其名称中
原始类型，但也

260
00:12:17,350 --> 00:12:22,100
他们的签名，他们装饰á
几年前，当他们最后一次访问。

261
00:12:22,100 --> 00:12:25,800
>> 但是，什么是特别引人注目
关于这就是他们所要做的

262
00:12:25,800 --> 00:12:29,760
是写一个程序，将
让其他人写的

263
00:12:29,760 --> 00:12:30,950
自己的方案。

264
00:12:30,950 --> 00:12:34,280
当时所有有带
这牵牛星机由MITS进行。

265
00:12:34,280 --> 00:12:40,020
和所有他们需要的是一些方法
因此很容易为业余爱好者和人民

266
00:12:40,020 --> 00:12:45,300
喜欢我们在这个房间里居然程序
如果没有一定了解

267
00:12:45,300 --> 00:12:49,060
汇编代码或机器
码，或上帝保佑，0和1。

268
00:12:49,060 --> 00:12:51,190
我们的程序员一样，
那些在这个房间里，我们

269
00:12:51,190 --> 00:12:54,070
希望能够表达
自己更像伪代码

270
00:12:54,070 --> 00:12:57,330
即使这是一个有点更挑剔
挑剔比上周我们讨论。

271
00:12:57,330 --> 00:13:00,970
我们不希望写这样的代码，
保罗·艾伦和比尔·盖茨一样。

272
00:13:00,970 --> 00:13:04,850
相反，我们要编写代码，
看起来多了几分人性化。

273
00:13:04,850 --> 00:13:07,150
>> 现在，这就是所谓的基本语言。

274
00:13:07,150 --> 00:13:11,497
和行号有你
使用简单的数行代码

275
00:13:11,497 --> 00:13:12,330
那你写的。

276
00:13:12,330 --> 00:13:14,038
我们甚至不须
这样做的这些日子。

277
00:13:14,038 --> 00:13:16,060
但是你可以在这里看到
如何打印“你好，世界”

278
00:13:16,060 --> 00:13:18,660
的确大概印了这一点。

279
00:13:18,660 --> 00:13:22,710
还等什么比尔和保罗所做的是
授权人写这样的代码

280
00:13:22,710 --> 00:13:27,240
而不是of--如果你看一看的
计算机科学wall--这样的代码。

281
00:13:27,240 --> 00:13:29,290
>> 事实上，CS50最近
有机会

282
00:13:29,290 --> 00:13:32,540
坐下来与哈利·刘易斯教授
在计算机科学系，谁

283
00:13:32,540 --> 00:13:34,640
实际上教草案
盖茨几年前，

284
00:13:34,640 --> 00:13:38,460
而站在这里之前
这三页的摘录。

285
00:13:38,460 --> 00:13:39,560
让我们一起来看看。

286
00:13:39,560 --> 00:13:45,520
>> 哈里刘易斯：你在这里是
早期的软件上市

287
00:13:45,520 --> 00:13:50,240
写的比尔·盖茨和保罗
艾伦，微软的创始人。

288
00:13:50,240 --> 00:13:52,570
这样的代码是有趣
有两个原因。

289
00:13:52,570 --> 00:13:55,480
首先，它成为
微软的第一款产品，

290
00:13:55,480 --> 00:14:01,810
这是一个解释器
BASIC编程语言。

291
00:14:01,810 --> 00:14:04,940
其次，这是
第一次尝试之一

292
00:14:04,940 --> 00:14:10,580
创建一个解释如此平凡
人们可以使用个人电脑。

293
00:14:10,580 --> 00:14:12,670
>> 所以，比尔·盖茨是一个
本科在哈佛。

294
00:14:12,670 --> 00:14:14,820
我开始在哈佛大学1974年的教学。

295
00:14:14,820 --> 00:14:16,560
这是在1975年完成。

296
00:14:16,560 --> 00:14:20,180
所以这是他职业生涯的早期
在我职业生涯的早期。

297
00:14:20,180 --> 00:14:23,790
其实我教条例草案
在这段时间的课程。

298
00:14:23,790 --> 00:14:27,130
保罗·艾伦是不是
哈佛的学生，但他

299
00:14:27,130 --> 00:14:31,020
曾是一名高中
同学比尔·盖茨。

300
00:14:31,020 --> 00:14:33,740
如果你来看看
在清单中，将会

301
00:14:33,740 --> 00:14:36,230
居然找到第三
名，蒙大卫杜夫，

302
00:14:36,230 --> 00:14:39,260
谁是盖茨的同学
你们是哈佛。

303
00:14:39,260 --> 00:14:41,340
>> 好了，这里是一个
有趣的评论在这里。

304
00:14:41,340 --> 00:14:47,150
它说：“在4K可以删除平方根
但对于循环应该仍然有效。“

305
00:14:47,150 --> 00:14:53,080
好了，这是什么意思是，有
两种方法来编译这个程序。

306
00:14:53,080 --> 00:14:57,860
一个是上一个版本运行
这牛郎星电脑

307
00:14:57,860 --> 00:15:04,310
只有具有4K字
存储器中，存储器4096字。

308
00:15:04,310 --> 00:15:07,050
但大版本有8K。

309
00:15:07,050 --> 00:15:09,770
还等什么这说的是
，在4K版本

310
00:15:09,770 --> 00:15:12,770
你必须删除一些
代码，使其适合。

311
00:15:12,770 --> 00:15:14,790
和的事情之一
这将被删除

312
00:15:14,790 --> 00:15:16,290
将平方根例程。

313
00:15:16,290 --> 00:15:20,360
但显然
for循环应该还是

314
00:15:20,360 --> 00:15:26,392
当你编译下工作，即使
对于刚刚4K版本的计算机。

315
00:15:26,392 --> 00:15:29,350
戴维·J·马兰：所以的主题之一，
我们将在计算机科学中看到，

316
00:15:29,350 --> 00:15:31,430
是这个概念
分层和抽象，

317
00:15:31,430 --> 00:15:34,670
真正站在肩膀上
人谁已经来到我们面前，不是

318
00:15:34,670 --> 00:15:37,890
不像某些比尔·盖茨
和保罗·艾伦的叙事在这里。

319
00:15:37,890 --> 00:15:40,080
而这句话的意思是
今天，我们可以采取

320
00:15:40,080 --> 00:15:43,490
理所当然的事情，其实
我们更容易编写代码。

321
00:15:43,490 --> 00:15:47,170
事实上代码，因为我们上周五表示，为
更多技术上称为源代码。

322
00:15:47,170 --> 00:15:52,210
而正是这种英语的语法
这是更合适的，更明确

323
00:15:52,210 --> 00:15:55,480
不是像伪代码，
其中有没有正式的定义。

324
00:15:55,480 --> 00:15:58,320
>> 今天我们要去
关注的是源代码

325
00:15:58,320 --> 00:16:01,010
看起来像这样，这
诚然，乍一看

326
00:16:01,010 --> 00:16:02,690
看起来完全隐蔽。

327
00:16:02,690 --> 00:16:08,540
坦率地说，它的方式更加美观
较复杂的底层程序。

328
00:16:08,540 --> 00:16:13,300
所有这些程序呢，
召回，是我们没有说什么？

329
00:16:13,300 --> 00:16:14,990
它只是打印的“hello world”。

330
00:16:14,990 --> 00:16:19,600
然而，看看所有我们需要的东西
环绕这很简单的短语。

331
00:16:19,600 --> 00:16:21,750
但没过多久全部
这些线路多

332
00:16:21,750 --> 00:16:24,800
会更好的感觉给你。

333
00:16:24,800 --> 00:16:26,940
>> 且流程如下。

334
00:16:26,940 --> 00:16:31,220
我们需要在我们的处置
是取码，如源

335
00:16:31,220 --> 00:16:32,340
我们刚才看到的代码。

336
00:16:32,340 --> 00:16:35,060
我们需要一个新的计划
通过运行它。

337
00:16:35,060 --> 00:16:39,130
我们需要算法，可以
转换的源代码，这样，

338
00:16:39,130 --> 00:16:41,932
成目标代码，0和1。

339
00:16:41,932 --> 00:16:43,890
换句话说，什么
我们今天要学

340
00:16:43,890 --> 00:16:46,620
是如何做到这一点，写
源代码往上顶，

341
00:16:46,620 --> 00:16:49,930
把它作为输入到一个特殊的
程序被称为编译程序，

342
00:16:49,930 --> 00:16:52,140
而我们将要产生的目标代码。

343
00:16:52,140 --> 00:16:54,600
这是只是一种奇特的方式
他说，我们将采取什么

344
00:16:54,600 --> 00:16:58,350
看起来像这样，通过它
成称为编译程序，

345
00:16:58,350 --> 00:17:01,210
产生的目标代码
看起来是这样的。

346
00:17:01,210 --> 00:17:04,720
>> 因此，这些都是字面上
0和1的模式

347
00:17:04,720 --> 00:17:08,550
是由一个理解
英特尔电脑这几天，

348
00:17:08,550 --> 00:17:12,480
如果解释由CPU，
电脑里面的大脑，

349
00:17:12,480 --> 00:17:16,130
将逐字打印出来，
很简单，“世界你好”。

350
00:17:16,130 --> 00:17:19,670
现在有比你更多的方式0和1
希望可能需要为该。

351
00:17:19,670 --> 00:17:22,520
那是因为我们正在建设
一个很好的协议的复杂性

352
00:17:22,520 --> 00:17:24,270
我们可以从此理所当然的。

353
00:17:24,270 --> 00:17:27,869
换句话说，很多聪明的人
给我们提供了很多很酷的工具

354
00:17:27,869 --> 00:17:32,480
和强大的软件，使用它我们
现在可以让我们自己的项目。

355
00:17:32,480 --> 00:17:33,400
>> 所以，让我们开始吧。

356
00:17:33,400 --> 00:17:36,640
而上周五，和
对于习题集0本周，

357
00:17:36,640 --> 00:17:39,000
你会打的
世界是这样的。

358
00:17:39,000 --> 00:17:42,180
从今天起和问题
设置1，下周代码

359
00:17:42,180 --> 00:17:45,410
会看起来多了几分
神秘，但在功能上是

360
00:17:45,410 --> 00:17:46,940
将是相同的。

361
00:17:46,940 --> 00:17:50,770
所以通知，上面是从无到有，
底部是C坦白划痕

362
00:17:50,770 --> 00:17:52,780
是一个很大的用户
友好访问。

363
00:17:52,780 --> 00:17:56,890
但如果你现在比较直观顶部
底部，有一种一对一的

364
00:17:56,890 --> 00:17:59,690
之间的对应关系
拼图块和语言

365
00:17:59,690 --> 00:18:00,870
我们即将一起玩。

366
00:18:00,870 --> 00:18:04,420
特别是，就是说，
蓝色拼图往上顶，

367
00:18:04,420 --> 00:18:08,370
显然相当于什么关键字
在这门语言或特殊短语

368
00:18:08,370 --> 00:18:09,062
称为C？

369
00:18:09,062 --> 00:18:09,770
听众：printf的。

370
00:18:09,770 --> 00:18:10,728
戴维·J·马兰：printf的。

371
00:18:10,728 --> 00:18:12,140
这意味着格式化打印。

372
00:18:12,140 --> 00:18:15,240
而这只是一个幻想
说法printf的C语言的方式

373
00:18:15,240 --> 00:18:18,615
将会是一个语句或函数
可打印的东西到屏幕上。

374
00:18:18,615 --> 00:18:19,990
这是什么打印到屏幕上？

375
00:18:19,990 --> 00:18:23,627
不管你告诉它里面
的报价，括号内。

376
00:18:23,627 --> 00:18:25,460
如此反复，无可否认，
有很多东西

377
00:18:25,460 --> 00:18:27,990
你必须记住，
括号，引号，分号，

378
00:18:27,990 --> 00:18:28,656
和所有的这一点。

379
00:18:28,656 --> 00:18:30,600
但是，所有这一切是那种
的旁边的点。

380
00:18:30,600 --> 00:18:33,660
有趣的外卖现在
是，在划痕的发言权块

381
00:18:33,660 --> 00:18:37,520
几乎是等同于
在C中的printf语句

382
00:18:37,520 --> 00:18:41,390
>> 同时，黄色拼图
向上顶，当绿旗点击，

383
00:18:41,390 --> 00:18:44,736
大概相当于
在这里什么关键字？

384
00:18:44,736 --> 00:18:45,360
听众：主。

385
00:18:45,360 --> 00:18:46,359
戴维·J·马兰：那么主要。

386
00:18:46,359 --> 00:18:47,410
也许诠释，也许作废。

387
00:18:47,410 --> 00:18:51,280
但主要的有点像声音
这一点很重要，确实是。

388
00:18:51,280 --> 00:18:54,080
所以，当绿旗点击
又正是一块拼图

389
00:18:54,080 --> 00:18:56,390
揭开序幕的
整个耐刮划。

390
00:18:56,390 --> 00:19:02,140
但是，我们要现在就开始打电话
在主，此功能称为主。

391
00:19:02,140 --> 00:19:06,410
>> 现在，同时我们会
这个概括如下。

392
00:19:06,410 --> 00:19:08,780
我们可以称说的功能。

393
00:19:08,780 --> 00:19:10,580
它可能看起来
具体是这样的。

394
00:19:10,580 --> 00:19:11,770
那么，怎么样的循环？

395
00:19:11,770 --> 00:19:16,540
如果我们要开始转换，或
翻译更从头℃，

396
00:19:16,540 --> 00:19:19,400
这件事情在这里显然是刚刚
说的“hello world”永远的。

397
00:19:19,400 --> 00:19:23,060
如果这些关联如此
在划痕猫的脚本，

398
00:19:23,060 --> 00:19:26,560
它只是要不停地说
在某种卡通气泡，

399
00:19:26,560 --> 00:19:29,922
“世界你好，你好世界，你好
世界“广告nauseum，直到永远。

400
00:19:29,922 --> 00:19:33,130
如果我们想要做类似的事情
C，它会显得有点神秘。

401
00:19:33,130 --> 00:19:35,463
但是，我们可以达到同样的
结果，我们最终会

402
00:19:35,463 --> 00:19:36,861
发现，像这样的语法。

403
00:19:36,861 --> 00:19:39,360
我要再次用printf，
因为在一天结束时

404
00:19:39,360 --> 00:19:42,040
我想打印的“hello world”。

405
00:19:42,040 --> 00:19:45,610
而我显然使用的是
关键字是不是永远。

406
00:19:45,610 --> 00:19:47,320
这是不是同时的话。

407
00:19:47,320 --> 00:19:49,650
但就在语义
英语，种时

408
00:19:49,650 --> 00:19:52,120
表明某种循环或周期。

409
00:19:52,120 --> 00:19:55,070
>> 因此出现这种情况是
在C使用的关键字。

410
00:19:55,070 --> 00:20:00,700
虽然如此，为什么不同时
真正有效的意思是永远不会消失？

411
00:20:00,700 --> 00:20:04,240
好吧，虽然，因为我们很快就会
欣赏所有的越多，

412
00:20:04,240 --> 00:20:08,140
具有此括号旁边
在那里你可以把一个布尔表达式。

413
00:20:08,140 --> 00:20:11,360
而只要是
表达式为true，则此代码，

414
00:20:11,360 --> 00:20:14,750
在这两者之间，并标示
大括号，我们会打电话给他们，

415
00:20:14,750 --> 00:20:16,880
将只保留一次又一次地运行。

416
00:20:16,880 --> 00:20:18,410
>> 所以，真实不虚。

417
00:20:18,410 --> 00:20:20,900
因此，尽管真正的手段
只是这样做下去。

418
00:20:20,900 --> 00:20:23,480
这几乎是一个愚蠢的
构建表达自己。

419
00:20:23,480 --> 00:20:26,590
但是没有永远
在C语言关键字有一段时间。

420
00:20:26,590 --> 00:20:29,390
并有一个很简单的
布尔表达式像真的。

421
00:20:29,390 --> 00:20:32,210
所以，我们会看到，
实现相同的结果。

422
00:20:32,210 --> 00:20:33,890
>> 你可能怎么回事实现一个循环？

423
00:20:33,890 --> 00:20:36,980
那么，在刮你可能
硬编码一个特定的数

424
00:20:36,980 --> 00:20:39,430
在这里的循环迭代。

425
00:20:39,430 --> 00:20:43,210
所以这正是我们
可能会做在这个版本的C，

426
00:20:43,210 --> 00:20:46,140
因此，我们有一个所谓的循环。

427
00:20:46,140 --> 00:20:49,850
和for循环在这里是怎么回事
迭代，有点神秘地，

428
00:20:49,850 --> 00:20:54,100
从提升价值0
到，但小于10。

429
00:20:54,100 --> 00:20:55,955
>> 现在，变量划伤。

430
00:20:55,955 --> 00:20:57,830
你可能不会有
际使用这些。

431
00:20:57,830 --> 00:21:02,516
但有什么意义，在一般情况下，
变量上周我说？

432
00:21:02,516 --> 00:21:03,015
那是什么？

433
00:21:03,015 --> 00:21:03,780
>> 听众：点。

434
00:21:03,780 --> 00:21:05,200
>> 戴维·J·马兰：来点？

435
00:21:05,200 --> 00:21:05,700
呵呵，点。

436
00:21:05,700 --> 00:21:07,620
好吧，跟踪点，
例如，在一个游戏。

437
00:21:07,620 --> 00:21:09,510
或者更一般地做
与变量是什么？

438
00:21:09,510 --> 00:21:10,450
什么是他们的效用？

439
00:21:10,450 --> 00:21:10,825
>> 听众：内存。

440
00:21:10,825 --> 00:21:11,750
>> 戴维·J·马兰：是啊，所以内存。

441
00:21:11,750 --> 00:21:13,000
它是用来存储东西。

442
00:21:13,000 --> 00:21:17,336
和愚蠢的视觉í排序中使用
最后一次是这样的玻璃碗。

443
00:21:17,336 --> 00:21:19,710
如果我们想存储
一些变量里面，

444
00:21:19,710 --> 00:21:21,918
例如，现在的
值是6，因为有

445
00:21:21,918 --> 00:21:23,450
六个乒乓球在这里。

446
00:21:23,450 --> 00:21:26,158
这只是某种存储
容器，该发动机罩下方

447
00:21:26,158 --> 00:21:30,030
与位0和1实施
然而，一台电脑发生这样做。

448
00:21:30,030 --> 00:21:32,900
>> 因此，在划痕，如果我们
希望有一个变量，

449
00:21:32,900 --> 00:21:34,840
我们可以用一个橙色块这样。

450
00:21:34,840 --> 00:21:37,050
我们称之为反
在这种特殊情况下。

451
00:21:37,050 --> 00:21:38,890
I初始化为0。

452
00:21:38,890 --> 00:21:41,080
什么是我那时候怎么办？

453
00:21:41,080 --> 00:21:44,780
永远的，说柜台，而如果
你在玩刮，

454
00:21:44,780 --> 00:21:45,780
你只看到划痕。

455
00:21:45,780 --> 00:21:49,920
你把猫或其他服装
他将在议题发言的次数。

456
00:21:49,920 --> 00:21:52,840
>> 1更改计数器
如按1递增。

457
00:21:52,840 --> 00:21:56,580
所以这是要
从什么那么什么算什么？

458
00:21:56,580 --> 00:21:59,114
从0直到无穷大，或
直到划痕休息，

459
00:21:59,114 --> 00:22:01,030
或之类的，直到你
失去观看的兴趣

460
00:22:01,030 --> 00:22:02,650
他有多高其实可以算。

461
00:22:02,650 --> 00:22:04,800
>> 那么我们如何把它转换为C？

462
00:22:04,800 --> 00:22:06,480
它会显得有点神秘。

463
00:22:06,480 --> 00:22:08,896
但同样，如果你看一下每个
这些线的单独

464
00:22:08,896 --> 00:22:10,410
他们那种阵容一般。

465
00:22:10,410 --> 00:22:13,526
因此很明显，int是要
有C语言的一些特殊含义

466
00:22:13,526 --> 00:22:14,400
我们将看到一次。

467
00:22:14,400 --> 00:22:15,810
顺便说一句这意味着整数。

468
00:22:15,810 --> 00:22:16,990
所以它只是意味着数量。

469
00:22:16,990 --> 00:22:18,920
所以，这类型
玻璃碗我想，人们

470
00:22:18,920 --> 00:22:21,120
可以存储数字
不是乒乓球。

471
00:22:21,120 --> 00:22:25,520
而我将用等号
那里给它分配一个0值。

472
00:22:25,520 --> 00:22:29,440
所以这是很喜欢集
计数器为0，但在C

473
00:22:29,440 --> 00:22:32,840
>> 同时，在真实的，那就是
等效，当然，永远，

474
00:22:32,840 --> 00:22:35,980
尽管这是一个有点神秘，
然后里面的花括号中。

475
00:22:35,980 --> 00:22:39,188
你也可以认为这些花括号，
您可以输入键盘上，

476
00:22:39,188 --> 00:22:43,110
因为真的是像在曲率
这些黄色的环块划伤。

477
00:22:43,110 --> 00:22:45,700
它包括多行代码。

478
00:22:45,700 --> 00:22:48,120
>> printf的是得到一个
现在有点吓人，因为我

479
00:22:48,120 --> 00:22:51,120
不仅看到行情在括号中。

480
00:22:51,120 --> 00:22:55,160
还有什么是新的
语法在这个例子？

481
00:22:55,160 --> 00:22:57,300
有一成Ð。

482
00:22:57,300 --> 00:22:58,551
然后反斜杠n是在那里。

483
00:22:58,551 --> 00:23:00,883
我们也看到，之前，即使
虽然我没有提到它。

484
00:23:00,883 --> 00:23:01,886
然后有一个逗号。

485
00:23:01,886 --> 00:23:03,010
然后还有一个计数器。

486
00:23:03,010 --> 00:23:05,010
>> 但是，我们可以看到在短短的
矩，这仅仅是

487
00:23:05,010 --> 00:23:09,080
说法打印的标准方式
“小数”，报价，引文结束，

488
00:23:09,080 --> 00:23:10,500
一些十进制数。

489
00:23:10,500 --> 00:23:13,370
不过，我以后告诉你
什么是十进制数是。

490
00:23:13,370 --> 00:23:16,835
因此，事实上，有一个逗号
在此行中的printf的说法，

491
00:23:16,835 --> 00:23:18,710
是指直接进行打印
一些十进制数。

492
00:23:18,710 --> 00:23:23,110
哦，对了，号码是
不管这个变量的值是。

493
00:23:23,110 --> 00:23:25,880
因此，使这更
显然，我们将看到一个例子

494
00:23:25,880 --> 00:23:30,930
不久，涉及的printf到底
在真正的C程序的上下文。

495
00:23:30,930 --> 00:23:33,472
>> 现在只是换了一些
这些结构。

496
00:23:33,472 --> 00:23:36,680
布尔表达式，你可能没有
机会在你的程序中使用这些

497
00:23:36,680 --> 00:23:39,450
但你很可能，
尤其是在使用条件。

498
00:23:39,450 --> 00:23:43,460
所以这两个例子从
从头开始的意思是如果x小于y，

499
00:23:43,460 --> 00:23:48,770
或者如果x小于y和y是少
大于Z，我们如何翻译呢？

500
00:23:48,770 --> 00:23:50,810
>> 那么，在C中它只是
会是这样的。

501
00:23:50,810 --> 00:23:55,300
有点神秘，更括号，
一些奇怪的符号（＆），但从根本上

502
00:23:55,300 --> 00:23:59,160
的想法很简单，因为他们
在一块拼图的世界。

503
00:23:59,160 --> 00:24:02,690
我们只是如果有什么检查
不到别的东西。

504
00:24:02,690 --> 00:24:03,910
>> 怎么样的条件？

505
00:24:03,910 --> 00:24:09,710
在英语简单地说，这是什么
的划痕代码块做，你会说什么？

506
00:24:09,710 --> 00:24:11,050
>> 听众：比较两个数字。

507
00:24:11,050 --> 00:24:13,760
>> 戴维·J·马兰：比较两个
号，并且如果x小于y

508
00:24:13,760 --> 00:24:14,860
它说为多。

509
00:24:14,860 --> 00:24:18,080
如果x大于y
它说为多，其他

510
00:24:18,080 --> 00:24:20,740
如果x是等于y它说为多。

511
00:24:20,740 --> 00:24:22,180
现在在哪里x和y是从哪里来的？

512
00:24:22,180 --> 00:24:22,680
谁知道。

513
00:24:22,680 --> 00:24:25,380
划痕的这一块
代码是断章取义。

514
00:24:25,380 --> 00:24:29,050
但是，我们现在要做的是翻译
这只是一瞬间看到的。

515
00:24:29,050 --> 00:24:31,660
>> 所以，当你舒服
本周习题集

516
00:24:31,660 --> 00:24:34,190
0在这个世界上扮演
在左边，实现

517
00:24:34,190 --> 00:24:36,940
该理念并没有改变
本周或下周或以后。

518
00:24:36,940 --> 00:24:38,690
我们只是要
开始写东西

519
00:24:38,690 --> 00:24:41,240
以不同的方式与我们的
键盘而不是鼠标了。

520
00:24:41,240 --> 00:24:44,577
>> 因此，如果x小于y和
有一些括号那里，

521
00:24:44,577 --> 00:24:47,160
再有就是一些大括号
种再封装它

522
00:24:47,160 --> 00:24:48,970
就像黄色拼图做。

523
00:24:48,970 --> 00:24:53,000
我要去给printf点¯x
小于y等等。

524
00:24:53,000 --> 00:24:56,540
>> 什么是好的关于C，
你可以在这里看到，

525
00:24:56,540 --> 00:25:00,480
是你没有得到这个嵌套，
嵌套，嵌套那是必然

526
00:25:00,480 --> 00:25:02,220
将你的代码推到右侧。

527
00:25:02,220 --> 00:25:04,990
您可以改为拥有一切
阵容整齐这样。

528
00:25:04,990 --> 00:25:08,960
但是，这只是一种美学
细节我们将在不久再见到。

529
00:25:08,960 --> 00:25:09,660
>> 好吧。

530
00:25:09,660 --> 00:25:13,290
所以这使我们回到
这个神秘的寻找程序。

531
00:25:13,290 --> 00:25:15,180
让我们来实际编写一些代码。

532
00:25:15,180 --> 00:25:16,830
现在，你如何去写代码？

533
00:25:16,830 --> 00:25:21,310
所有你所拥有的这些年
在Mac或PC，台式机或笔记本电脑，

534
00:25:21,310 --> 00:25:24,520
你确实有能力
开始编写程序代码。

535
00:25:24,520 --> 00:25:27,050
但是你可能会丢失
一种特殊类型的程序。

536
00:25:27,050 --> 00:25:28,470
你当然可以编写代码。

537
00:25:28,470 --> 00:25:30,740
但是你不一定能，
开箱即，

538
00:25:30,740 --> 00:25:34,210
转换的源代码
成目标代码，0和1

539
00:25:34,210 --> 00:25:35,619
没有你的电脑是什么？

540
00:25:35,619 --> 00:25:36,410
听众：编译器。

541
00:25:36,410 --> 00:25:37,630
戴维·J·马兰：那么编译器吧。

542
00:25:37,630 --> 00:25:39,730
现在，你们中的大多数可能
没有自己的编译器，

543
00:25:39,730 --> 00:25:41,259
从来没有下载的编译器。

544
00:25:41,259 --> 00:25:44,300
但是你会看到，你可以下载它
象大多数其它的软件。

545
00:25:44,300 --> 00:25:47,470
在Mac OS中的世界，你可能会
下载或已下载

546
00:25:47,470 --> 00:25:50,437
一些所谓的Xcode或GCC或锵。

547
00:25:50,437 --> 00:25:52,270
如果你来自
Windows世界，你可能会

548
00:25:52,270 --> 00:25:56,190
下载Visual Studio中，
Visual Basic中，环境类的。

549
00:25:56,190 --> 00:25:59,200
有几十个编译器
这些天，你可能会使用。

550
00:25:59,200 --> 00:26:01,940
但是它的短这里
是，这将是一个痛苦

551
00:26:01,940 --> 00:26:04,480
，坦率地说，一个技术
噩梦数百

552
00:26:04,480 --> 00:26:07,680
的人患有不同
电脑的配置，所有的

553
00:26:07,680 --> 00:26:09,800
配置自己的机器
以完全相同的方式

554
00:26:09,800 --> 00:26:11,700
让我们都可以在同一页上。

555
00:26:11,700 --> 00:26:15,240
>> 所以我们，相反，这样做
在CS50是我们给你

556
00:26:15,240 --> 00:26:18,349
一个标准的环境中，
Linux环境下这是

557
00:26:18,349 --> 00:26:20,140
去看看小
这样的事情。

558
00:26:20,140 --> 00:26:22,980
你会看到更多这样的
问题1规范，

559
00:26:22,980 --> 00:26:25,330
将上网本星期五晚上去。

560
00:26:25,330 --> 00:26:28,360
>> 而这意味着什么
就是你从今以后

561
00:26:28,360 --> 00:26:32,060
要能够
下载并安装程序

562
00:26:32,060 --> 00:26:33,650
所谓的CS50电器。

563
00:26:33,650 --> 00:26:36,275
而且你要下载和
所谓安装其他程序

564
00:26:36,275 --> 00:26:40,300
虚拟机管理程序，它仅仅是一个
实现这一目标的假想方式。

565
00:26:40,300 --> 00:26:44,600
无论你拥有Mac还是PC或
Linux的计算机或计算机的Solaris，

566
00:26:44,600 --> 00:26:46,830
或什么疯狂的工作
你正在运行的系统，

567
00:26:46,830 --> 00:26:49,820
你要下载一个程序
所谓的虚拟机管理程序这是

568
00:26:49,820 --> 00:26:53,350
要运行CS50
电器在您的计算机上

569
00:26:53,350 --> 00:26:55,430
无论您的操作系统是什么。

570
00:26:55,430 --> 00:27:00,640
换句话说管理程序转换
我们的东西，以任何一种语言，

571
00:27:00,640 --> 00:27:03,850
无论你说明
自己的电脑理解。

572
00:27:03,850 --> 00:27:04,962
>> 所以这是一个分层。

573
00:27:04,962 --> 00:27:06,920
再次，这是一种
专题中的电脑

574
00:27:06,920 --> 00:27:08,722
科学，对事物的顶部建设。

575
00:27:08,722 --> 00:27:09,680
你可能有Windows。

576
00:27:09,680 --> 00:27:10,710
你可能有Mac的操作系统。

577
00:27:10,710 --> 00:27:12,960
但下周开始你
要下载

578
00:27:12,960 --> 00:27:14,980
一个免费的软件
所谓的虚拟机管理程序。

579
00:27:14,980 --> 00:27:17,800
你要下载的一块
软件名为CS50设备。

580
00:27:17,800 --> 00:27:21,050
>> 这是要在管理程序上运行，
这是要在计算机上运行。

581
00:27:21,050 --> 00:27:23,030
和最终的结果是
那大家都会

582
00:27:23,030 --> 00:27:26,220
有这样一个简单的窗口
这在您的Mac或PC

583
00:27:26,220 --> 00:27:30,160
这给了我们所有的幻想
运行相同的操作系统，

584
00:27:30,160 --> 00:27:32,800
没有任何其它
您的计算机上的影响。

585
00:27:32,800 --> 00:27:34,870
你可以全屏
它与基本行为

586
00:27:34,870 --> 00:27:37,550
就好像你正在运行的
所谓的Linux操作系统，

587
00:27:37,550 --> 00:27:40,270
这是什么CS50
设备是基于。

588
00:27:40,270 --> 00:27:42,930
>> 因此，让我们实际使用此
现在写一个程序。

589
00:27:42,930 --> 00:27:45,450
你可以写一个程序
使用Microsoft Word。

590
00:27:45,450 --> 00:27:48,160
你可以写一个程序
使用文本编辑，或记事本，

591
00:27:48,160 --> 00:27:51,880
或写字板，或几乎任何字
你曾经使用过的处理程序。

592
00:27:51,880 --> 00:27:55,174
但现实情况是，你不应该
使用真正的这些程序。

593
00:27:55,174 --> 00:27:57,840
你当然不应该使用
像Microsoft Word中，这

594
00:27:57,840 --> 00:28:01,120
有大胆的面对和斜体，和
大字体和小字体，

595
00:28:01,120 --> 00:28:03,560
因为电脑没有
关心任何。

596
00:28:03,560 --> 00:28:05,600
所有的电脑
要关心的是

597
00:28:05,600 --> 00:28:09,040
英语就像用C写的说明

598
00:28:09,040 --> 00:28:12,050
>> 所以我们会做内部
在CS50电器

599
00:28:12,050 --> 00:28:14,290
被自由使用的程序
可用，它的

600
00:28:14,290 --> 00:28:17,360
预先安装在此
家电，Gedit的叫。

601
00:28:17,360 --> 00:28:22,280
和Gedit是只是一个超级简单
文本编辑器，像Mac OS的文字编辑，

602
00:28:22,280 --> 00:28:26,200
如Windows记事本，那将
看起来有点像这样。

603
00:28:26,200 --> 00:28:28,910
>> 因此，让我们其实并不
看这个幻灯片。

604
00:28:28,910 --> 00:28:32,580
但是，让我们真正进入
环境本身。

605
00:28:32,580 --> 00:28:36,090
我要继续前进，
登录后，在该另一窗口，

606
00:28:36,090 --> 00:28:40,910
我的CS50电器，我已经
我的笔记本电脑预装了这里。

607
00:28:40,910 --> 00:28:43,771
>> 请注意，如Windows和
Mac OS中，它有一些菜单。

608
00:28:43,771 --> 00:28:45,520
像Windows却让
它在那儿，而不是

609
00:28:45,520 --> 00:28:47,020
的Mac OS中，它把它在那里。

610
00:28:47,020 --> 00:28:48,930
但现实是它的
所有种相同。

611
00:28:48,930 --> 00:28:50,770
而在这里是一个整体
一堆软件。

612
00:28:50,770 --> 00:28:51,770
有Dropbox的。

613
00:28:51,770 --> 00:28:54,780
还有一大堆的配件，
图形化的程序，我们会

614
00:28:54,780 --> 00:28:56,430
后来在任期问题集使用。

615
00:28:56,430 --> 00:28:59,650
有建在这么一个Web浏览器
这是一个全功能的电脑

616
00:28:59,650 --> 00:29:01,240
里面的电脑。

617
00:29:01,240 --> 00:29:04,170
>> 不过，我要点击这个
这里最左边的白色图标，

618
00:29:04,170 --> 00:29:05,890
这对于Gedit的图标。

619
00:29:05,890 --> 00:29:09,650
而且它会打开一个窗口
有三板给它，

620
00:29:09,650 --> 00:29:12,590
左1，个顶个，和底部的。

621
00:29:12,590 --> 00:29:16,071
>> 现在，在这个右上角一个
我要实际编写一些代码。

622
00:29:16,071 --> 00:29:16,820
因此，让我们做到这一点，。

623
00:29:16,820 --> 00:29:19,040
我要去文件，保存。

624
00:29:19,040 --> 00:29:22,100
你可能永远不会看到
这个特殊的窗口前。

625
00:29:22,100 --> 00:29:23,620
但是，这是像Mac OS或Windows。

626
00:29:23,620 --> 00:29:25,490
这只是一个窗口
所有的文件夹

627
00:29:25,490 --> 00:29:27,290
我有这台电脑里面。

628
00:29:27,290 --> 00:29:30,320
>> 我要去拯救
该文件的hello.c。

629
00:29:30,320 --> 00:29:32,690
我要去
未来，然后单击保存。

630
00:29:32,690 --> 00:29:36,364
现在发现我有一个标签
在左上叫hello.c的。

631
00:29:36,364 --> 00:29:38,280
所以，很可能
熟悉即使你不

632
00:29:38,280 --> 00:29:40,240
之前使用这个特定的程序。

633
00:29:40,240 --> 00:29:44,890
>> 现在，我要在那些输入
命令相当神秘的序列

634
00:29:44,890 --> 00:29:46,360
我们刚才看到的。

635
00:29:46,360 --> 00:29:49,330
包括标准I / O.h。

636
00:29:49,330 --> 00:29:50,600
更多关于不久。

637
00:29:50,600 --> 00:29:55,670
智力主要无效，左大
撑，收花括号。

638
00:29:55,670 --> 00:30:01,570
然后还有里面我觉得是
在那里我们有“世界你好”，分号。

639
00:30:01,570 --> 00:30:03,100
现在保存。

640
00:30:03,100 --> 00:30:08,780
>> 因此，这是用C语言编写的程序，
写入，因此，在源代码。

641
00:30:08,780 --> 00:30:10,720
但我不能只是运行此程序。

642
00:30:10,720 --> 00:30:13,390
我有点想翻番
点击一个图标的地方，

643
00:30:13,390 --> 00:30:16,390
但没有图标存在其他
比源代码文件。

644
00:30:16,390 --> 00:30:20,359
什么，又是过程，​​现在
我需要通过运行这个文件？

645
00:30:20,359 --> 00:30:21,150
听众：编译器。

646
00:30:21,150 --> 00:30:22,399
戴维·J·马兰：所以编译器。

647
00:30:22,399 --> 00:30:24,890
因此，在不同的计算机上你
以不同的方式做到这一点。

648
00:30:24,890 --> 00:30:27,480
不过，我们已经在这里做了
在CS50电器这

649
00:30:27,480 --> 00:30:31,260
代表你怎么可能
做到这一点在许多不同的系统，

650
00:30:31,260 --> 00:30:34,036
是，我只是要
运行一个叫做make命令。

651
00:30:34,036 --> 00:30:35,660
并作出简直是要做到这一点。

652
00:30:35,660 --> 00:30:36,640
让我的程序。

653
00:30:36,640 --> 00:30:39,060
>> 因此，请打算
运行一个编译器给我。

654
00:30:39,060 --> 00:30:42,160
和该程序的名称
我想提出的是你好。

655
00:30:42,160 --> 00:30:43,510
现在提出的是一个程序。

656
00:30:43,510 --> 00:30:47,170
并足以聪明
意识到如果我说让你好，

657
00:30:47,170 --> 00:30:50,980
它会自动查找
一个名为hello.c的文件

658
00:30:50,980 --> 00:30:53,420
只是因为这是
这样它的配置。

659
00:30:53,420 --> 00:31:00,300
>> 所以，当我打到现在进入这里，这
疯狂神秘的线刚刚被处决。

660
00:31:00,300 --> 00:31:02,720
相信我，才
长，在短短几天，

661
00:31:02,720 --> 00:31:05,590
你就会明白什么都
那废话手段。

662
00:31:05,590 --> 00:31:11,150
但现在，只知道做
触发执行一个编译器的。

663
00:31:11,150 --> 00:31:13,290
换句话说，它发现
编译器在我的电脑上

664
00:31:13,290 --> 00:31:14,820
这就是预装
在CS50电器

665
00:31:14,820 --> 00:31:16,560
我们会交给你的习题集1。

666
00:31:16,560 --> 00:31:20,990
它然后把hello.c中的
输入和明显产生

667
00:31:20,990 --> 00:31:23,040
0和1的输出。

668
00:31:23,040 --> 00:31:29,410
>> 并且在默认情况下它的作用是它可以节省
这些0和1在一个文件名为hello。

669
00:31:29,410 --> 00:31:33,180
虽然这个语法也可能
是新的给你，只是说点

670
00:31:33,180 --> 00:31:37,110
你好削减将是该
指我运行这个程序。

671
00:31:37,110 --> 00:31:40,360
>> 对于现在和至少一对夫妇
周的，几乎所有的节目

672
00:31:40,360 --> 00:31:44,230
我们写将要在
黑白文本窗口。

673
00:31:44,230 --> 00:31:47,006
没有鼠标，没有点击，
没有窗户，没有图标。

674
00:31:47,006 --> 00:31:49,630
我们要保持简单
并专注于基本思想

675
00:31:49,630 --> 00:31:52,490
一开始之前，我们得到的东西
更高的水平，例如，

676
00:31:52,490 --> 00:31:56,410
喜欢打出来的游戏，我们聊
关于上周的第一场演讲。

677
00:31:56,410 --> 00:32:00,820
>> 所以，当我打在这里输入，它的
在文本仅相当于环境

678
00:32:00,820 --> 00:32:03,272
要双击名为hello的图标。

679
00:32:03,272 --> 00:32:05,480
你还指望意志
发生时，我按下回车键呢？

680
00:32:05,480 --> 00:32:07,120
>> 听众：这将打印的“hello world”。

681
00:32:07,120 --> 00:32:10,000
>> 戴维·J·马兰：希望
将打印的“hello world”。

682
00:32:10,000 --> 00:32:11,370
事实上的确如此。

683
00:32:11,370 --> 00:32:13,690
现在，有过一些
在这里神秘的语法。

684
00:32:13,690 --> 00:32:15,950
让我们倒带仅售
一会儿，看看我们

685
00:32:15,950 --> 00:32:19,530
无法启动只是推断
修修补补，尝试和失败，

686
00:32:19,530 --> 00:32:21,130
至于什么是怎么回事。

687
00:32:21,130 --> 00:32:23,609
如果我摆脱了反斜杠的n？

688
00:32:23,609 --> 00:32:25,650
现在，你们中的一些谁已经
之前大概编程

689
00:32:25,650 --> 00:32:27,054
立刻知道这意味着什么。

690
00:32:27,054 --> 00:32:29,220
但是，对于那些你们谁已经
以前从来没有编程，

691
00:32:29,220 --> 00:32:34,052
至少觉得自己是怎么回事
当我重新运行该程序更改？

692
00:32:34,052 --> 00:32:37,010
所以，我要下来回到我
小黑白窗口，

693
00:32:37,010 --> 00:32:39,290
是窗口，其中
我可以编译的。

694
00:32:39,290 --> 00:32:41,130
我要重新编译打招呼。

695
00:32:41,130 --> 00:32:43,520
我们将看到相同的
命令的神秘序列。

696
00:32:43,520 --> 00:32:45,719
而我会做点斜线打招呼。

697
00:32:45,719 --> 00:32:48,260
而现在的人，如果你愿意，
谁从来没有编程之前，

698
00:32:48,260 --> 00:32:49,770
可能是什么不同呢？

699
00:32:49,770 --> 00:32:50,020
是啊。

700
00:32:50,020 --> 00:32:51,840
>> 听众：它不会停止
印刷的“hello world”。

701
00:32:51,840 --> 00:32:52,660
>> 戴维·J·马兰：这是怎么回事to--遗憾？

702
00:32:52,660 --> 00:32:54,210
>> 听众：它不会停止打印呢？

703
00:32:54,210 --> 00:32:55,810
>> 戴维·J·马兰：不会
停止打印的“hello world”。

704
00:32:55,810 --> 00:32:56,560
所以不是一个坏主意。

705
00:32:56,560 --> 00:32:58,633
其他的想法？

706
00:32:58,633 --> 00:32:59,132
是啊。

707
00:32:59,132 --> 00:33:00,060
>> 听众：错误讯息？

708
00:33:00,060 --> 00:33:01,750
>> 戴维·J·马兰：错误
消息确定，可能是。

709
00:33:01,750 --> 00:33:02,250
还有什么？

710
00:33:02,250 --> 00:33:05,479
听众：它可能打印
支架用分号呢？

711
00:33:05,479 --> 00:33:08,270
戴维·J·马兰：可能打印
支架以分号为好。

712
00:33:08,270 --> 00:33:11,950
所以也许这反斜线然后是一些
样的同时终止这很重要。

713
00:33:11,950 --> 00:33:14,860
任何其他的想法？

714
00:33:14,860 --> 00:33:16,412
>> 因此，所有的好点子。

715
00:33:16,412 --> 00:33:18,370
而事实上，这是怎么回事
为一个错误信息。

716
00:33:18,370 --> 00:33:20,400
这可能是最有可能的
是在一般的答案

717
00:33:20,400 --> 00:33:22,420
在接下来的几个星期
当我们学会了这里的代码。

718
00:33:22,420 --> 00:33:27,680
>> 但现在记得的电脑
只会做你告诉他们做什么。

719
00:33:27,680 --> 00:33:30,400
就像可笑的花生
酱和果冻的例子。

720
00:33:30,400 --> 00:33:33,860
我们人类的电脑只应该
做你告诉他们做什么。

721
00:33:33,860 --> 00:33:36,250
所以在这种情况下，如果
不要告诉电脑

722
00:33:36,250 --> 00:33:41,190
来移动闪烁的光标移动到
下一行，它不会做。

723
00:33:41,190 --> 00:33:45,390
所以，当我运行这个程序
现在，发现其中的差别。

724
00:33:45,390 --> 00:33:46,900
>> 看起来像一个错误。

725
00:33:46,900 --> 00:33:49,190
这是一个审美的错误，也许是。

726
00:33:49,190 --> 00:33:53,310
但是，什么是这个不同
输出与最后一个明显？

727
00:33:53,310 --> 00:33:53,810
是啊。

728
00:33:53,810 --> 00:33:54,920
>> 听众：它没有做新的生产线。

729
00:33:54,920 --> 00:33:56,586
>> 戴维·J·马兰：它没有做新的生产线。

730
00:33:56,586 --> 00:33:58,740
现在，你们谁
有可能做的网页

731
00:33:58,740 --> 00:34:01,910
以前，你可能知道的
BR标记或段落标记，

732
00:34:01,910 --> 00:34:03,120
非常相似的精神。

733
00:34:03,120 --> 00:34:06,680
Web浏览器会忽略你，直到
你告诉它该怎么做。

734
00:34:06,680 --> 00:34:10,020
同样的，就像C语言写成只
会做你告诉它的事情。

735
00:34:10,020 --> 00:34:12,730
>> 这样的理由是
所有的这些例子中，

736
00:34:12,730 --> 00:34:15,350
迄今为止，已经种
随便过这样的反斜线

737
00:34:15,350 --> 00:34:18,560
在那里，这是手段
通过它，你表达你自己

738
00:34:18,560 --> 00:34:21,380
作为新行字符，可以这么说。

739
00:34:21,380 --> 00:34:26,219
您还可以种体会，也许，
这看起来有点傻

740
00:34:26,219 --> 00:34:27,070
如果没有别的。

741
00:34:27,070 --> 00:34:29,150
如果我想要一个新的生产线，只是
按Enter键，然后种

742
00:34:29,150 --> 00:34:32,219
的屠宰一样，该代码
真的不应该擦你以正确的方式。

743
00:34:32,219 --> 00:34:33,830
即使你不
真正关心在这一点上，

744
00:34:33,830 --> 00:34:35,830
你会发现，
这不是一个特别

745
00:34:35,830 --> 00:34:37,870
好看的一段代码。

746
00:34:37,870 --> 00:34:39,969
>> 还等什么世界
决定年前

747
00:34:39,969 --> 00:34:43,420
当你想要把
光标移动到一个新行明确，

748
00:34:43,420 --> 00:34:46,332
你必须明确地说，
新的生产线，反斜线ñ。

749
00:34:46,332 --> 00:34:48,040
而且还有一些其他的
这样的符号。

750
00:34:48,040 --> 00:34:50,719
但现在我们只
专注于反斜线ñ。

751
00:34:50,719 --> 00:34:53,790
>> 现在，让我们把节目
更有趣一点。

752
00:34:53,790 --> 00:34:59,200
我要继续前进，
此时打开一个新的文件。

753
00:34:59,200 --> 00:35:02,520
我要保存此为hello-1.C。

754
00:35:02,520 --> 00:35:05,540
而就踢，我要
去把它放到我的Dropbox文件夹。

755
00:35:05,540 --> 00:35:09,030
>> 正如你将在CS50见
对于家电文档，

756
00:35:09,030 --> 00:35:11,210
本周晚些时候的问题
设置1，我们会鼓励

757
00:35:11,210 --> 00:35:13,230
您使用的Dropbox或
一些等价的服务，

758
00:35:13,230 --> 00:35:15,430
因为那时所有代码的
将被自动备份。

759
00:35:15,430 --> 00:35:17,830
因此，这就是为什么我
去到这个文件夹在这里。

760
00:35:17,830 --> 00:35:20,230
>> 现在我会写一
略有不同的程序。

761
00:35:20,230 --> 00:35:24,740
包括标准I / O.h，INT主要作废。

762
00:35:24,740 --> 00:35:29,660
然后在这里的printf，你好世界，
这也正是像以前一样。

763
00:35:29,660 --> 00:35:32,450
>> 但现在我想打印的东西
这是一个有点不同。

764
00:35:32,450 --> 00:35:34,800
我想打印出来，
说，“你好，大卫。”

765
00:35:34,800 --> 00:35:37,590
好吧，所以很明显，
它应该有希望

766
00:35:37,590 --> 00:35:40,360
是，如果我重新编译的情况下
这个程序，重新运行它，

767
00:35:40,360 --> 00:35:41,840
它会说“你好，戴维。”

768
00:35:41,840 --> 00:35:45,160
>> 但是，如果我想要的东西介绍
这种类型的变量，

769
00:35:45,160 --> 00:35:49,240
容器的概念，是怎么回事
存储的D-A-V-I-D，而不是硬编码

770
00:35:49,240 --> 00:35:50,600
到我的程序。

771
00:35:50,600 --> 00:35:53,430
好吧，如果我开始了
做这样的事情？

772
00:35:53,430 --> 00:35:57,120
>> 字符串s，所以这是一个变量。

773
00:35:57,120 --> 00:36:00,250
如果你想要一个字符串，
又名一个词或短语。

774
00:36:00,250 --> 00:36:03,485
字符的顺序是什么
我们在编程调用的字符串。

775
00:36:03,485 --> 00:36:06,610
我们只是去一般的呼叫
它s，因为它是一个不错的简单名称。

776
00:36:06,610 --> 00:36:08,010
不过，我可以把它叫做什么。

777
00:36:08,010 --> 00:36:12,920
>> 我要说的字符串s等于
报价引文结束，“大卫，”分号。

778
00:36:12,920 --> 00:36:18,330
现在我想插入
D-A-V-I-D成什么样，我打印。

779
00:36:18,330 --> 00:36:23,720
和我们之前看到的传情
对一些特殊的语法屏幕

780
00:36:23,720 --> 00:36:26,050
这使我们能够
替代的价值。

781
00:36:26,050 --> 00:36:29,250
什么是特殊
符号几张幻灯片前？

782
00:36:29,250 --> 00:36:30,040
>> 所以个百分点。

783
00:36:30,040 --> 00:36:33,830
当时它是百分比
d为十进制数。

784
00:36:33,830 --> 00:36:35,850
这不似乎真的与此有关。

785
00:36:35,850 --> 00:36:38,650
原来那里的
另一个百分号，

786
00:36:38,650 --> 00:36:42,810
这是百分之秒，它代表
一个占位符的字符串。

787
00:36:42,810 --> 00:36:49,350
>> 所以，现在，很简单，我
要去使喂-1，

788
00:36:49,350 --> 00:36:54,210
因为这个文件就是所谓的
HELLO-1.C，然后按Enter键。

789
00:36:54,210 --> 00:36:56,230
我搞砸了。

790
00:36:56,230 --> 00:36:57,394
这是怎么回事？

791
00:36:57,394 --> 00:37:00,560
好了，这里就是我们要开始
认识到我们在这个命令

792
00:37:00,560 --> 00:37:02,810
线环境中，这个
纯文字环境。

793
00:37:02,810 --> 00:37:06,114
有图标上单击鼠标无
像文件夹现在。

794
00:37:06,114 --> 00:37:07,280
和刚才想回来。

795
00:37:07,280 --> 00:37:10,740
在哪个文件夹没有我说的
我救了我的代码？

796
00:37:10,740 --> 00:37:11,657
所以Dropbox文件夹。

797
00:37:11,657 --> 00:37:12,989
本来叫什么。

798
00:37:12,989 --> 00:37:14,530
但它发生在被称为Dropbox的。

799
00:37:14,530 --> 00:37:18,380
所以，我莫名其妙地需要双击
即，为了得到收存箱文件夹

800
00:37:18,380 --> 00:37:21,657
然后送我
代码名为hello-1.C。

801
00:37:21,657 --> 00:37:24,490
其实，让我继续前进，并尽量减少
这个窗口只是一瞬间。

802
00:37:24,490 --> 00:37:27,560
就像Windows和Mac OS，
有在Linux下的文件夹。

803
00:37:27,560 --> 00:37:29,410
有在CS50电器夹。

804
00:37:29,410 --> 00:37:32,380
这只是我们马上围
自己这个文本的环境。

805
00:37:32,380 --> 00:37:34,700
>> 但是，如果我双击
对Dropbox的，注意有

806
00:37:34,700 --> 00:37:37,210
是我想对文件进行编译。

807
00:37:37,210 --> 00:37:41,430
但我需要这个黑白
终端窗口，可以这么说。

808
00:37:41,430 --> 00:37:45,750
但是，我所需要的，因此，移动
进入该文件夹或目录。

809
00:37:45,750 --> 00:37:48,290
所以稍微晦涩难懂，但
你会习惯这一点。

810
00:37:48,290 --> 00:37:50,430
>> 在Linux的世界，
这又是操作

811
00:37:50,430 --> 00:37:54,860
系统我们对CS50的内部运行
电器，有一个叫做cd命令。

812
00:37:54,860 --> 00:37:58,310
这意味着我可以做的光盘，空间，Dropbox的。

813
00:37:58,310 --> 00:37:59,900
CD，改变目录。

814
00:37:59,900 --> 00:38:00,400
右。

815
00:38:00,400 --> 00:38:02,890
早在一天，当人们
发明了计算机和操作系统

816
00:38:02,890 --> 00:38:05,806
像这样的系统，他们想
输入最少的按键可能。

817
00:38:05,806 --> 00:38:08,760
所以，最简单的方式说
更改目录为光盘。

818
00:38:08,760 --> 00:38:13,910
>> 所以，如果我打的CD，Dropbox的空间，
察觉到曾在这里改变。

819
00:38:13,910 --> 00:38:16,480
括号内的
该设备是一种

820
00:38:16,480 --> 00:38:19,360
humoring我和
提醒我我在哪里。

821
00:38:19,360 --> 00:38:21,480
所以打开的文件夹是Dropbox的。

822
00:38:21,480 --> 00:38:24,950
如果我现在输入ls的
列表中，再次简洁，

823
00:38:24,950 --> 00:38:27,540
因为人们不想
在当天L-I-S-T型背。

824
00:38:27,540 --> 00:38:29,300
因此，他们反而使得LS上。

825
00:38:29,300 --> 00:38:30,110
>> 输入。

826
00:38:30,110 --> 00:38:35,740
请注意，我看到两件事情，HELLO-1.C，
然后这个隐蔽的事情，源1米。

827
00:38:35,740 --> 00:38:38,310
这只是我的方式说
源代码1周星期一。

828
00:38:38,310 --> 00:38:42,020
这是我从下载的文件夹
CS50的网站，我今天早些时候提出

829
00:38:42,020 --> 00:38:43,990
而只是把它变成了
家电提前。

830
00:38:43,990 --> 00:38:47,550
>> 但现在我们唯一
在乎的是使这一计划。

831
00:38:47,550 --> 00:38:50,440
所以，当我键入make HELLO-1，回车。

832
00:38:50,440 --> 00:38:51,320
该死的。

833
00:38:51,320 --> 00:38:53,060
出事了。

834
00:38:53,060 --> 00:38:54,580
因此，让我们取笑这个分开。

835
00:38:54,580 --> 00:38:58,489
而不幸的是，这是哪里的东西
变得有点紧张，在第一，

836
00:38:58,489 --> 00:39:00,280
至少，如果你已经
以前从来没有编程。

837
00:39:00,280 --> 00:39:00,980
>> 我的上帝。

838
00:39:00,980 --> 00:39:04,990
我写了两行程序，并
我有四根线的错误。

839
00:39:04,990 --> 00:39:07,180
那么，什么是怎么回事。

840
00:39:07,180 --> 00:39:11,370
首先总是向后滚动
并发现第一个错误讯息，

841
00:39:11,370 --> 00:39:15,730
因为通常情况下编译器只
弄糊涂了你和我。

842
00:39:15,730 --> 00:39:17,000
编译器是非常愚蠢的。

843
00:39:17,000 --> 00:39:18,360
他们只会做什么
你告诉他们做什么。

844
00:39:18,360 --> 00:39:21,484
如果你迷惑他们，他们只是
要种丢了手

845
00:39:21,484 --> 00:39:25,010
也许投入更多的错误信息
比实际上是相关的。

846
00:39:25,010 --> 00:39:26,380
>> 因此，让我们来看看第一个。

847
00:39:26,380 --> 00:39:27,540
超级神秘的第一位。

848
00:39:27,540 --> 00:39:31,050
但注意，这里的名字
文件中，我搞砸了明显。

849
00:39:31,050 --> 00:39:36,570
结肠5，结肠5只指
第5行的第五个字符。

850
00:39:36,570 --> 00:39:39,760
因此，字符列第五，
如果你愿意，错误。

851
00:39:39,760 --> 00:39:41,870
使用未声明的标识符字符串。

852
00:39:41,870 --> 00:39:43,120
您的意思是标准N？

853
00:39:43,120 --> 00:39:44,850
>> 不，我的意思是字符串。

854
00:39:44,850 --> 00:39:47,640
然后它的种
复制和粘贴

855
00:39:47,640 --> 00:39:50,700
我打字真的画我
注意，我搞砸了。

856
00:39:50,700 --> 00:39:54,260
所以由于某些原因C，
或者至少编译器

857
00:39:54,260 --> 00:39:56,470
不理解的词串。

858
00:39:56,470 --> 00:39:57,890
那是因为我们和好了。

859
00:39:57,890 --> 00:40:01,440
所以字符串不存在
在C CS50是什么呢，

860
00:40:01,440 --> 00:40:03,380
在最初的几个星期
唯一的类，

861
00:40:03,380 --> 00:40:05,700
为我们提供一些培训
轮子，可以这么说。

862
00:40:05,700 --> 00:40:11,160
我们把这些辅助轮
所谓CS50.h.一个特殊的文件里

863
00:40:11,160 --> 00:40:14,970
>> 因此，这是两种文件的第二
名字中的点h上显然结束。

864
00:40:14,970 --> 00:40:16,300
让我们倒带。

865
00:40:16,300 --> 00:40:19,360
printf的是一个语句或函数
这显然​​是打印的东西

866
00:40:19,360 --> 00:40:20,580
到屏幕上。

867
00:40:20,580 --> 00:40:23,470
但是你没看到我
实现printf的，正确的。

868
00:40:23,470 --> 00:40:26,360
有人年前实现的printf。

869
00:40:26,360 --> 00:40:30,420
在什么样的文件，你会赌他
（或她）把实施

870
00:40:30,420 --> 00:40:34,270
在printf的，对于printf的代码？

871
00:40:34,270 --> 00:40:36,860
>> 在一个叫做标准的I / O.h文件。

872
00:40:36,860 --> 00:40:39,930
事实上，它可能是在
两个文件，​​标准I / O.h，

873
00:40:39,930 --> 00:40:42,650
它代表头
文件和标准I / O.c，

874
00:40:42,650 --> 00:40:44,060
它代表的C源代码。

875
00:40:44,060 --> 00:40:48,220
于是，他或她几年前屁股
他们写道：到该文件中的代码

876
00:40:48,220 --> 00:40:51,240
让我们这样的人
年后，可以将其包含，

877
00:40:51,240 --> 00:40:53,040
可以这么说，在我们自己的节目。

878
00:40:53,040 --> 00:40:56,320
>> 事实上，这就是井号
其次是字，包括做。

879
00:40:56,320 --> 00:41:00,250
它看起来在本地硬盘驱动器上，
发现所谓的标准I / O.h文件，

880
00:41:00,250 --> 00:41:03,840
然后有效地复制和
我自己的文件里粘贴了。

881
00:41:03,840 --> 00:41:07,210
所以现在我的程序知道
如何打印到屏幕上。

882
00:41:07,210 --> 00:41:11,120
>> 因此，通过这种逻辑，其中
是字符串定义？

883
00:41:11,120 --> 00:41:12,260
>> 听众：CS50.h.

884
00:41:12,260 --> 00:41:13,290
>> 戴维·J·马兰：CS50.h.

885
00:41:13,290 --> 00:41:15,540
事实上，这就是我们，
核心员工，都做了。

886
00:41:15,540 --> 00:41:19,590
我们已经发明了一些数据类型，
可以这么说，就像一个字符串，

887
00:41:19,590 --> 00:41:22,370
除了那些你
免费获得，如一个int。

888
00:41:22,370 --> 00:41:26,010
我们会看到其他类似一个char
一个字符和几个。

889
00:41:26,010 --> 00:41:30,670
里面的CS50.h显然是
至少某些提字符串。

890
00:41:30,670 --> 00:41:34,980
>> 所以，现在让我先走
并重新运行化妆HELLO-1。

891
00:41:34,980 --> 00:41:37,100
我会再次放大，穿过我的手指。

892
00:41:37,100 --> 00:41:41,370
现在已经做了一个
改变我固定的大多数事情。

893
00:41:41,370 --> 00:41:42,100
但是，该死的。

894
00:41:42,100 --> 00:41:44,290
更多百分比比数据参数。

895
00:41:44,290 --> 00:41:45,980
我做了什么错了这一次？

896
00:41:45,980 --> 00:41:47,420
>> 因此，它仍然是相当神秘的。

897
00:41:47,420 --> 00:41:51,560
但这个错误是
7号线和21字符。

898
00:41:51,560 --> 00:41:53,880
因此，让我们去看看在这里。

899
00:41:53,880 --> 00:41:55,350
这是一个有点微妙。

900
00:41:55,350 --> 00:41:59,167
但是如果你考虑一下
这里的基本思想是，

901
00:41:59,167 --> 00:42:00,500
或许我们可以这样取笑分开。

902
00:42:00,500 --> 00:42:02,300
>> 这样的printf是函数名。

903
00:42:02,300 --> 00:42:04,960
括号，迄今为止，是
就像我们把各地

904
00:42:04,960 --> 00:42:07,005
我们传递的东西
作为输入的函数。

905
00:42:07,005 --> 00:42:08,921
没事，只是一个
任意人会议。

906
00:42:08,921 --> 00:42:09,919
使用括号。

907
00:42:09,919 --> 00:42:12,460
里面的括号
我们已经把双引号，

908
00:42:12,460 --> 00:42:14,810
然后像一个字符串“Hello World”。

909
00:42:14,810 --> 00:42:18,160
>> 但是在前面的例子很
简单地做我们来看看有划痕。

910
00:42:18,160 --> 00:42:22,590
我们有百分之D，还有什么
是那些括号内

911
00:42:22,590 --> 00:42:23,730
我叫了口头上？

912
00:42:23,730 --> 00:42:24,230
是啊。

913
00:42:24,230 --> 00:42:28,166
>> 听众：所以这是你正在做什么
[听不清]，从[听不清]

914
00:42:28,166 --> 00:42:30,200
这是什么[听不清]？

915
00:42:30,200 --> 00:42:31,200
戴维·J·马兰：没错。

916
00:42:31,200 --> 00:42:32,700
因此，我们有百分之ð。

917
00:42:32,700 --> 00:42:36,620
但是，我们不得不关闭
引号，顿号，计数器。

918
00:42:36,620 --> 00:42:37,120
右。

919
00:42:37,120 --> 00:42:40,680
我们规定我们想要的
做作为占位符。

920
00:42:40,680 --> 00:42:44,621
所以，我什么都做的，是
逗号，你想要什么我把？

921
00:42:44,621 --> 00:42:45,120
听众：S。

922
00:42:45,120 --> 00:42:46,828
戴维·J·马兰：S，
因为本例中为

923
00:42:46,828 --> 00:42:48,700
是在存储容器的名称。

924
00:42:48,700 --> 00:42:50,180
那就是玻璃碗的名称。

925
00:42:50,180 --> 00:42:53,610
而在此之前它是反在那
简单的刮例子中，我们看着。

926
00:42:53,610 --> 00:42:56,630
所以，现在已经做了两个
变化，让我放大

927
00:42:56,630 --> 00:42:59,800
并尝试再次到
编译这个程序。

928
00:42:59,800 --> 00:43:01,596
>> 现在我看到神秘的线。

929
00:43:01,596 --> 00:43:03,470
但是，这实际上是
编译器的名称。

930
00:43:03,470 --> 00:43:04,886
铛是编译器的名称。

931
00:43:04,886 --> 00:43:07,100
让刚刚救了我
有史以来头痛

932
00:43:07,100 --> 00:43:09,830
打字那么久疯狂的命令了。

933
00:43:09,830 --> 00:43:14,900
所以，现在如果我不点斜线HELLO-1，
我看到“Hello，大卫。”

934
00:43:14,900 --> 00:43:16,450
>> 漂亮给人留下深刻印象，不过，对吧？

935
00:43:16,450 --> 00:43:18,158
我们可以做
这个有很多更简单

936
00:43:18,158 --> 00:43:20,940
而不谈变量
和CS50.h和所有的。

937
00:43:20,940 --> 00:43:23,080
因此，让我们使它成为一个
更有趣一点。

938
00:43:23,080 --> 00:43:31,010
>> 除了CS50.h，
有东西像字符串

939
00:43:31,010 --> 00:43:34,550
宣布，该CS50库
也有一些功能。

940
00:43:34,550 --> 00:43:38,520
所以就像几年前，有人写
printf和把它在标准I / O.h

941
00:43:38,520 --> 00:43:39,530
和一些其他文件。

942
00:43:39,530 --> 00:43:44,010
>> 我们的CS50的工作人员，写了一个函数
所谓的getchar，GetDouble，GetFloat，

943
00:43:44,010 --> 00:43:47,610
调用getInt，GetLongLong，GetString的，
我们把这些文件里面

944
00:43:47,610 --> 00:43:49,890
所谓CS50.h和CS50.c.

945
00:43:49,890 --> 00:43:51,880
我们把他们的内部
的CS50设备。

946
00:43:51,880 --> 00:43:53,880
而人们也可以
如果他们在网上进行下载

947
00:43:53,880 --> 00:43:55,880
希望把他们在他们的
自己的电脑也是如此。

948
00:43:55,880 --> 00:44:00,880
这就是说，我们已经创建
即获得来自用户的输入的功能。

949
00:44:00,880 --> 00:44:02,930
我不知道，什么都
这些数据类型包括。

950
00:44:02,930 --> 00:44:06,490
调用getInt是一种简单的，像
从用户得到某种方式的整数。

951
00:44:06,490 --> 00:44:09,980
和GetString可能喜欢弄
一个字或从用户的句子。

952
00:44:09,980 --> 00:44:11,770
>> 因此，让我们着眼于这一点。

953
00:44:11,770 --> 00:44:14,710
我要去回
家电，我要继续前进

954
00:44:14,710 --> 00:44:20,790
并保存此文件，姑且称之为
它HELLO-2.C我的第二个版本。

955
00:44:20,790 --> 00:44:23,030
让我们做一些改动。

956
00:44:23,030 --> 00:44:25,800
>> 这一次，而不是
硬编码大卫，这

957
00:44:25,800 --> 00:44:29,120
做一个令人难以置信的一致
但给人留下深刻印象的程序，

958
00:44:29,120 --> 00:44:32,640
如果我不是这样做的GetString？

959
00:44:32,640 --> 00:44:35,660
现在可以看到的GetString
有一个开放的括号，

960
00:44:35,660 --> 00:44:38,500
封闭的括号，因为
它不需要任何输入。

961
00:44:38,500 --> 00:44:40,850
这只是去给
一个字符串从用户。

962
00:44:40,850 --> 00:44:42,460
>> 现在其他的语法词。

963
00:44:42,460 --> 00:44:45,439
分号刚刚结束的代码行。

964
00:44:45,439 --> 00:44:46,730
你并不需要它们无处不在。

965
00:44:46,730 --> 00:44:48,896
但是，这只是意味着我
与这行代码完成。

966
00:44:48,896 --> 00:44:51,080
让我移动到另一个
语句或函数。

967
00:44:51,080 --> 00:44:53,010
字符串声明了一个变量。

968
00:44:53,010 --> 00:44:55,920
串好像是说
给我一碗，请。

969
00:44:55,920 --> 00:44:57,940
并让我把一个字符串在里面。

970
00:44:57,940 --> 00:44:59,430
>> 而现在上了等号。

971
00:44:59,430 --> 00:45:03,510
什么是等号
基本上等同于？

972
00:45:03,510 --> 00:45:04,500
>> 听众：分配。

973
00:45:04,500 --> 00:45:06,190
>> 戴维·J·马兰：是的，分配的值。

974
00:45:06,190 --> 00:45:09,872
所以，如果我，例如，呼叫
这个功能的GetString，

975
00:45:09,872 --> 00:45:12,830
我们会在一个时刻，我们来看看
会提示输入字符串的用户。

976
00:45:12,830 --> 00:45:17,810
这就好比让那么我写
D-A-V-I-D在一张纸上。

977
00:45:17,810 --> 00:45:21,060
当我说的字符串
s等于GetString的，

978
00:45:21,060 --> 00:45:24,140
平等并不真正意味着
相当于C语言编程。

979
00:45:24,140 --> 00:45:27,880
这意味着从右侧分配
右手侧到左手侧。

980
00:45:27,880 --> 00:45:29,510
>> 所以，我已经得到了一个字符串。

981
00:45:29,510 --> 00:45:32,785
和等号手段把它
在存储容器称为第

982
00:45:32,785 --> 00:45:36,730
再通过这关要
printf的实际做它的事。

983
00:45:36,730 --> 00:45:39,790
>> 所以，最终的结果则是怎么回事
看起来有点不同。

984
00:45:39,790 --> 00:45:40,840
让我们不要让HELLO-2。

985
00:45:40,840 --> 00:45:43,940

986
00:45:43,940 --> 00:45:45,260
或者可以工作。

987
00:45:45,260 --> 00:45:46,450
你下沿。

988
00:45:46,450 --> 00:45:47,940
让HELLO-2的工作。

989
00:45:47,940 --> 00:45:52,640
点斜线HELLO-2，回车。

990
00:45:52,640 --> 00:45:54,620
>> 我似乎有无限
环什么的。

991
00:45:54,620 --> 00:45:55,453
什么也没有发生。

992
00:45:55,453 --> 00:45:56,134
为什么呢？

993
00:45:56,134 --> 00:45:57,805
>> 听众：它使得一个无限循环。

994
00:45:57,805 --> 00:45:59,430
戴维·J·马兰：这是一个死循环。

995
00:45:59,430 --> 00:46:02,710
种它等着我
实际上它提供了一些信息。

996
00:46:02,710 --> 00:46:05,800
因此，让我继续前进，并键入
在大卫，然后按Enter键。

997
00:46:05,800 --> 00:46:07,230
而现在它说：“你好，大卫。”

998
00:46:07,230 --> 00:46:09,040
如果我再次运行它。

999
00:46:09,040 --> 00:46:11,530
让我们输入罗布，“你好，罗布。”

1000
00:46:11,530 --> 00:46:13,900
>> 现在，这是最糟糕的
用户界面不断。

1001
00:46:13,900 --> 00:46:16,110
用户显然
应该知道该怎么做。

1002
00:46:16,110 --> 00:46:17,120
但不管。

1003
00:46:17,120 --> 00:46:19,570
使用这些相同的建筑
就像在擦除块

1004
00:46:19,570 --> 00:46:24,980
我们可以解决这个问题，说
像你的名字吗，结肠癌，

1005
00:46:24,980 --> 00:46:27,820
空间，封闭报价，接近
括号，分号。

1006
00:46:27,820 --> 00:46:30,680
如此反复了很多
愚蠢的语法。

1007
00:46:30,680 --> 00:46:34,040
>> 但是请注意，我只是增加了一个
拼图上面这一个

1008
00:46:34,040 --> 00:46:35,280
以上这一个。

1009
00:46:35,280 --> 00:46:38,870
所以，现在如果我重新运行此，HELLO-2，回车。

1010
00:46:38,870 --> 00:46:41,180
等待一分钟。

1011
00:46:41,180 --> 00:46:41,830
怎么了？

1012
00:46:41,830 --> 00:46:43,570
它不表现任何不同。

1013
00:46:43,570 --> 00:46:44,200
是啊。

1014
00:46:44,200 --> 00:46:46,010
>> 听众：你没有运行make了。

1015
00:46:46,010 --> 00:46:47,968
>> 戴维·J·马兰：我没有
再次运行做出了吧。

1016
00:46:47,968 --> 00:46:49,430
所以我改变了我的源代码。

1017
00:46:49,430 --> 00:46:50,638
但同样，有这么流。

1018
00:46:50,638 --> 00:46:54,530
通过编译源代码提供
你新的目标代码，或0和1。

1019
00:46:54,530 --> 00:47:00,209
所以，我需要实际
重新运行化妆HELLO-2输入。

1020
00:47:00,209 --> 00:47:01,750
好了，事情似乎已经发生了。

1021
00:47:01,750 --> 00:47:04,220
点斜线HELLO-2。

1022
00:47:04,220 --> 00:47:05,390
你的名字吗。

1023
00:47:05,390 --> 00:47:09,990
现在要清楚，这是为什么
将光标放在同一行？

1024
00:47:09,990 --> 00:47:10,490
没错。

1025
00:47:10,490 --> 00:47:13,020
我没有把反斜线
Ñ​​在这里在我的代码。

1026
00:47:13,020 --> 00:47:16,110
所以，现在我可以写
像Daven，回车。

1027
00:47:16,110 --> 00:47:18,710
我可以再次运行它，然后键入
像加布，回车，

1028
00:47:18,710 --> 00:47:22,250
我们得到不同的程序
一遍又一遍又一遍。

1029
00:47:22,250 --> 00:47:28,940
>> 现在，最终我们将需要
使用几个不同的功能。

1030
00:47:28,940 --> 00:47:32,860
我们需要引入一些最终
条件，有条件做的事情。

1031
00:47:32,860 --> 00:47:35,550
也许循环，所以我们可以做
事情一遍又一遍。

1032
00:47:35,550 --> 00:47:38,220
>> 也许这将是很好，如果我们
可以实现自己的功能，

1033
00:47:38,220 --> 00:47:41,355
就像我们可以实现我们自己的
printf的还是我们自己的版本的GetString的

1034
00:47:41,355 --> 00:47:45,870
和GetFlow，因为最终连
使用此命令行环境

1035
00:47:45,870 --> 00:47:49,780
我们可以做的，即使是最
视觉上有趣的东西。

1036
00:47:49,780 --> 00:47:51,950
>> 事实上，总之让我做到这一点。

1037
00:47:51,950 --> 00:47:54,020
我要继续前进
并关闭这些窗口

1038
00:47:54,020 --> 00:47:57,400
在这里开这个图标，
这仅仅是一个更大的

1039
00:47:57,400 --> 00:48:00,020
版本的嵌入式
终端窗口。

1040
00:48:00,020 --> 00:48:02,329
所以Gedit的不仅
这个地方我的代码，

1041
00:48:02,329 --> 00:48:05,620
而且一个内置的终端窗口中，
黑色和白色的窗口，在这里我可以运行

1042
00:48:05,620 --> 00:48:06,230
命令。

1043
00:48:06,230 --> 00:48:08,600
>> 我刚好开
一个更大的版本了。

1044
00:48:08,600 --> 00:48:11,170
现在，我要进入
我已经在文件夹

1045
00:48:11,170 --> 00:48:13,150
把事先在球场上的网站。

1046
00:48:13,150 --> 00:48:16,720
而且我要继续前进，
打开一个名为thadgavin.c文件，

1047
00:48:16,720 --> 00:48:18,710
这是别人写的。

1048
00:48:18,710 --> 00:48:21,220
>> 如果我们看一下这个，
这不是种代码

1049
00:48:21,220 --> 00:48:24,370
我们会因为被写
这段代码的目的

1050
00:48:24,370 --> 00:48:28,450
是写的最漂亮的
看代码，他或她可以，

1051
00:48:28,450 --> 00:48:31,290
不论是否
另一个人可能永远

1052
00:48:31,290 --> 00:48:33,660
理解这段代码。

1053
00:48:33,660 --> 00:48:37,050
>> 事实上，每一年有什么
所谓的模糊ç比赛，这

1054
00:48:37,050 --> 00:48:39,570
是谁写的真正的怪才
没有其他人可以读取的代码，

1055
00:48:39,570 --> 00:48:42,050
但是，做任何事
很简单，或真是太神奇了。

1056
00:48:42,050 --> 00:48:43,890
而且我们认为我们会
总结这个样子

1057
00:48:43,890 --> 00:48:48,300
在东西是相当惊人的
你可能已经看到过一次。

1058
00:48:48,300 --> 00:48:52,650
但我们将结束在这个
注意，点斜线，thadgavin。

1059
00:48:52,650 --> 00:48:53,860
然后，这就是等待。

1060
00:48:53,860 --> 00:48:57,140

1061
00:48:57,140 --> 00:48:58,500
>> 这就是它的CS50。

1062
00:48:58,500 --> 00:48:59,935
我们会看到你在星期三。

1063
00:48:59,935 --> 00:49:04,284

1064
00:49:04,284 --> 00:49:10,016
>> [音乐播放]

1065
00:49:10,016 --> 00:53:31,883