1
00:00:00,000 --> 00:00:01,500
>> [音乐播放]

2
00:00:01,500 --> 00:00:11,000

3
00:00:11,000 --> 00:00:16,110
>> 马兰大卫：好吧，这是CS50
这是一周的结束。

4
00:00:16,110 --> 00:00:20,760
所以，我想介绍一下我的前
建议者，安洛达夫，谁不仅使

5
00:00:20,760 --> 00:00:25,460
iPhone 5的手段，以及这
讲台上，他也使汽车。

6
00:00:25,460 --> 00:00:27,927

7
00:00:27,927 --> 00:00:29,510
ANSEL DUFF：怎么样了，人呢？

8
00:00:29,510 --> 00:00:31,980
我只是想告诉你一个小
关于SAE方程式，这一点我

9
00:00:31,980 --> 00:00:32,604
我的船长。

10
00:00:32,604 --> 00:00:33,437
这是麻省理工学院的团队。

11
00:00:33,437 --> 00:00:35,520
我只是想告诉你
人约一点点

12
00:00:35,520 --> 00:00:37,520
并希望产生一些兴趣。

13
00:00:37,520 --> 00:00:41,590
>> 所以，我只想通过运行
我们的团队对夫妇的事情。

14
00:00:41,590 --> 00:00:43,640
所以我们完全
学生而言，其中的所有

15
00:00:43,640 --> 00:00:47,300
成员设计，模拟，
测试和制造商的一个子系统

16
00:00:47,300 --> 00:00:48,090
的汽车。

17
00:00:48,090 --> 00:00:51,240
我们有自己的加工车间
和车库，以及N52--或不好意思，

18
00:00:51,240 --> 00:00:54,140
N51--这是同一栋大楼
作为麻省理工学院的科学博物馆。

19
00:00:54,140 --> 00:00:55,990
我们是人民
那开车的人。

20
00:00:55,990 --> 00:00:58,340
有一个国家的竞争
在夏季的开始，

21
00:00:58,340 --> 00:01:01,215
然后有小枪战
比赛贯穿全年。

22
00:01:01,215 --> 00:01:04,400
然后我们做驾驶培训
天获得新成员熟悉。

23
00:01:04,400 --> 00:01:08,280
>> 我们构建的日子上
周六上午11时至下午8时。

24
00:01:08,280 --> 00:01:11,060
午餐和晚餐都照顾
的，从贝图西的与豆城

25
00:01:11,060 --> 00:01:12,130
分别。

26
00:01:12,130 --> 00:01:15,260
我们有一个星期的会议和
研讨会上，这是课程学分。

27
00:01:15,260 --> 00:01:18,560
这是新的，因为这学期，和
这也将是下个学期，

28
00:01:18,560 --> 00:01:19,940
这样你就可以跨章为。

29
00:01:19,940 --> 00:01:22,960
然后我们有设计，店铺，
而在本周的CAD天，

30
00:01:22,960 --> 00:01:26,870
而成员们将各自
CAD零件，订单库存等等。

31
00:01:26,870 --> 00:01:29,200
>> 所以对于电
在工程队

32
00:01:29,200 --> 00:01:31,110
我们有我们的牵引力，
高电压系统，

33
00:01:31,110 --> 00:01:33,390
它运行在标称
300伏，它包括

34
00:01:33,390 --> 00:01:35,360
马达，马达控制器，
和电池组。

35
00:01:35,360 --> 00:01:37,235
然后我们有一个低
电压系统，它运行

36
00:01:37,235 --> 00:01:40,180
在12伏电压，它包括
控制，CAN节点，脑

37
00:01:40,180 --> 00:01:41,570
框，仪表板。

38
00:01:41,570 --> 00:01:43,890
至于CS变，我们做
有网站维护

39
00:01:43,890 --> 00:01:47,940
我们需要做的事件，成员
的变化，新的图片和宣传材料。

40
00:01:47,940 --> 00:01:51,540
然后我们有一个控制码
汽车为我们的牵引力控制系统，发射

41
00:01:51,540 --> 00:01:55,750
控制，仪表板控制，转矩矢量，
和再生制动系统，其

42
00:01:55,750 --> 00:01:59,170
在MATLAB中运行一般，
Simulink和LabVIEW中。

43
00:01:59,170 --> 00:02:00,910
>> 告诉你关于这款车一点点。

44
00:02:00,910 --> 00:02:02,470
因此，它是约500磅。

45
00:02:02,470 --> 00:02:04,285
这是仅限于85千瓦规则。

46
00:02:04,285 --> 00:02:08,310
它有2 EMRAX 207汽车在
后面，每一个后轮。

47
00:02:08,310 --> 00:02:11,880
它具有定制电池组
从棱A123囊细胞，

48
00:02:11,880 --> 00:02:14,780
共计300伏，
5.6千瓦小时。

49
00:02:14,780 --> 00:02:17,950
而且它是直接驱动器
2.64比1的传动比。

50
00:02:17,950 --> 00:02:20,970
这里有一些图片，我们
注意到它的竞争力。

51
00:02:20,970 --> 00:02:25,820
这里的背，鼻锥，
这里是电机，

52
00:02:25,820 --> 00:02:29,682
那些大黑盘
下方等男装Manus的。

53
00:02:29,682 --> 00:02:32,140
这里有一个幻灯片，我拉
我们的比赛计划。

54
00:02:32,140 --> 00:02:35,389
这是我们的车刚比作
几个商购的汽车，

55
00:02:35,389 --> 00:02:38,380
像KTM XBOW，林依晨
原子，Caterha M 7-280。

56
00:02:38,380 --> 00:02:42,110
如果你熟悉价格，功耗
拉的重量，美元，每匹马力，

57
00:02:42,110 --> 00:02:44,930
元元的扭矩，而我们的车
打击他们都露出水面。

58
00:02:44,930 --> 00:02:47,520
如果您有任何问题，
记下这个电子邮件地址。

59
00:02:47,520 --> 00:02:50,800
拍我们fsae@mit.edu的电子邮件。

60
00:02:50,800 --> 00:02:53,350
>> 我们很高兴谈论
任何你愿意的话。

61
00:02:53,350 --> 00:02:55,600
哈佛的学生有样
对团队的少数。

62
00:02:55,600 --> 00:02:58,350
如果您有任何问题，
那请不要拍我们的电子邮件，

63
00:02:58,350 --> 00:03:00,810
快乐的交谈，我要
头回了大卫。

64
00:03:00,810 --> 00:03:01,550
谢谢。

65
00:03:01,550 --> 00:03:02,466
我很感激​​，伙计们。

66
00:03:02,466 --> 00:03:03,615
[掌声]

67
00:03:03,615 --> 00:03:07,080

68
00:03:07,080 --> 00:03:10,980
>> 大卫马兰：安塞尔整个夏天
我们在这里CS50工作在校园

69
00:03:10,980 --> 00:03:11,480
今年夏天。

70
00:03:11,480 --> 00:03:13,505
和除了工作
之类的二进制灯泡，

71
00:03:13,505 --> 00:03:16,090
他居然真的打开了我们
eyes--和矿particular--

72
00:03:16,090 --> 00:03:20,535
以真正的交叉点
没有硬件和软件都可以。

73
00:03:20,535 --> 00:03:23,410
其实有很多的事情，他只是
参观您完成最终是

74
00:03:23,410 --> 00:03:26,030
首先在软件中创建，
然后最终制造

75
00:03:26,030 --> 00:03:27,299
在硬件的真实世界。

76
00:03:27,299 --> 00:03:29,590
所以，如果你有兴趣
探索那个路口，

77
00:03:29,590 --> 00:03:31,430
或许占用该组。

78
00:03:31,430 --> 00:03:34,140
>> 现在，同时，那些你
谁是技术爱好者，

79
00:03:34,140 --> 00:03:36,140
和苹果产品
尤其知道有

80
00:03:36,140 --> 00:03:37,860
一对夫妇的
昨日公布的。

81
00:03:37,860 --> 00:03:39,776
但是，我们认为我们会展示
你一说出来

82
00:03:39,776 --> 00:03:43,590
前几天的
你可能没见过。

83
00:03:43,590 --> 00:03:46,150
>> 约根EGHAMMER：你知道吗，
曾经在一段时间的东西

84
00:03:46,150 --> 00:03:49,540
走来了
改变了我们的生活方式。

85
00:03:49,540 --> 00:03:53,479
一个设备那么简单，直观
使用感觉差不多熟悉了。

86
00:03:53,479 --> 00:03:59,710

87
00:03:59,710 --> 00:04:04,138
在介绍2015年宜家目录。

88
00:04:04,138 --> 00:04:10,420
这不是一个数字图书或
一本电子书，这是一本电子书。

89
00:04:10,420 --> 00:04:14,440
>> 要注意的第一件事情是没有
电缆，甚至没有电源线。

90
00:04:14,440 --> 00:04:18,519
2015年宜家目录
来完全充电，

91
00:04:18,519 --> 00:04:20,550
而电池的寿命是永恒的。

92
00:04:20,550 --> 00:04:27,300
该接口是7.5×8英寸，
但可以8英寸扩大到15。

93
00:04:27,300 --> 00:04:32,410
导航是基于触觉触摸
技术，你可以真正感受到。

94
00:04:32,410 --> 00:04:37,120
>> 内容预装
通过328高清页面

95
00:04:37,120 --> 00:04:40,180
鼓舞人心的家居理念。

96
00:04:40,180 --> 00:04:43,740
开始浏览，
只需触摸和拖动。

97
00:04:43,740 --> 00:04:50,870
从右向左前进，
从左向右向后移动。

98
00:04:50,870 --> 00:04:52,770
>> 请注意别的东西吗？

99
00:04:52,770 --> 00:04:53,780
这是正确的。

100
00:04:53,780 --> 00:04:55,190
没有滞后。

101
00:04:55,190 --> 00:04:58,400
每个晶莹剔透页
负载瞬间，

102
00:04:58,400 --> 00:05:00,586
无论你如何快速滚动。

103
00:05:00,586 --> 00:05:03,710
如果你想获得快速浏览，
只是握在手心，

104
00:05:03,710 --> 00:05:06,816
而只用你的拇指，
速浏览的内容。

105
00:05:06,816 --> 00:05:10,930
>> 如果你发现一些你想要保存
在以后，你可以简单地将它设为书签。

106
00:05:10,930 --> 00:05:17,620
即使你关闭应用程序，
您可以轻松地再次找到书签。

107
00:05:17,620 --> 00:05:18,490
太神奇了。

108
00:05:18,490 --> 00:05:20,434
>> [笑]

109
00:05:20,434 --> 00:05:21,406
[掌声]

110
00:05:21,406 --> 00:05:26,760

111
00:05:26,760 --> 00:05:29,870
所以这给我们带来了
一周的结束。

112
00:05:29,870 --> 00:05:31,760
几项通知了。

113
00:05:31,760 --> 00:05:33,440
所以切片是现在进行时。

114
00:05:33,440 --> 00:05:36,860
去这个网址的某个时候在这里
从现在到周五中午

115
00:05:36,860 --> 00:05:39,960
实际指定是否
在那些不那么舒服，更

116
00:05:39,960 --> 00:05:41,690
舒适，或介于两者之间。

117
00:05:41,690 --> 00:05:44,511
>> 这通常是其中的一个
东西种，你才知道。

118
00:05:44,511 --> 00:05:47,510
而事实上，那些你们谁少
舒适可能知道的不多，

119
00:05:47,510 --> 00:05:49,634
那些你们谁更
舒适的了解一样多，

120
00:05:49,634 --> 00:05:54,960
并再次，如果你不是很确定这
这些桶你落入你

121
00:05:54,960 --> 00:05:56,210
可能介于两者之间。

122
00:05:56,210 --> 00:05:59,810
但请放心，你可以交换
之后的几个星期，如果需要的话。

123
00:05:59,810 --> 00:06:02,620
>> 同时，针对未来一周
我们不开始本身的部分，

124
00:06:02,620 --> 00:06:04,760
但超级部分，这
是开放给所有的学生。

125
00:06:04,760 --> 00:06:08,220
在本星期日在一个位置
可以在课程网站上公布

126
00:06:08,220 --> 00:06:10,190
我们将有一个用于
那些不太舒服，

127
00:06:10,190 --> 00:06:12,470
以及一个用于
那些更舒适。

128
00:06:12,470 --> 00:06:15,460
而那些介于两者之间
可以选择这两个的，

129
00:06:15,460 --> 00:06:17,360
或两者，如果你愿意，坐式的。

130
00:06:17,360 --> 00:06:19,630
而这些重点
将最终的C，

131
00:06:19,630 --> 00:06:22,440
我们将继续我们的
今天的谈话。

132
00:06:22,440 --> 00:06:25,070
>> 习题集0同时是
希望在你的手中。

133
00:06:25,070 --> 00:06:27,500
正式由于明天
周四中午。

134
00:06:27,500 --> 00:06:29,490
除非你在现金1
你迟到5天，

135
00:06:29,490 --> 00:06:31,780
这将使其
直到周五中午。

136
00:06:31,780 --> 00:06:34,420
习题集1同时将
张贴在课程网站。

137
00:06:34,420 --> 00:06:37,381
这将是我们第一次
作为进军一类为C。

138
00:06:37,381 --> 00:06:40,630
而且问题设置规范将引导您
通过大量的哪些力学

139
00:06:40,630 --> 00:06:43,960
我们开始在周一谈到，
我们将继续在谈论今天。

140
00:06:43,960 --> 00:06:46,770
C，Linux上，CS50
设备，所有这些

141
00:06:46,770 --> 00:06:48,990
将等待你的规范。

142
00:06:48,990 --> 00:06:52,840
>> 办公时间同时都在进步，
在大学生食堂。

143
00:06:52,840 --> 00:06:56,240
前往这个网址在这里看到的
安排今晚和明天

144
00:06:56,240 --> 00:06:57,930
如果您想以分享。

145
00:06:57,930 --> 00:07:01,920
问题同时，让你
有机会提问

146
00:07:01,920 --> 00:07:05,860
异步，7天24小时，实现你
不限于节和办公室

147
00:07:05,860 --> 00:07:09,530
小时，而此工具
在这里，CS50讨论那个网址

148
00:07:09,530 --> 00:07:12,150
将过程的在线
公告板软件，通过它

149
00:07:12,150 --> 00:07:15,030
你可以问的问题
同学们也工作人员。

150
00:07:15,030 --> 00:07:18,492
所以请记住，资源也是如此。

151
00:07:18,492 --> 00:07:20,200
同时传统
启动这个星期五。

152
00:07:20,200 --> 00:07:23,200
正如你可能已经从瞥见
上周三的预告片视频，

153
00:07:23,200 --> 00:07:25,510
我们有一个传统，最
期间逢星期五

154
00:07:25,510 --> 00:07:28,750
服用一些50名学生和
工作人员到当地餐厅叫

155
00:07:28,750 --> 00:07:31,510
火与冰，在此我们
通常加入了一些校友

156
00:07:31,510 --> 00:07:33,850
还是从行业的朋友
普遍向往

157
00:07:33,850 --> 00:07:35,780
使一大类觉得小。

158
00:07:35,780 --> 00:07:37,560
所以这是一个完全偶然的午餐。

159
00:07:37,560 --> 00:07:40,160
一堆我们的工作人员
特别是，将发挥音乐椅

160
00:07:40,160 --> 00:07:43,360
并与学生讨论聊天
50，50以外的生活，

161
00:07:43,360 --> 00:07:46,510
生活在未来，现实世界中，
我说的是就业机会

162
00:07:46,510 --> 00:07:47,680
与朋友在工业。

163
00:07:47,680 --> 00:07:51,110
>> 所以，如果你想加入我们的行列
这个星期五，前往该网址在这里。

164
00:07:51,110 --> 00:07:54,180
空间是有限的，但我们会做到这一点
recurringly整个学期。

165
00:07:54,180 --> 00:07:57,380
前往那里cs50.harvard.edu/rsvp。

166
00:07:57,380 --> 00:07:59,380
如果你没有得到的
这个时候，不用担心。

167
00:07:59,380 --> 00:08:02,390
我们将再次这样做
未来几周内为好。

168
00:08:02,390 --> 00:08:05,434
>> 因此，这是图像
我们上周画，

169
00:08:05,434 --> 00:08:07,350
你可能已经被
涉足迄今。

170
00:08:07,350 --> 00:08:10,360
但是，让我们尝试到现在连本
什么我们今天做的

171
00:08:10,360 --> 00:08:11,440
从不间断。

172
00:08:11,440 --> 00:08:14,760
我有一个志愿者？

173
00:08:14,760 --> 00:08:16,000
好吧，或者几个。

174
00:08:16,000 --> 00:08:18,460
如何这里的
最后，在蓝色衬衫。

175
00:08:18,460 --> 00:08:20,329
拜托了，你叫什么名字？

176
00:08:20,329 --> 00:08:20,870
ALANA：阿拉纳。

177
00:08:20,870 --> 00:08:21,661
大卫马兰：阿拉纳。

178
00:08:21,661 --> 00:08:25,100
所以阿拉纳，对于只是一个
moment--很高兴认识你 - 

179
00:08:25,100 --> 00:08:28,260
将要扮演的角色
这个功能在这里。

180
00:08:28,260 --> 00:08:31,290
我们已经紫块
被称为迄今为止功能。

181
00:08:31,290 --> 00:08:34,830
所以我要去
未来这里提供阿拉纳

182
00:08:34,830 --> 00:08:38,380
是一个小名牌，使
清楚你玩什么样的作用。

183
00:08:38,380 --> 00:08:39,753
>> 所以，你应该发言权块。

184
00:08:39,753 --> 00:08:41,419
如果你想继续前进，把那上。

185
00:08:41,419 --> 00:08:43,169
而我们要
保持这个超级简单。

186
00:08:43,169 --> 00:08:46,180
如果目标在眼前简直是
现在实行与阿拉纳，

187
00:08:46,180 --> 00:08:49,710
这个所谓的说嵌段，
这里是它如何去上班。

188
00:08:49,710 --> 00:08:52,574
íhave--姑且称之为
参数或参数，

189
00:08:52,574 --> 00:08:54,240
它是真正的纸只是一张白纸。

190
00:08:54,240 --> 00:08:57,239
而且它的白色种是让人联想到
白框到您

191
00:08:57,239 --> 00:08:58,080
可以写文字。

192
00:08:58,080 --> 00:09:00,660
>> 同时我会去这里。

193
00:09:00,660 --> 00:09:06,560
我要继续前进，
写H-E-L-L-O逗号世界。

194
00:09:06,560 --> 00:09:09,972
而现在我作为说程序员，不要
根本不知道怎么说的东西。

195
00:09:09,972 --> 00:09:12,180
我能想出的话，
但我不一定

196
00:09:12,180 --> 00:09:15,220
知道如何表达自己
口头或在屏幕上。

197
00:09:15,220 --> 00:09:17,280
所以，我什么都
要做的就是把这块

198
00:09:17,280 --> 00:09:21,157
的功能，其input--
或说法，因为我们会打电话给它，

199
00:09:21,157 --> 00:09:23,990
我写这片paper--的
我要去外包了。

200
00:09:23,990 --> 00:09:26,831
>> 的确是这样的角色
在编程语言的功能

201
00:09:26,831 --> 00:09:27,330
可以玩。

202
00:09:27,330 --> 00:09:29,246
类似的发言权
块可以外包

203
00:09:29,246 --> 00:09:32,074
的人谁真正知道
她或他在说什么。

204
00:09:32,074 --> 00:09:33,990
所以，如果你跳过
这里只是一瞬间，

205
00:09:33,990 --> 00:09:40,092
我将这个输入传递到
阿拉纳，并要求你说的这个输入。

206
00:09:40,092 --> 00:09:41,202
>> ALANA：你好，世界。

207
00:09:41,202 --> 00:09:42,160
大卫马兰：就是这样。

208
00:09:42,160 --> 00:09:43,326
所以，有一个功能。

209
00:09:43,326 --> 00:09:46,556
现在，我们可以把它多一点，
我们可以向前迈进了一步这里。

210
00:09:46,556 --> 00:09:48,180
因为这显然是给人留下深刻印象。

211
00:09:48,180 --> 00:09:51,670
现在让我们将它转​​换为
一些更复杂。

212
00:09:51,670 --> 00:09:53,630
>> 因此，这当然是我们的C版本。

213
00:09:53,630 --> 00:09:56,760
所以，现在如果你想利用这
一关，这个名字标签脱落，

214
00:09:56,760 --> 00:09:58,530
并让我们有你换上一个新的名字。

215
00:09:58,530 --> 00:10:00,850
但是从根本上你
扮演相同的角色，

216
00:10:00,850 --> 00:10:03,400
它只是恰巧
可现在叫的printf。

217
00:10:03,400 --> 00:10:06,930
>> 这个故事，当然，
要be--可能

218
00:10:06,930 --> 00:10:09,317
正如underwhelming--是
将是下面的内容。

219
00:10:09,317 --> 00:10:10,650
您现在所在的函数printf。

220
00:10:10,650 --> 00:10:13,300
我的来电，或
程序员，谁愿意

221
00:10:13,300 --> 00:10:15,745
站上的台肩
以往人们喜欢你，

222
00:10:15,745 --> 00:10:18,670
谁已经想出如何
实际上写的东西了。

223
00:10:18,670 --> 00:10:20,650
所以此时，
而不是说出来，让我们

224
00:10:20,650 --> 00:10:22,255
实际使用我们的屏幕在这里。

225
00:10:22,255 --> 00:10:24,130
所以，如果你想一步
在这里，我要

226
00:10:24,130 --> 00:10:27,196
再此为通
输入我的printf的朋友。

227
00:10:27,196 --> 00:10:29,320
如果你能继续前进，
打印在屏幕上，

228
00:10:29,320 --> 00:10:31,611
只需用你的画
手指在黑色的屏幕上。

229
00:10:31,611 --> 00:10:43,680

230
00:10:43,680 --> 00:10:44,180
优秀的。

231
00:10:44,180 --> 00:10:47,350
好吧，所以很多悬念的
怎么说是要发挥出来。

232
00:10:47,350 --> 00:10:51,390
>> 所以，现在让我们东西1
最后的缺口，如果我们可以，如下所示。

233
00:10:51,390 --> 00:10:53,980
因此，这是一个C程序
正如我们上次讲的。

234
00:10:53,980 --> 00:10:57,460
而这只是做你做了什么，它
打印出的画面，你好，世界。

235
00:10:57,460 --> 00:11:00,290
尽管有明显很多
喧宾夺主的东西在那里。

236
00:11:00,290 --> 00:11:03,630
但是，让我们拿东西了一个缺口，
推出这个版本，这回忆

237
00:11:03,630 --> 00:11:06,160
是第三个版本
我们结束了最后一次。

238
00:11:06,160 --> 00:11:09,120
>> 现在有明确
两种用途的printf。

239
00:11:09,120 --> 00:11:12,280
有2呼叫阿拉纳
在这种情况下为printf的，

240
00:11:12,280 --> 00:11:14,740
但也有一个电话
另一个功能。

241
00:11:14,740 --> 00:11:17,150
那是什么功能的清楚一点吗？

242
00:11:17,150 --> 00:11:17,650
GetString的。

243
00:11:17,650 --> 00:11:18,980
>> 我们可以得到一个更多的志愿者？

244
00:11:18,980 --> 00:11:20,980
好了，上来吧。

245
00:11:20,980 --> 00:11:21,805
你叫什么名字？

246
00:11:21,805 --> 00:11:22,990
>> 哈维尔：哈维尔。

247
00:11:22,990 --> 00:11:24,750
>> 大卫马兰：哈维尔，上来吧。

248
00:11:24,750 --> 00:11:27,270
所以哈维尔的作用是在
这张纸。

249
00:11:27,270 --> 00:11:28,860
其中我要笼统称S。

250
00:11:28,860 --> 00:11:32,250
现在，这是一个变量，它的
字符串类型，如暗示

251
00:11:32,250 --> 00:11:34,290
在中间有在第二行。

252
00:11:34,290 --> 00:11:36,540
我想请你去给我拿一个字符串。

253
00:11:36,540 --> 00:11:40,120
具体低着头乐团
节，让我一个人的名字，

254
00:11:40,120 --> 00:11:43,142
回来用一个变量
包含该值。

255
00:11:43,142 --> 00:11:44,225
它可以是你想要的人。

256
00:11:44,225 --> 00:11:47,590

257
00:11:47,590 --> 00:11:48,520
>> 开始了。

258
00:11:48,520 --> 00:11:53,620

259
00:11:53,620 --> 00:11:55,960
好吧，哈维尔是
写下名字。

260
00:11:55,960 --> 00:12:02,210

261
00:12:02,210 --> 00:12:03,280
好吧。

262
00:12:03,280 --> 00:12:05,740
大家可以猜到是如何
这是要发挥出来。

263
00:12:05,740 --> 00:12:07,489
我们也许操劳
点什么

264
00:12:07,489 --> 00:12:10,320
功能是干什么的，但
不过非常感谢你。

265
00:12:10,320 --> 00:12:13,890
>> 所以，哈维尔已经返回此字符串
在这里，这，不能完全看到，

266
00:12:13,890 --> 00:12:15,800
乔纳森是字符串
我们已经得到了。

267
00:12:15,800 --> 00:12:18,330
所以，现在就是我究竟要
提供给阿拉纳虽然

268
00:12:18,330 --> 00:12:20,150
是的东西有点不同。

269
00:12:20,150 --> 00:12:23,800
因为在这个版本的
节目中，首先有你的名字。

270
00:12:23,800 --> 00:12:26,160
所以第一个参数
我需要提供阿拉纳

271
00:12:26,160 --> 00:12:33,030
与将是
从字面上说出你的名字。

272
00:12:33,030 --> 00:12:35,280
好吧，让这么简单
我会交给这个给你。

273
00:12:35,280 --> 00:12:36,730
当我写上去的
下一个参数，如果你

274
00:12:36,730 --> 00:12:39,230
要继续写这
在黑板上，让我们继续

275
00:12:39,230 --> 00:12:42,659
而做最后的例子来说明，使
明确什么是最终得到的情况发生。

276
00:12:42,659 --> 00:12:44,450
所以说出你的名字，
写出它朝着顶端

277
00:12:44,450 --> 00:12:47,220
如果你不介意的话，只是让
我们有房间一第二线路。

278
00:12:47,220 --> 00:12:52,890
因为过去的事情我要去
现在为您提供的不是一个，

279
00:12:52,890 --> 00:12:57,220
但是两张纸。

280
00:12:57,220 --> 00:12:58,074
>> 好吧。

281
00:12:58,074 --> 00:13:01,920
H-E-L-L-O逗号，然后空一行。

282
00:13:01,920 --> 00:13:04,780
所以我很担心现在出手阿拉纳
是的东西有点不同。

283
00:13:04,780 --> 00:13:08,600
不仅是她得到这个，
其中填空表示

284
00:13:08,600 --> 00:13:12,050
这percent--究竟是什么
占位符，我们一直在使用？

285
00:13:12,050 --> 00:13:13,890
是啊，所以％的第

286
00:13:13,890 --> 00:13:16,530
同时，我要通过
她在第二个参数，其中

287
00:13:16,530 --> 00:13:19,290
正是哈维尔
从乔纳森检索。

288
00:13:19,290 --> 00:13:20,534
>> 所以让我给你这两个。

289
00:13:20,534 --> 00:13:22,575
如果你想，去吧
和打印的效果。

290
00:13:22,575 --> 00:13:25,660

291
00:13:25,660 --> 00:13:28,130
什么是最终发生
现在的问题是，阿拉纳再次

292
00:13:28,130 --> 00:13:29,410
正在播放的printf的作用。

293
00:13:29,410 --> 00:13:32,160
哈维尔被打
GetString的作用。

294
00:13:32,160 --> 00:13:34,700
所以这将是你的纪念品。

295
00:13:34,700 --> 00:13:39,910
并最终发生了什么，尽管
这hello--是的继续和逗号。

296
00:13:39,910 --> 00:13:41,410
ALANA：我收到这事还是没有呢？

297
00:13:41,410 --> 00:13:43,451
马兰大卫：是的，你
在一次接待了他们两个。

298
00:13:43,451 --> 00:13:45,740
这样的想法是，你
现在可以翻转页面

299
00:13:45,740 --> 00:13:50,000
处理所述第二
的这两个输入。

300
00:13:50,000 --> 00:13:53,280
因此，这是唯一的锤家
指出的是，尽管阿拉纳执行

301
00:13:53,280 --> 00:13:55,830
这个绿线位置，然后
哈维尔做这一块我们

302
00:13:55,830 --> 00:13:57,820
并返回我的东西
我们会打电话给S，但它是真的

303
00:13:57,820 --> 00:13:59,520
只是那件他自己的论文。

304
00:13:59,520 --> 00:14:02,320
现在阿拉纳已经这样做了第三行。

305
00:14:02,320 --> 00:14:06,010
>> 而且即使这一切看起来
如此令人难以置信的神秘也许

306
00:14:06,010 --> 00:14:08,870
乍一看，还真
就是这么简单。

307
00:14:08,870 --> 00:14:11,390
周围路过的投入，
得到的输出，无论是

308
00:14:11,390 --> 00:14:14,560
以物理交回的东西，
或看到这样的副作用。

309
00:14:14,560 --> 00:14:17,170
视觉上的东西
写在屏幕上。

310
00:14:17,170 --> 00:14:19,990
因此，让我们继续前进，
感谢阿拉纳和哈维尔，

311
00:14:19,990 --> 00:14:25,012
是谁到这里，为
加入我们在这里。

312
00:14:25,012 --> 00:14:25,934
>> [掌声]

313
00:14:25,934 --> 00:14:29,360

314
00:14:29,360 --> 00:14:33,480
>> 所以，现在让我们习以为常的是如何
简单的所有的可能是。

315
00:14:33,480 --> 00:14:36,775
让我们继续来实际
做一些实际的代码。

316
00:14:36,775 --> 00:14:40,620
所以，在这里，屏幕上是截图
的所谓CS50器具。

317
00:14:40,620 --> 00:14:43,980
如果你不得不在作为
下午2时00分在周三下午，

318
00:14:43,980 --> 00:14:46,602
解释一些朋友
什么CS50器具，

319
00:14:46,602 --> 00:14:48,185
你怎么会在一个句子里定义它？

320
00:14:48,185 --> 00:14:52,160

321
00:14:52,160 --> 00:14:53,240
任何一个句子？

322
00:14:53,240 --> 00:14:54,876
是吗？

323
00:14:54,876 --> 00:14:57,334
学生：这就像一个程序
这使得每个人的电脑

324
00:14:57,334 --> 00:14:58,460
用相同的系统上运行。

325
00:14:58,460 --> 00:14:59,210
大卫马兰：好！

326
00:14:59,210 --> 00:15:02,810
这是一个程序，使每个人的
计算机具有相同的系统上运行。

327
00:15:02,810 --> 00:15:04,920
这有点自己的
操作副本

328
00:15:04,920 --> 00:15:07,540
系统，恰好
被称为Ubuntu Linux操作系统。

329
00:15:07,540 --> 00:15:11,070
它有效的内部运行
在自己的Mac或PC的一个窗口，

330
00:15:11,070 --> 00:15:15,080
使这样右边出了大门
在1个星期，这里的每个人在课堂上

331
00:15:15,080 --> 00:15:17,590
可以访问相同的工具，
相同的结构，

332
00:15:17,590 --> 00:15:21,250
而且也没有学习曲线的具体
到Mac或特定的电脑。

333
00:15:21,250 --> 00:15:25,620
>> 现在我们打开了，在CS50内
家电在周一，这个程序在这里。

334
00:15:25,620 --> 00:15:27,040
它发生在被称为gedit的。

335
00:15:27,040 --> 00:15:29,050
但是，这真的只是
图形编辑器。

336
00:15:29,050 --> 00:15:33,170
这有点像记事本或文本
分别编辑在Windows或Mac OS。

337
00:15:33,170 --> 00:15:36,720
我建议有真
三个重要环节进行屏幕。

338
00:15:36,720 --> 00:15:39,560
顶面是你
会写你的代码。

339
00:15:39,560 --> 00:15:44,080
而这也正是我们花了很多的我们
三个例子在周一的演讲。

340
00:15:44,080 --> 00:15:47,650
在底部，我们叫什么，
这个黑色的窗口，是吗？

341
00:15:47,650 --> 00:15:48,640
>> 学生：编译器？

342
00:15:48,640 --> 00:15:51,500
>> 大卫马兰：编译我们
通过该窗口的方式进行访问。

343
00:15:51,500 --> 00:15:53,040
但更普遍。

344
00:15:53,040 --> 00:15:54,540
是的，这只是一个终端窗口。

345
00:15:54,540 --> 00:15:57,780
这是一个古老的术语，只是
本质上描述了一个闪烁

346
00:15:57,780 --> 00:16:01,910
提示，多年前曾经是上
其中的一个大的CRT型的。

347
00:16:01,910 --> 00:16:04,300
但现在它的排序
的虚拟软件。

348
00:16:04,300 --> 00:16:06,710
与终端窗口
让我们输入命令。

349
00:16:06,710 --> 00:16:11,750
它排序的简化版本
用户界面或UI的。

350
00:16:11,750 --> 00:16:14,060
这不是一个图形
用户界面或图形用户界面，

351
00:16:14,060 --> 00:16:17,250
它是一个基于文本的界面
或命令行界面。

352
00:16:17,250 --> 00:16:20,770
>> 而事实上这就是最终
我能写一些代码。

353
00:16:20,770 --> 00:16:24,200
有一次，我写了，虽然一些代码，
记得，我用这个命令。

354
00:16:24,200 --> 00:16:26,210
并且，因为它的名字
种暗示，这

355
00:16:26,210 --> 00:16:29,860
让我做一个
程序名为Hello。

356
00:16:29,860 --> 00:16:33,400
但什么是它真正在做什么？

357
00:16:33,400 --> 00:16:36,180
以及化妆是把我的
输入，我的源代码，

358
00:16:36,180 --> 00:16:39,380
并且将其转换到什么，最后？

359
00:16:39,380 --> 00:16:40,060
>> 目标代码。

360
00:16:40,060 --> 00:16:42,790
代码和目标代码只是一个花哨
说的零和一的方式。

361
00:16:42,790 --> 00:16:46,420
再一次，我希望
来运行的目标代码，

362
00:16:46,420 --> 00:16:50,940
有一次我想通过输入这些
零和一进我的电脑

363
00:16:50,940 --> 00:16:54,430
脑，所谓CPU的
或中央处理单元，

364
00:16:54,430 --> 00:16:55,730
我不得不运行程序。

365
00:16:55,730 --> 00:16:59,042
但它不是在星期一相当简单
像刚才双击的一些图标。

366
00:16:59,042 --> 00:17:01,375
而不是什么都我来
做的，以运行一个程序？

367
00:17:01,375 --> 00:17:04,130

368
00:17:04,130 --> 00:17:07,890
>> 什么是第二个命令？

369
00:17:07,890 --> 00:17:09,619
我听到一个小斜线？

370
00:17:09,619 --> 00:17:10,544
是的，是吗？

371
00:17:10,544 --> 00:17:12,474
>> 学生：点和斜线
该程序的名称。

372
00:17:12,474 --> 00:17:13,349
马兰大卫：没错。

373
00:17:13,349 --> 00:17:15,030
点斜线和程序的名称。

374
00:17:15,030 --> 00:17:16,210
现在没有什么意思？

375
00:17:16,210 --> 00:17:19,470
好点仅仅是一个神秘的方式
的话说当前目录。

376
00:17:19,470 --> 00:17:23,440
不管文件夹，你是在为
作为参考，表示为圆点。

377
00:17:23,440 --> 00:17:26,680
斜线正是你所看到的
在Mac OS和Windows多年，

378
00:17:26,680 --> 00:17:30,329
这是一个目录之间的分隔符
或文件夹的一些名称的其余部分。

379
00:17:30,329 --> 00:17:32,620
在Windows中碰巧去
向后，在Linux和Mac

380
00:17:32,620 --> 00:17:34,210
操作系统它发生向前去。

381
00:17:34,210 --> 00:17:37,560
但是，这仅仅是分隔符，所以它的
只是一个无趣的语法细节。

382
00:17:37,560 --> 00:17:40,440
>> 当然，多汁的部分是
节目的名称，您好。

383
00:17:40,440 --> 00:17:42,650
而这对于我们把创造的东西。

384
00:17:42,650 --> 00:17:44,910
它输出的文件，对我们来说。

385
00:17:44,910 --> 00:17:46,700
但是，我们怎么会到这一点？

386
00:17:46,700 --> 00:17:48,870
现在让我们来问问
的问题，什么是真正的

387
00:17:48,870 --> 00:17:52,470
会在这里，至少在
考虑到一些这方面的语法呢？

388
00:17:52,470 --> 00:17:57,000
>> 因此，在一个句子或左右，
我们是如何解释的距离

389
00:17:57,000 --> 00:17:59,020
这第一行的
以绿色突出显示？

390
00:17:59,020 --> 00:18:02,998
那是什么行头做，
相对于我的程序？

391
00:18:02,998 --> 00:18:03,974
是吗？

392
00:18:03,974 --> 00:18:05,067
>> 学生：[听不清]。

393
00:18:05,067 --> 00:18:06,150
大卫马兰：再说一遍吗？

394
00:18:06,150 --> 00:18:08,734
学生：包括和下载
过去的功能[听不清]。

395
00:18:08,734 --> 00:18:09,483
大卫马兰：好。

396
00:18:09,483 --> 00:18:11,900
其中，我就不说了
下载，但让我们说

397
00:18:11,900 --> 00:18:15,500
包括功能，人们
都写在了过去。

398
00:18:15,500 --> 00:18:18,260
而这些功能的实现
某处在我的电脑。

399
00:18:18,260 --> 00:18:20,470
有人写了一个文件
多年前，并且该文件

400
00:18:20,470 --> 00:18:23,490
是CS50内某处
家电，或在我的硬盘驱动器

401
00:18:23,490 --> 00:18:24,480
更普遍。

402
00:18:24,480 --> 00:18:27,810
因此该线基本上说
去找到那个文件，标准I / O点

403
00:18:27,810 --> 00:18:31,740
小时，复制和粘贴的内容
在这里我文件顶部

404
00:18:31,740 --> 00:18:33,860
这样我就不必
做手工自己。

405
00:18:33,860 --> 00:18:40,970
>> 而且里面最丰厚的部分中
我们称这个文件是什么功能？

406
00:18:40,970 --> 00:18:45,740
什么功能并说被宣布
或在标准I / O点ħ提到

407
00:18:45,740 --> 00:18:47,120
最有可能的？

408
00:18:47,120 --> 00:18:47,900
printf的，对不对？

409
00:18:47,900 --> 00:18:50,797
我们没有写上的printf
周一，它只是存在。

410
00:18:50,797 --> 00:18:52,880
就像阿拉纳刚
站在舞台上，她只是

411
00:18:52,880 --> 00:18:55,540
存在并且知道如何绘制
屏幕上的对象，

412
00:18:55,540 --> 00:18:58,660
所以不会printf的多年存在。

413
00:18:58,660 --> 00:19:00,240
所以这是我们如何访问它。

414
00:19:00,240 --> 00:19:03,280
现在，如果我们在这里提出，
主要是类似的，我们

415
00:19:03,280 --> 00:19:06,620
在拼图说
所谓当绿旗点击

416
00:19:06,620 --> 00:19:07,620
在刮的世界。

417
00:19:07,620 --> 00:19:10,130
它的只是排序
在人类的默认名称

418
00:19:10,130 --> 00:19:13,340
决定将代表
默认入口点的程序。

419
00:19:13,340 --> 00:19:16,540
的程序代码的组块
那被先执行。

420
00:19:16,540 --> 00:19:19,700
>> 同时这些花括号
种等的弯曲形状

421
00:19:19,700 --> 00:19:21,410
对很多这些黄色划痕件。

422
00:19:21,410 --> 00:19:24,860
他们种封装的整体
一串指令在一起。

423
00:19:24,860 --> 00:19:28,350
因此，它只是一种结合在一起
一些相关的功能。

424
00:19:28,350 --> 00:19:33,750
当然printf的是一个函数，
打印屏幕，因为我们只是做了。

425
00:19:33,750 --> 00:19:35,190
>> 那么这些括号？

426
00:19:35,190 --> 00:19:38,770
即使你，你会怎么define--
从未编程之前，但只是基于

427
00:19:38,770 --> 00:19:41,320
现在越来越
希望直觉，什么

428
00:19:41,320 --> 00:19:43,290
正在括号做我们在这里？

429
00:19:43,290 --> 00:19:45,450
或者什么是他们周围？

430
00:19:45,450 --> 00:19:46,360
是吗？

431
00:19:46,360 --> 00:19:49,360
>> 学生：他们在说什么
你要打印带的printf。

432
00:19:49,360 --> 00:19:52,401
>> 马兰大卫：是啊，他们是怎么说的
你要打印带的printf。

433
00:19:52,401 --> 00:19:56,260
或者更一般地，它们是
周围的输入的功能。

434
00:19:56,260 --> 00:19:58,530
所以你几乎可以认为
这些括号

435
00:19:58,530 --> 00:20:01,620
作为是像金属
夹在这剪贴板。

436
00:20:01,620 --> 00:20:05,940
这是什么样的控股，这是什么
将要被用于提供参数

437
00:20:05,940 --> 00:20:08,500
入功能，其中在
这种情况被称为printf的。

438
00:20:08,500 --> 00:20:12,390
>> 所以一般几乎任何
一次，我们调用一个函数，

439
00:20:12,390 --> 00:20:14,280
我们将看到一对括号。

440
00:20:14,280 --> 00:20:17,000
也许有东西在里面，
像现在，也许什么也没有。

441
00:20:17,000 --> 00:20:19,770
但是，这是在那里你可以把
输入或所谓的参数

442
00:20:19,770 --> 00:20:20,680
一个函数。

443
00:20:20,680 --> 00:20:22,470
>> 这里有一个这样的说法。

444
00:20:22,470 --> 00:20:24,467
我已经强调了一切
引号之间，

445
00:20:24,467 --> 00:20:26,300
因为事实证明，
在这种语言称为

446
00:20:26,300 --> 00:20:29,950
C，当你想表示一个
string--这是一个单词或短语

447
00:20:29,950 --> 00:20:33,470
甚至paragraph--你必须
用双引号括起来。

448
00:20:33,470 --> 00:20:35,420
不是单引号，双引号。

449
00:20:35,420 --> 00:20:37,460
而这正是我在这里所做的。

450
00:20:37,460 --> 00:20:39,900
>> 同时有一个时髦的
象征向着结束。

451
00:20:39,900 --> 00:20:41,600
反斜杠ñ。

452
00:20:41,600 --> 00:20:43,460
没有说什么代表？

453
00:20:43,460 --> 00:20:44,093
是吗？

454
00:20:44,093 --> 00:20:44,980
>> 学生：一个新行。

455
00:20:44,980 --> 00:20:45,896
>> 大卫马兰：新行。

456
00:20:45,896 --> 00:20:47,910
对了，你不
一般敲回车时

457
00:20:47,910 --> 00:20:50,430
你想要的程序
吐出一个新行。

458
00:20:50,430 --> 00:20:54,210
而你明确告诉它
这个公认的晦涩作品

459
00:20:54,210 --> 00:20:58,770
语法，反斜线N，即
你想要一个新的生产线去那里。

460
00:20:58,770 --> 00:20:59,810
最后的分号。

461
00:20:59,810 --> 00:21:01,560
我们真的不说话
太多关于这一点，

462
00:21:01,560 --> 00:21:04,893
而到目前为止，这将是一些祸根
你的存在对于第一个问题的

463
00:21:04,893 --> 00:21:07,990
设置，当你只是没有意识到
你忘了什么是愚蠢的

464
00:21:07,990 --> 00:21:08,614
作为一个分号。

465
00:21:08,614 --> 00:21:11,600
一般把它
会解决这个问题。

466
00:21:11,600 --> 00:21:13,511
但是，什么是它做的
对我们来说，你会说什么？

467
00:21:13,511 --> 00:21:15,670
>> 学生：[听不清]。

468
00:21:15,670 --> 00:21:17,484
>> 大卫马兰：对不起？

469
00:21:17,484 --> 00:21:18,532
>> 学生：[听不清]。

470
00:21:18,532 --> 00:21:19,990
大卫马兰：整理一份声明。

471
00:21:19,990 --> 00:21:22,770
这有点像在期限
英语句子的末尾，

472
00:21:22,770 --> 00:21:25,790
而在这门语言
C中，它的结尾的语句。

473
00:21:25,790 --> 00:21:29,250
编程的指令
你刚才想说的代码，

474
00:21:29,250 --> 00:21:30,500
我做这个。

475
00:21:30,500 --> 00:21:32,240
现在发现这是这里唯一的一个。

476
00:21:32,240 --> 00:21:34,614
所以，你不想得到
把分号的习惯

477
00:21:34,614 --> 00:21:36,190
以后每隔封闭括号。

478
00:21:36,190 --> 00:21:38,610
比如有没有
接下来作废，我们将

479
00:21:38,610 --> 00:21:40,430
回来以后
什么无效的手段。

480
00:21:40,430 --> 00:21:44,080
但在这种情况下，你的printf是
功能，或正在使用的声明，

481
00:21:44,080 --> 00:21:47,420
所以我们希望有
总站在它的尽头。

482
00:21:47,420 --> 00:21:50,980
>> 而且我特意挑选的。和
坦率地说了很多，如C，C + +语言，

483
00:21:50,980 --> 00:21:55,000
的Java，JavaScript和任何数量的
其他的语言有很多这样的

484
00:21:55,000 --> 00:21:56,730
之类的语法细节。

485
00:21:56,730 --> 00:22:00,120
这当然如果你是新来
节目能真正你绊倒。

486
00:22:00,120 --> 00:22:02,307
而且你会记住我
也就是说，有些人会

487
00:22:02,307 --> 00:22:04,140
有这方面的经验
在办公时间或延迟

488
00:22:04,140 --> 00:22:07,554
在晚上工作的一些对集，其中
你那该死的程序就是不编译，

489
00:22:07,554 --> 00:22:09,470
它不跑，你有
不知道什么是错的，

490
00:22:09,470 --> 00:22:11,513
它似乎完全
逻辑上正确的给你。

491
00:22:11,513 --> 00:22:13,596
而且那是因为你忘了
像打

492
00:22:13,596 --> 00:22:15,250
分号一些行的末尾。

493
00:22:15,250 --> 00:22:17,590
>> 但这些都是各种各样的事情你
要立即学会看。

494
00:22:17,590 --> 00:22:20,048
而事实上这些都是事
该CA的和TF的有

495
00:22:20,048 --> 00:22:23,210
那种被训练来看看
速度远远超过你。

496
00:22:23,210 --> 00:22:26,610
因此，这只是说，因为你
潜入问题集1特别是，

497
00:22:26,610 --> 00:22:28,217
不要沮丧了这个东西。

498
00:22:28,217 --> 00:22:30,050
一旦那种你适应
走向世界，你

499
00:22:30,050 --> 00:22:35,130
开始看到的东西，你可能不
看第一眼第一周。

500
00:22:35,130 --> 00:22:37,440
>> 因此，源代码是类似的东西。

501
00:22:37,440 --> 00:22:40,370
我们想通过成
所谓的编译器。

502
00:22:40,370 --> 00:22:42,850
和编译器
我们所说的输出提供

503
00:22:42,850 --> 00:22:45,660
称为目标代码，该
所谓的零和一。

504
00:22:45,660 --> 00:22:47,747
但是从那里，是什么给我们？

505
00:22:47,747 --> 00:22:49,080
那么它给了我们这些模式。

506
00:22:49,080 --> 00:22:52,020
并再次在您的计算机，
英特尔内部，

507
00:22:52,020 --> 00:22:54,350
理解这些模式
的零和一。

508
00:22:54,350 --> 00:22:57,300
有时格局
表示实际的十进制数

509
00:22:57,300 --> 00:22:59,770
正如我们上周所看到的，有时
它代表的一封信

510
00:22:59,770 --> 00:23:02,730
就像我们上周看到的，有时
它代表一个指令，

511
00:23:02,730 --> 00:23:05,460
像打印的东西到屏幕上。

512
00:23:05,460 --> 00:23:08,782
>> 所以printf进行instance--
而是让我退。

513
00:23:08,782 --> 00:23:11,240
我们已经采取理所当然
那些零和一的

514
00:23:11,240 --> 00:23:14,200
通过这个命令彩妆生产。

515
00:23:14,200 --> 00:23:16,050
但要是不是一个编译器。

516
00:23:16,050 --> 00:23:19,370
使是没有的事，中间
该公司生产的零和一。

517
00:23:19,370 --> 00:23:23,780
宁可仅仅是一个很方便的
命名的程序，其目的在生活中

518
00:23:23,780 --> 00:23:27,267
本质上是要弄清楚
如何编译你的程序。

519
00:23:27,267 --> 00:23:29,350
我们用它在这些
第一个星期，因为它只是

520
00:23:29,350 --> 00:23:30,910
为我们节省了很多麻烦。

521
00:23:30,910 --> 00:23:34,080
>> 但是什么使真
当你编译你好做，

522
00:23:34,080 --> 00:23:36,690
是，正如我们上次讲的，它是
期待您的硬盘驱动器上

523
00:23:36,690 --> 00:23:40,620
或当前文件夹中，
所谓的文件是什么，显然？

524
00:23:40,620 --> 00:23:41,815
HELLO.C，对不对？

525
00:23:41,815 --> 00:23:43,190
这只是一种一项公约。

526
00:23:43,190 --> 00:23:45,620
这是任意的，但
这就是事物的本质。

527
00:23:45,620 --> 00:23:48,620
做，如果你只是指定名称
一个并不存在的项目，

528
00:23:48,620 --> 00:23:52,200
它会查找源代码
在文件中，默认情况下是指的hello.c。

529
00:23:52,200 --> 00:23:53,530
如果找到了，太棒了。

530
00:23:53,530 --> 00:23:56,650
这将转换的源
代码转换成你的目标代码。

531
00:23:56,650 --> 00:23:59,670
>> 但每次我按Enter
运行make招呼后，

532
00:23:59,670 --> 00:24:03,560
你还记得看到最后一次
相当长的和神秘的序列

533
00:24:03,560 --> 00:24:06,430
其他白色字母和
字符在屏幕上？

534
00:24:06,430 --> 00:24:11,220
嗯，这是实际的指令，
实际的编译器，这是在运行。

535
00:24:11,220 --> 00:24:15,500
因此，实际的编译器，我们将使用最
本学期是一种叫做铛。

536
00:24:15,500 --> 00:24:19,280
你们有些人可能已经使用
Visual Studio中之前，还是海湾合作委员会，

537
00:24:19,280 --> 00:24:21,340
或任何其他的编译器。

538
00:24:21,340 --> 00:24:22,620
我们将用铿锵。

539
00:24:22,620 --> 00:24:26,950
>> 和铛使我们能够真正转换
该源代码，目标代码。

540
00:24:26,950 --> 00:24:29,430
这是什么其实
在实践中意味着？

541
00:24:29,430 --> 00:24:33,390
那么，让我进入一个
我的文件夹从最后一次。

542
00:24:33,390 --> 00:24:35,760
里面的CS50器具。

543
00:24:35,760 --> 00:24:42,080
让我继续前进，创造这个
相同的文件，包括标准的I / O点小时。

544
00:24:42,080 --> 00:24:42,875
INT主要作废。

545
00:24:42,875 --> 00:24:46,000
我们会回来的将来
什么诠释方式，什么无效的方法。

546
00:24:46,000 --> 00:24:49,130
但现在让我们做
你好世界反斜线N，

547
00:24:49,130 --> 00:24:50,500
就像我们做在黑板上。

548
00:24:50,500 --> 00:24:53,930
>> 让我保存这个文件名为hello.c的。

549
00:24:53,930 --> 00:24:58,280
而现在，如果我想要编译该
ícould--让我放大in--运行

550
00:24:58,280 --> 00:25:00,450
让你好进入。

551
00:25:00,450 --> 00:25:02,645
而这又是
这很神秘的线。

552
00:25:02,645 --> 00:25:05,120
但现在至少有一个字
可能跳出你。

553
00:25:05,120 --> 00:25:07,087
铛就是我们之前看到的那条线。

554
00:25:07,087 --> 00:25:10,420
现在有很多其他的东西坦白
我们会挥舞手上的今天。

555
00:25:10,420 --> 00:25:14,020
但是有几个子集，
在这几个字符

556
00:25:14,020 --> 00:25:14,907
这是感兴趣的。

557
00:25:14,907 --> 00:25:16,490
不过，我要继续前进，做到这一点。

558
00:25:16,490 --> 00:25:18,281
我将第一次运行
你好，只是为了证明

559
00:25:18,281 --> 00:25:20,320
这是工作，因为它是星期一。

560
00:25:20,320 --> 00:25:22,330
但现在我要删除的程序。

561
00:25:22,330 --> 00:25:25,870
而就像我们有这些
短名称最后一次，

562
00:25:25,870 --> 00:25:29,787
除去命令
什么是RM，删除，回车。

563
00:25:29,787 --> 00:25:31,870
你会得到一些
很古怪的问题。

564
00:25:31,870 --> 00:25:35,210
很难相信，你可以
即使这个问题不难理解。

565
00:25:35,210 --> 00:25:38,100
但是，删除普通文件只是打招呼
要删除打招呼方式去做。

566
00:25:38,100 --> 00:25:42,650
>> 我可以继续键入y，以
是的，输入的，现在它不见了。

567
00:25:42,650 --> 00:25:45,130
这是什么意思，现在，
如果清除我的屏幕上，

568
00:25:45,130 --> 00:25:47,301
是代替
这样做使hello--你

569
00:25:47,301 --> 00:25:48,800
知道吗，我越来越擅长这个。

570
00:25:48,800 --> 00:25:50,690
我要运行编译器自己。

571
00:25:50,690 --> 00:25:53,330
我并不需要一些程序
弄清楚我的文件就会被调用。

572
00:25:53,330 --> 00:25:55,370
我写的hello.c，我
知道它叫什么，

573
00:25:55,370 --> 00:25:57,640
我很清楚地能打字了的。

574
00:25:57,640 --> 00:26:02,620
所以我要继续前进
做铛的hello.c输入。

575
00:26:02,620 --> 00:26:03,264
>> 似乎工作。

576
00:26:03,264 --> 00:26:05,930
而且也没有额外的输出，
因为铛是编译器。

577
00:26:05,930 --> 00:26:08,590
这是什么样的转换
源代码的零和一。

578
00:26:08,590 --> 00:26:12,870
所以，如果我现在做点
斜线你好输入，HM。

579
00:26:12,870 --> 00:26:14,630
今天新的错误消息。

580
00:26:14,630 --> 00:26:17,610
所以bash是正义的名义
眨眼，我们正在使用的提示。

581
00:26:17,610 --> 00:26:20,360
这是一个过于简单化，
但现在这一切就是，

582
00:26:20,360 --> 00:26:21,401
它的闪烁提示。

583
00:26:21,401 --> 00:26:22,880
这就是为什么它朝着我们大喊大叫。

584
00:26:22,880 --> 00:26:25,690
>> 没有这样的文件或目录
多一点简单。

585
00:26:25,690 --> 00:26:28,190
但可以肯定我做的目标代码。

586
00:26:28,190 --> 00:26:30,930
但美中不足的是，这
如果我输入的命令

587
00:26:30,930 --> 00:26:34,650
列出了这样的内容
目录中，这是什么？

588
00:26:34,650 --> 00:26:36,210
LS的列表。

589
00:26:36,210 --> 00:26:39,332
有一堆东西在这里，
其中一些附带的设备，

590
00:26:39,332 --> 00:26:42,040
像我的桌面文件夹，下载
文件夹，Dropbox文件夹，并且所有

591
00:26:42,040 --> 00:26:42,850
这些东西。

592
00:26:42,850 --> 00:26:45,410
但有趣的是，
是的hello.c，这

593
00:26:45,410 --> 00:26:47,286
我创建了一个刚才用gedit。

594
00:26:47,286 --> 00:26:49,160
什么是最怪异的
看名字在这里，

595
00:26:49,160 --> 00:26:53,110
或许，我们没有
看到最后一次呢？

596
00:26:53,110 --> 00:26:54,710
>> a.out的，对不对？

597
00:26:54,710 --> 00:26:56,920
因此，早在一天，它
刚刚决定，当

598
00:26:56,920 --> 00:26:58,760
编译程序
对于第一次，

599
00:26:58,760 --> 00:27:02,360
你没有指定名称
一个文件，让我们把它叫做。

600
00:27:02,360 --> 00:27:05,800
和a.out的意思只是，这是
编译器的输出。

601
00:27:05,800 --> 00:27:07,790
因此，它是一个程序一个可怕的名字。

602
00:27:07,790 --> 00:27:12,820
但是，这种逻辑，点大幅削减
当前目录下，削减的a.out，

603
00:27:12,820 --> 00:27:16,102
应该是说有其实
我的Hello World程序。

604
00:27:16,102 --> 00:27:17,560
现在，一个小热身运动了。

605
00:27:17,560 --> 00:27:20,420
如果我要重新命名此
文件，原来你

606
00:27:20,420 --> 00:27:23,000
从一个名移动一个文件到另一个。

607
00:27:23,000 --> 00:27:28,750
所以MV的a.out，然后我
可以称之为你好Enter键。

608
00:27:28,750 --> 00:27:30,940
所以这是一个Linux命令。

609
00:27:30,940 --> 00:27:34,370
DOS有这个年前，
Windows有一个终端窗口

610
00:27:34,370 --> 00:27:36,460
一些看起来的
这样，Linux和Mac

611
00:27:36,460 --> 00:27:38,140
电脑有这样的闪烁提示。

612
00:27:38,140 --> 00:27:41,490
虽然我们大多数人可能
很少，如果有的话，使用它。

613
00:27:41,490 --> 00:27:44,590
>> 但我做了什么是运行
程序，其名称是MV，

614
00:27:44,590 --> 00:27:47,900
我已经向它提供
两个参数，可以这么说。

615
00:27:47,900 --> 00:27:48,630
两个输入。

616
00:27:48,630 --> 00:27:50,260
a.out的是原来的名称。

617
00:27:50,260 --> 00:27:51,630
你好是新名称。

618
00:27:51,630 --> 00:27:55,670
所以，如果我现在做点斜线
你好，回车，即存在。

619
00:27:55,670 --> 00:28:00,770
如果我做点斜线的a.out，
你能指望我应该看什么？

620
00:28:00,770 --> 00:28:02,250
>> 击，没有这样的文件或目录。

621
00:28:02,250 --> 00:28:03,350
因为我只是给它改名。

622
00:28:03,350 --> 00:28:04,975
因此，这需要一点时间来适应。

623
00:28:04,975 --> 00:28:06,977
但问题集1
规范将真正

624
00:28:06,977 --> 00:28:08,810
通过牵你的手
一些本minutae的。

625
00:28:08,810 --> 00:28:11,050
因为这是一个完整的
知识产权分心

626
00:28:11,050 --> 00:28:12,966
从更有趣
创意就在眼前，这

627
00:28:12,966 --> 00:28:15,310
实际上是创造
出来的东西代码。

628
00:28:15,310 --> 00:28:18,830
但是，让我们做一处修改
现在这个计划。

629
00:28:18,830 --> 00:28:23,150
>> 回想一下，上次我做了一件
这样，printf的说出你的名字。

630
00:28:23,150 --> 00:28:25,790
而事实上，我们只是做了该
在大屏幕上在那边。

631
00:28:25,790 --> 00:28:30,640
然后我做字符串s变
GetString的开括号，括号接近。

632
00:28:30,640 --> 00:28:33,430
和括号只是速记
符号的括号。

633
00:28:33,430 --> 00:28:36,460
因此，没有GetString的任何参数？

634
00:28:36,460 --> 00:28:38,440
没有不投入，但它
需要括号，

635
00:28:38,440 --> 00:28:41,830
因为这是划定
一个函数的调用。

636
00:28:41,830 --> 00:28:46,440
>> 所以我要继续前进，并尝试
现在运行的编译器上这个节目。

637
00:28:46,440 --> 00:28:50,774
铿锵的hello.c，因为我
没有现在改名。

638
00:28:50,774 --> 00:28:51,940
我有一大堆的错误。

639
00:28:51,940 --> 00:28:53,570
让我们缩小在这里。

640
00:28:53,570 --> 00:28:55,420
如果我滚动了一遍，
就像我说最后一次，

641
00:28:55,420 --> 00:28:58,420
到第一，相同的错误
我得到了最后一次。

642
00:28:58,420 --> 00:29:04,210
在hello.c中的第6行我有一个
未声明的标识符字符串，

643
00:29:04,210 --> 00:29:05,590
没有我的意思是在标准？

644
00:29:05,590 --> 00:29:06,750
我没有。

645
00:29:06,750 --> 00:29:10,050
因为什么样的错误，我是用这个做
程序，如果从上一次召回？

646
00:29:10,050 --> 00:29:13,219

647
00:29:13,219 --> 00:29:15,010
是的，我们需要的
所谓训练轮

648
00:29:15,010 --> 00:29:16,510
我们就用了几个星期。

649
00:29:16,510 --> 00:29:19,480
但我需要指定另外，
某处的器具的内部，

650
00:29:19,480 --> 00:29:22,720
是，我们写了一个文件
就在几年前。

651
00:29:22,720 --> 00:29:26,500
其内部是功能
就像显然GetString的。

652
00:29:26,500 --> 00:29:35,160
所以，现在如果我去背下来在这里，
放大，并重新运行铛的hello.c。

653
00:29:35,160 --> 00:29:36,500
妈的，另一个错误。

654
00:29:36,500 --> 00:29:38,590
但我们还没有看到过这一项。

655
00:29:38,590 --> 00:29:41,900
>> 这其中的多一点
深奥弄清楚。

656
00:29:41,900 --> 00:29:46,910
但是，这是故意的屏幕上，
因为我们想讲这个故事。

657
00:29:46,910 --> 00:29:51,280
当你编译的hello.c，就像
图片来自前提出，

658
00:29:51,280 --> 00:29:54,650
你只是转换了
源代码的零和一。

659
00:29:54,650 --> 00:30:00,340
现在CS50的工作人员，几年前写的
CS50.h，并有相应的文件，

660
00:30:00,340 --> 00:30:01,640
CS50.c.

661
00:30:01,640 --> 00:30:04,490
而我们，几年前，
编译这些文件

662
00:30:04,490 --> 00:30:07,290
到出现这种情况的文件
被称为CS50.o.

663
00:30:07,290 --> 00:30:09,180
>> 或者也可以重命名的
一些不同的东西。

664
00:30:09,180 --> 00:30:11,054
但是，这是一个简单的方法
的考虑。

665
00:30:11,054 --> 00:30:14,960
所以我们做了CS50的
图书馆成零和一。

666
00:30:14,960 --> 00:30:20,340
但无处我已指定
我想结合我的零

667
00:30:20,340 --> 00:30:24,030
和那些对我的hello world
计划与零和一

668
00:30:24,030 --> 00:30:29,760
该CS50人员创建了几年
前成一个完整的程序。

669
00:30:29,760 --> 00:30:34,100
所有我所指定的写作
铛的hello.c是编译的hello.c。

670
00:30:34,100 --> 00:30:38,380
>> 我还没有告诉铛来
在零和一的链接

671
00:30:38,380 --> 00:30:41,650
创建CS50人员
你前一段时间。

672
00:30:41,650 --> 00:30:48,280
所以这是一个简单的办法，
冲升的链接，CS50。

673
00:30:48,280 --> 00:30:52,600
我们会再次看到这个
没过多久连连。

674
00:30:52,600 --> 00:30:54,420
但是现在发现，没有投诉。

675
00:30:54,420 --> 00:30:59,770
所以，现在如果我跑点斜线
您好，现在它的工作。

676
00:30:59,770 --> 00:31:03,840
虽然这是一个有点误导
因为我刚刚重新哪些文件？

677
00:31:03,840 --> 00:31:05,880
a.out的。

678
00:31:05,880 --> 00:31:07,930
>> 因此，让我退了一会儿就好了。

679
00:31:07,930 --> 00:31:10,900
我们刚刚编译的程序
有三行代码。

680
00:31:10,900 --> 00:31:14,710
当我跑世界你好，你好一会儿
以前，我没看到你的名字。

681
00:31:14,710 --> 00:31:17,080
那是因为我跑了
老版本的程序。

682
00:31:17,080 --> 00:31:22,700
但是，如果我确实跑点斜线的a.out
输入，说出你的名字，罗布，你好，

683
00:31:22,700 --> 00:31:23,370
世界。

684
00:31:23,370 --> 00:31:23,870
嗯。

685
00:31:23,870 --> 00:31:26,110
这是怎样的一个错误。

686
00:31:26,110 --> 00:31:28,560
大概的意思是说抢了吧？

687
00:31:28,560 --> 00:31:30,997
那么什么是固定在这里的代码。

688
00:31:30,997 --> 00:31:31,872
学生：[听不清]。

689
00:31:31,872 --> 00:31:38,415

690
00:31:38,415 --> 00:31:39,290
马兰大卫：没错。

691
00:31:39,290 --> 00:31:43,160
所以我只需要做出最后的好办法
让我传递一个占位符，

692
00:31:43,160 --> 00:31:45,690
如在空白填充，
就像我们刚才做了。

693
00:31:45,690 --> 00:31:47,870
但百分之s是现在
这填补了空白。

694
00:31:47,870 --> 00:31:52,100
所以，最后我们发现最后一个
这样的细节，有没有魔法。

695
00:31:52,100 --> 00:31:54,090
我要继续前进
并摆脱hellow的。

696
00:31:54,090 --> 00:31:56,070
我要继续前进
和摆脱的a.out的。

697
00:31:56,070 --> 00:31:58,410
所以现在我没有计划，
只是我的源代码。

698
00:31:58,410 --> 00:32:01,100
我要去跑
稍长的命令，铛

699
00:32:01,100 --> 00:32:05,650
冲Ø你好hello.c的冲刺LCS50。

700
00:32:05,650 --> 00:32:08,700
>> 现在，这是开始排序去
在左耳进右耳出的其他可能。

701
00:32:08,700 --> 00:32:10,366
但就取笑除了这是什么做的。

702
00:32:10,366 --> 00:32:14,910
铛是编译器，仪表板LCS50
故意在最后

703
00:32:14,910 --> 00:32:18,330
在一个句子里做什么？

704
00:32:18,330 --> 00:32:19,607
链接到CS50库。

705
00:32:19,607 --> 00:32:21,440
抓住零和
那些员工做

706
00:32:21,440 --> 00:32:23,310
和crams成我自己的计划。

707
00:32:23,310 --> 00:32:27,040
所以手头上的最后一个问题是，
什么是破折号Ø你好可能

708
00:32:27,040 --> 00:32:30,530
这样做，即使你从来没有
以前见过这种语法？

709
00:32:30,530 --> 00:32:34,920
>> 输出一个程序，是
未命名缺省的a.out。

710
00:32:34,920 --> 00:32:37,330
相反，它的命名打招呼。

711
00:32:37,330 --> 00:32:39,460
所以现在还没有a.out的。

712
00:32:39,460 --> 00:32:42,660
没有这样的文件或目录，
因为我明确地说，

713
00:32:42,660 --> 00:32:46,720
这个程序叫做打招呼，让
我现在可以输入这样的名字

714
00:32:46,720 --> 00:32:47,790
并将其行为。

715
00:32:47,790 --> 00:32:50,180
>> 现在坦率地说，男孩是
无趣的有

716
00:32:50,180 --> 00:32:52,170
要记住这一切
小细节，对不对？

717
00:32:52,170 --> 00:32:54,180
因此，让我们继续前进，
再次摆脱打招呼的。

718
00:32:54,180 --> 00:32:57,880
让我们回到一个世界
它足以让说你好。

719
00:32:57,880 --> 00:33:00,410
但是，这就是魔法
让为你做的，

720
00:33:00,410 --> 00:33:02,320
这就是乏味的
它为你做。

721
00:33:02,320 --> 00:33:04,630
而作为我们的计划和
问题变得更复杂，

722
00:33:04,630 --> 00:33:06,142
使将真正成为你的朋友。

723
00:33:06,142 --> 00:33:07,850
因为不会太长
从现在开始我们要

724
00:33:07,850 --> 00:33:11,150
到具有所编写的程序
不是一个文件，而是几个文件，

725
00:33:11,150 --> 00:33:16,310
并会自动的过程
编译所有这一切让我们在一起。

726
00:33:16,310 --> 00:33:20,620
>> 所以，现在打印。

727
00:33:20,620 --> 00:33:24,960
printf的是这个文件里面，标准
I / O点的小时，我们已经看到过，

728
00:33:24,960 --> 00:33:26,980
但有更多的printf比。

729
00:33:26,980 --> 00:33:30,482
有反斜线N，但也有
一堆其他的转义序列。

730
00:33:30,482 --> 00:33:32,940
和转义序列仅仅是一个
的说着什么奇特的方式

731
00:33:32,940 --> 00:33:35,990
以反斜杠开始，
不是一个正斜杠，反斜杠，

732
00:33:35,990 --> 00:33:37,920
并做了一些特别的东西。

733
00:33:37,920 --> 00:33:43,770
我们不会纠缠于其中的大多数，
但为什么会出现反斜杠双引号，

734
00:33:43,770 --> 00:33:44,830
你觉得呢？

735
00:33:44,830 --> 00:33:48,010
为什么会出现这种奇怪的序列
字符，反斜线双引号，

736
00:33:48,010 --> 00:33:50,505
为什么会是这样有用吗？

737
00:33:50,505 --> 00:33:51,380
学生：[听不清]。

738
00:33:51,380 --> 00:33:56,594

739
00:33:56,594 --> 00:33:57,760
马兰大卫：没错，对不对？

740
00:33:57,760 --> 00:34:01,830
回想一下我们的Hello World程序
我们已经见过不少次了，

741
00:34:01,830 --> 00:34:05,880
每一次，我们已经看到的Hello World
方案我们内部有双引号

742
00:34:05,880 --> 00:34:08,210
这是打招呼逗号
世界反斜杠ñ。

743
00:34:08,210 --> 00:34:10,070
但想到自己，
如果你究竟是什么

744
00:34:10,070 --> 00:34:12,520
想打印出一个引号？

745
00:34:12,520 --> 00:34:16,100
你的第一反应可能是，我不
知道我为什么会想在这里do--，

746
00:34:16,100 --> 00:34:18,780
我们可以稍微被动
积极的，你好的朋友。

747
00:34:18,780 --> 00:34:21,350
我们可能需要做这样的事情。

748
00:34:21,350 --> 00:34:25,230
>> 但是，为什么是现在这个问题？

749
00:34:25,230 --> 00:34:28,730
无视弯引号放在一边
基调为我们自动完成。

750
00:34:28,730 --> 00:34:29,730
这是为什么有问题？

751
00:34:29,730 --> 00:34:36,719

752
00:34:36,719 --> 00:34:37,270
>> 没错。

753
00:34:37,270 --> 00:34:39,022
因为我们有像4引号。

754
00:34:39,022 --> 00:34:41,230
以及第一个可能
去与第二个，

755
00:34:41,230 --> 00:34:43,271
也许第四个
去与第三个，

756
00:34:43,271 --> 00:34:46,170
或者，我是说我什至不知道，
也不是计算机将是。

757
00:34:46,170 --> 00:34:48,352
再次计算机，编译器
再次，是相当愚蠢的。

758
00:34:48,352 --> 00:34:50,060
他们只会做什么
你告诉他们做什么。

759
00:34:50,060 --> 00:34:54,270
如果你不明确自己
很可能会引发错误。

760
00:34:54,270 --> 00:34:57,700
>> 如果你不明确就如何
做花生酱和果冻三明治

761
00:34:57,700 --> 00:34:59,510
奇怪的事情可能会到达。

762
00:34:59,510 --> 00:35:00,580
这是同样的想法。

763
00:35:00,580 --> 00:35:03,100
现在，我只想说有
其他一些转义序列，

764
00:35:03,100 --> 00:35:04,820
不过我们会找到那些用不了多久。

765
00:35:04,820 --> 00:35:07,410
本质上这些逃生
序列代表什么

766
00:35:07,410 --> 00:35:10,480
你可能无法
太容易在键盘上，

767
00:35:10,480 --> 00:35:12,010
没有混淆的计算机。

768
00:35:12,010 --> 00:35:15,733
>> 现在，与此同时，我们
占位符的printf。

769
00:35:15,733 --> 00:35:19,630
％的D，它也可以写成
在几乎所有情况下的百分之一，

770
00:35:19,630 --> 00:35:21,610
是一个占位符的数据是什么类型的？

771
00:35:21,610 --> 00:35:23,920
什么样的价值？

772
00:35:23,920 --> 00:35:24,920
十进制数。

773
00:35:24,920 --> 00:35:27,234
所以实际上，我们将开始
使用％的I，因为它是

774
00:35:27,234 --> 00:35:28,650
比较简单，就像一个整数。

775
00:35:28,650 --> 00:35:29,550
％的I。

776
00:35:29,550 --> 00:35:31,320
一个整数，它恰好是小数。

777
00:35:31,320 --> 00:35:35,690
>> 百分比Š我们已经说了
占位符的字符串。

778
00:35:35,690 --> 00:35:38,630
这仅仅是一个词，一个短语，
一个段落，一篇论文，等等。

779
00:35:38,630 --> 00:35:40,830
这是一个序列
一些长度的字符。

780
00:35:40,830 --> 00:35:42,820
我们将不久看到
一些其他的。

781
00:35:42,820 --> 00:35:45,950
但百分之c是单个字符。

782
00:35:45,950 --> 00:35:48,500
百分比f是一个
浮点数

783
00:35:48,500 --> 00:35:50,860
这样有一个实数
在这一个小数点，这

784
00:35:50,860 --> 00:35:52,550
当然不是一个整数。

785
00:35:52,550 --> 00:35:54,670
并有一个整体
一群人也是如此。

786
00:35:54,670 --> 00:35:56,990
>> 同时，在C和
在许多语言中，

787
00:35:56,990 --> 00:35:58,650
我们有不同的数据类型。

788
00:35:58,650 --> 00:36:00,650
不同类型的
玻璃碗，如果你会的。

789
00:36:00,650 --> 00:36:03,830
碗我用最后一次
是为乒乓球，

790
00:36:03,830 --> 00:36:06,990
但是，我们还可以存储不同
如字符和字符串值

791
00:36:06,990 --> 00:36:10,820
并在容器中的整数，
就像一个变量，而C有这些。

792
00:36:10,820 --> 00:36:14,020
char是数据的类型，
变量的类型，

793
00:36:14,020 --> 00:36:15,700
您可以在其中存储的字符。

794
00:36:15,700 --> 00:36:19,560
浮球是一个类型的变量
它可以存储一个实数。

795
00:36:19,560 --> 00:36:21,220
>> INT当然是一个int。

796
00:36:21,220 --> 00:36:23,760
和相当可笑
命名很长很长

797
00:36:23,760 --> 00:36:26,830
在这里，你基本上可以存储
一个很长的数字，连

798
00:36:26,830 --> 00:36:29,930
更多的数字则
典型的诠释可能存储。

799
00:36:29,930 --> 00:36:32,420
但我们会回来用不了多久。

800
00:36:32,420 --> 00:36:35,520
>> 在CS50点ħ同时
在其他的头文件

801
00:36:35,520 --> 00:36:37,630
我们已经看到一对夫妇
在使用时间，有

802
00:36:37,630 --> 00:36:41,350
另外两种数据类型
不要在C中存在的典型。

803
00:36:41,350 --> 00:36:45,000
一个是字符串，我们会看到在
几个星期什么真正的字符串

804
00:36:45,000 --> 00:36:46,610
在引擎盖下方。

805
00:36:46,610 --> 00:36:47,950
一个是布尔值。

806
00:36:47,950 --> 00:36:51,650
和一个bool是一个变量，
可以只对特定的值。

807
00:36:51,650 --> 00:36:54,370
而只是根据上周的
划痕的解释，

808
00:36:54,370 --> 00:36:56,680
以及最近C，
你会猜想

809
00:36:56,680 --> 00:37:01,770
有两个可能的值
有些容器是bool类型？

810
00:37:01,770 --> 00:37:02,860
>> 是的，没有。

811
00:37:02,860 --> 00:37:03,870
1和0。

812
00:37:03,870 --> 00:37:04,502
真的还是假的。

813
00:37:04,502 --> 00:37:07,460
事实上就这么容易的最后
是传统的编程

814
00:37:07,460 --> 00:37:10,030
语言，说什么
像真或假。

815
00:37:10,030 --> 00:37:13,160
>> 同时，CS50库来
一堆的功能

816
00:37:13,160 --> 00:37:16,640
该工作人员为你写的，
除了刚开始的字符串。

817
00:37:16,640 --> 00:37:20,910
我们提前职能写道，
可以从用户获得的整数，

818
00:37:20,910 --> 00:37:22,990
得到一个字符，
得到一个浮点数，即

819
00:37:22,990 --> 00:37:25,160
仅仅是一个数字的小数点。

820
00:37:25,160 --> 00:37:28,290
得到一个很长很长，真的
从用户的大值。

821
00:37:28,290 --> 00:37:30,930
因此，我们只看到这
动作中的Ge​​tString的形式。

822
00:37:30,930 --> 00:37:33,230
但是，通过这些功能
很快就可以写

823
00:37:33,230 --> 00:37:36,070
即获得来自用户的输入的程序。

824
00:37:36,070 --> 00:37:39,230
>> 同时考虑这
计划，并考虑

825
00:37:39,230 --> 00:37:42,600
我们怎么可能现在就开始增加
将其与新的构建体。

826
00:37:42,600 --> 00:37:44,530
快速旋风之旅
然后我们将看看

827
00:37:44,530 --> 00:37:47,340
一些写一些
手动程序自己。

828
00:37:47,340 --> 00:37:49,700
今后如果我们想
实施条件，

829
00:37:49,700 --> 00:37:52,790
它不会看起来像一个
可爱的小漂亮的拼图。

830
00:37:52,790 --> 00:37:54,460
这将看起来多了几分神秘的。

831
00:37:54,460 --> 00:37:57,620
但是，这是典型的
在C的条件下结构

832
00:37:57,620 --> 00:38:00,380
>> 这个词，如果两
括号，里面其中

833
00:38:00,380 --> 00:38:02,590
将是某种形式的
布尔表达式。

834
00:38:02,590 --> 00:38:04,999
现在斜线斜线
在中间，这是

835
00:38:04,999 --> 00:38:07,290
此刻有点像
伪代码的占位符。

836
00:38:07,290 --> 00:38:11,576
但更正确，任何一行代码
在C中，与斜线斜线开始

837
00:38:11,576 --> 00:38:12,850
是一条评论。

838
00:38:12,850 --> 00:38:15,920
>> 这就像一个便条，你可能
换上的文章，印在纸上。

839
00:38:15,920 --> 00:38:17,290
这是一张纸条给自己。

840
00:38:17,290 --> 00:38:20,100
它没有的功能
对方案的影响。

841
00:38:20,100 --> 00:38:23,580
这有点提醒的，这是你自己
文件以什么回事。

842
00:38:23,580 --> 00:38:25,720
因此，在目前这样做
是那种占位符

843
00:38:25,720 --> 00:38:27,560
不管是什么里面
这些大括号

844
00:38:27,560 --> 00:38:29,810
最终是要做些什么。

845
00:38:29,810 --> 00:38:35,160
>> 同时你有两个叉
路上，一个if else结构是这样的。

846
00:38:35,160 --> 00:38:37,024
你可以的，如果，ELSEIF，否则。

847
00:38:37,024 --> 00:38:39,690
现在，这是值得注意的，尤其是
如果你已经围绕谷歌搜索

848
00:38:39,690 --> 00:38:42,480
网上资源出
好奇心，或者如果你拿起

849
00:38:42,480 --> 00:38:44,575
过程中的一个
在C推荐的书籍，

850
00:38:44,575 --> 00:38:48,430
你会看到，人类有很多
不同的偏好是如何

851
00:38:48,430 --> 00:38:50,510
来表达自己的代码。

852
00:38:50,510 --> 00:38:53,800
有些人喜欢把
大括号，因为我在这里所做的。

853
00:38:53,800 --> 00:38:57,760
有些人喜欢把卷发
在这里括号为实例。

854
00:38:57,760 --> 00:39:01,700
>> 有些人喜欢把偷别人
在这里，然后这个在这里。

855
00:39:01,700 --> 00:39:05,120
有任何数目的方式来
写代码，他们都不

856
00:39:05,120 --> 00:39:06,566
是对本身。

857
00:39:06,566 --> 00:39:08,440
虽然有几个
这是相当错误的。

858
00:39:08,440 --> 00:39:11,315
但也有no--如果这是
最后一个很严谨的辩论。

859
00:39:11,315 --> 00:39:13,940
事实上，最讨厌的1
关于计算机科学的东西

860
00:39:13,940 --> 00:39:16,310
是如何自以为是
计算机科学家都可以。

861
00:39:16,310 --> 00:39:19,880
你会发现随着时间的推移
即使你开发的个人喜好

862
00:39:19,880 --> 00:39:22,130
为你的代码应该是什么样子。

863
00:39:22,130 --> 00:39:27,162
>> 不只是循规蹈矩，不只是建立输出，
但怎么也应该美观。

864
00:39:27,162 --> 00:39:30,120
所以，我们需要做的是沿着引导你
一路走向，至少目前，

865
00:39:30,120 --> 00:39:34,825
一个标准的CS50风格，至少
使事情变得均匀，易于阅读。

866
00:39:34,825 --> 00:39:37,330
但在那些更
不久区别。

867
00:39:37,330 --> 00:39:41,830
>> 布尔表达式在C中，如果你
想说的话，如果这个条件为真

868
00:39:41,830 --> 00:39:44,650
这等条件
真的，你不写的字

869
00:39:44,650 --> 00:39:46,610
并且，你会用英语。

870
00:39:46,610 --> 00:39:50,580
你不是用符号与符号，
对于原因，我们会回来的。

871
00:39:50,580 --> 00:39:54,520
如果你想说的，或者你用两个
竖线，这是美国键盘上

872
00:39:54,520 --> 00:39:57,650
通常上述的输入
键旁边的反斜杠。

873
00:39:57,650 --> 00:40:03,080
这也就意味着，如果这一条件
或该其他条件为真时执行此操作。

874
00:40:03,080 --> 00:40:05,210
>> 同时有这
疯狂的事情，这

875
00:40:05,210 --> 00:40:07,760
你将有机会
在一段时间使用一次。

876
00:40:07,760 --> 00:40:10,390
但它只是一种替代
的方式来表达自己。

877
00:40:10,390 --> 00:40:12,400
这一点，现在，让我们来
规定，它只是

878
00:40:12,400 --> 00:40:16,880
表达的另一种时髦的方式
如果ELSEIF，ELSEIF，ELSEIF，ELSEIF。

879
00:40:16,880 --> 00:40:19,720
它只是在格式条款
情况下，如果你从字面上的

880
00:40:19,720 --> 00:40:23,420
枚举值
你可能要检查。

881
00:40:23,420 --> 00:40:24,410
>> 同时循环。

882
00:40:24,410 --> 00:40:26,842
我们看到的比较
从头开始循环。

883
00:40:26,842 --> 00:40:29,550
而且我要挥挥手
各有什么这些东西的意思。

884
00:40:29,550 --> 00:40:33,520
但是请注意，循环将很
往往先从关键字。

885
00:40:33,520 --> 00:40:36,350
或者，它将开始与关键字一会儿。

886
00:40:36,350 --> 00:40:41,360
或者，它会开始用关键字
做的，用关键字而结束。

887
00:40:41,360 --> 00:40:43,920
>> 但是我们要看到
是东西更是这样。

888
00:40:43,920 --> 00:40:47,950
在这里，在一般的C语言，你怎么可能
声明一个变量，并给它一个值。

889
00:40:47,950 --> 00:40:50,610
在C语言中不足够，
就像在刮，你只要

890
00:40:50,610 --> 00:40:52,810
说给我一个变量叫什么。

891
00:40:52,810 --> 00:40:55,960
你要告诉℃，并告诉
编译器，更具体地说，

892
00:40:55,960 --> 00:40:58,680
什么类型的值你
要放在玻璃碗里。

893
00:40:58,680 --> 00:40:59,610
>> 它是一个整数？

894
00:40:59,610 --> 00:41:02,210
如果是这样，你要
从字面上说，INT，然后

895
00:41:02,210 --> 00:41:04,220
的变量的名称，
然后一个分号。

896
00:41:04,220 --> 00:41:08,050
如果你想要的，而不是字符串，称为
它就像我今天做了我的代码，

897
00:41:08,050 --> 00:41:10,920
你会说字符串s分号。

898
00:41:10,920 --> 00:41:14,200
当你想给它一个值
那么你可以使用等号，

899
00:41:14,200 --> 00:41:16,211
否则被称为
赋值运算符。

900
00:41:16,211 --> 00:41:17,960
并注意各
这些代码行

901
00:41:17,960 --> 00:41:20,650
有分号它的结束。

902
00:41:20,650 --> 00:41:22,550
>> 但是，坦率地说这只是
看起来有点丑。

903
00:41:22,550 --> 00:41:26,580
为什么我不能说，到电脑，给
我一个变量，并将其初始化为0。

904
00:41:26,580 --> 00:41:28,380
也就是说，给我一个空的玻璃碗里。

905
00:41:28,380 --> 00:41:28,980
虽然你可以。

906
00:41:28,980 --> 00:41:32,250
这样一来，判断一个叫你
必须使文体上随着时间的推移

907
00:41:32,250 --> 00:41:36,290
是，你写你的代码，这样，或
有种你把它打扫干净，并留下深刻的印象

908
00:41:36,290 --> 00:41:39,040
人们通过写两行只有一个。

909
00:41:39,040 --> 00:41:41,830
这将被认为是
通常是一个更优雅的方式

910
00:41:41,830 --> 00:41:43,870
的文体写你的代码。

911
00:41:43,870 --> 00:41:45,200
>> 功能我们当然看到了。

912
00:41:45,200 --> 00:41:46,340
他们将采用这种格式。

913
00:41:46,340 --> 00:41:48,881
一个函数的名称，有些
括号，然后也许有些

914
00:41:48,881 --> 00:41:49,910
里面的东西。

915
00:41:49,910 --> 00:41:52,540
或者，你可能会看到应用
多种功能方

916
00:41:52,540 --> 00:41:55,980
并排，像这样的事情。

917
00:41:55,980 --> 00:41:59,390
现在，作为一个切线，不
这个笑话现在做有意义吗？

918
00:41:59,390 --> 00:42:03,566

919
00:42:03,566 --> 00:42:04,960
>> [笑]

920
00:42:04,960 --> 00:42:09,360
这并不意味着这很有趣，但它
也或许做一点更有意义。

921
00:42:09,360 --> 00:42:12,140
所以，现在，让我们进入
CS50家电一会儿。

922
00:42:12,140 --> 00:42:14,640
让我在这里开了1传情。

923
00:42:14,640 --> 00:42:17,470
>> 的原因，事实上1
引入宜家产品目录

924
00:42:17,470 --> 00:42:20,080
和闪烁的画面
在iPhone的前位

925
00:42:20,080 --> 00:42:24,700
是真正绑在了一起
事实上，仅仅在几年前，在2007年，

926
00:42:24,700 --> 00:42:26,540
这段代码是
释放时，将其

927
00:42:26,540 --> 00:42:29,820
在第一个执行的一个
一个软件的

928
00:42:29,820 --> 00:42:31,494
那做什么叫做越狱。

929
00:42:31,494 --> 00:42:34,410
对于那些不熟悉，越狱
像手机或iPhone手机

930
00:42:34,410 --> 00:42:37,680
指基本上搞清楚
如何做事

931
00:42:37,680 --> 00:42:39,864
与它的公司
谁做的，也没打算。

932
00:42:39,864 --> 00:42:42,780
如要安装特定的
软件不是在应用程序商店，

933
00:42:42,780 --> 00:42:45,405
越狱你的手机，它
你做这样的事情多。

934
00:42:45,405 --> 00:42:47,447
但是，什么是乐趣
2007--而且一直

935
00:42:47,447 --> 00:42:49,780
几十个不同版本的
这些东西从那时起，

936
00:42:49,780 --> 00:42:53,540
在各种languages​​--是
这个节目在这里，所谓的iUnlock，

937
00:42:53,540 --> 00:42:57,036
实际上是用C写的所以我
拉升的源代码本，

938
00:42:57,036 --> 00:42:59,910
只是那种告诉你一些
与结构的相似性

939
00:42:59,910 --> 00:43:01,450
我们一直在讨论迄今。

940
00:43:01,450 --> 00:43:05,150
现在有更多的方式在这里的复杂性
比我们在课堂上已经看到了。

941
00:43:05,150 --> 00:43:07,160
让我在这里滚动只是一点点。

942
00:43:07,160 --> 00:43:11,520
>> 但是请注意these--好，我们注意到一些
things--但这里要注意这些线，

943
00:43:11,520 --> 00:43:14,090
包括标准的I / O点小时。

944
00:43:14,090 --> 00:43:17,660
和all--线24，please--
注意标准的I / O

945
00:43:17,660 --> 00:43:21,380
点H和一大堆其他的
文件，显然其他人

946
00:43:21,380 --> 00:43:22,160
写。

947
00:43:22,160 --> 00:43:24,850
如果我们向下滚动
这一点，随意一点，

948
00:43:24,850 --> 00:43:27,910
请注意，我不知道该怎么写
这一切我一定还，

949
00:43:27,910 --> 00:43:28,880
但是有如果。

950
00:43:28,880 --> 00:43:30,400
因此很明显，这有一个分支。

951
00:43:30,400 --> 00:43:33,210
>> 如果我向下滚动一点点
如果再有另一个。

952
00:43:33,210 --> 00:43:38,210
如果我向上滚动，我觉得
围绕线100，我看到了。

953
00:43:38,210 --> 00:43:40,020
所以我不太清楚
是如何工作的呢，

954
00:43:40,020 --> 00:43:43,180
但是这是一个for循环，那将
让我重复的时候一定数目。

955
00:43:43,180 --> 00:43:45,230
如果我所有的滚动
的方式向底部

956
00:43:45,230 --> 00:43:51,020
我看到有一个
功能这儿叫

957
00:43:51,020 --> 00:43:54,570
主，以及一些额外币
为您的阅读快感。

958
00:43:54,570 --> 00:43:57,830
>> 因此，这仅仅是say--，我们会把
课程的源之间的这种在线

959
00:43:57,830 --> 00:44:01,480
代码today--，即使其中的一些
我们认为理所当然的设备，

960
00:44:01,480 --> 00:44:05,130
在一天结束的时候你还在
用我们这些已经基本结构

961
00:44:05,130 --> 00:44:07,430
不断推出已有迄今。

962
00:44:07,430 --> 00:44:08,620
这就足够了的那一个。

963
00:44:08,620 --> 00:44:11,480
好吧，现在让我们来
实际上建立的东西。

964
00:44:11,480 --> 00:44:15,640
>> 让我们超越像
hello.c中，并打开了这一点，

965
00:44:15,640 --> 00:44:17,170
让我们在这里写这个程序。

966
00:44:17,170 --> 00:44:19,850
我要继续前进，
编写一个名为如adder.c程序，

967
00:44:19,850 --> 00:44:23,310
在生活中，其目的将是
像我的第一个超级简单的计算器

968
00:44:23,310 --> 00:44:24,840
这只是增加了几个数字。

969
00:44:24,840 --> 00:44:27,050
不是因为这是一个硬
的问题，而是因为它

970
00:44:27,050 --> 00:44:29,390
让我现在配合
在一起的几件事情。

971
00:44:29,390 --> 00:44:33,100
所以我要继续前进，包括
标准I / O点H和CS50点小时。

972
00:44:33,100 --> 00:44:34,670
我要说INT主要作废。

973
00:44:34,670 --> 00:44:36,545
并再次在未来的
我们会回来吧

974
00:44:36,545 --> 00:44:38,560
成在这方面和空隙装置。

975
00:44:38,560 --> 00:44:43,340
>> 而现在我会说些什么
如printf，给我一个整数。

976
00:44:43,340 --> 00:44:47,610
现在，在我的第二行，
我该如何表达自己这样的

977
00:44:47,610 --> 00:44:50,980
我想声明一个变量
这是怎么回事存储一个int？

978
00:44:50,980 --> 00:44:55,470
从字面上看我该怎么输入，如果我想
创建一个存储一个int变量

979
00:44:55,470 --> 00:44:58,270
你会说什么？

980
00:44:58,270 --> 00:44:59,650
整数a等于调用getInt。

981
00:44:59,650 --> 00:45:00,485
当然，这样的作品。

982
00:45:00,485 --> 00:45:02,360
和公正的一致性
用你的代码会

983
00:45:02,360 --> 00:45:04,485
在网上看到的，让我改变
此为x，只是因为变量x

984
00:45:04,485 --> 00:45:06,830
是一种常见的变量名
使用中，至少在代数。

985
00:45:06,830 --> 00:45:08,720
现在让我继续前进，不要再printf的。

986
00:45:08,720 --> 00:45:10,692
给我一个整数。

987
00:45:10,692 --> 00:45:12,900
现在，我要那种
对学习的模式，

988
00:45:12,900 --> 00:45:14,490
我要说诠释y到达调用getInt。

989
00:45:14,490 --> 00:45:16,340
>> 我们已经不习惯
调用getInt之前，但只是

990
00:45:16,340 --> 00:45:19,860
喜欢的GetString去，并得到一个字符串，
像哈维尔观众一样，

991
00:45:19,860 --> 00:45:22,780
同样不调用getInt
开始闪烁提示。

992
00:45:22,780 --> 00:45:26,750
和有效地等待用户
给它一个整数，通过键入它

993
00:45:26,750 --> 00:45:27,900
并按下Enter键。

994
00:45:27,900 --> 00:45:30,850
现在，最后，我该怎么办
对此，printf的总和of--

995
00:45:30,850 --> 00:45:36,080
并让我看上now--
百分之一和百分之i是目前

996
00:45:36,080 --> 00:45:39,270
í感叹号反斜线ñ。

997
00:45:39,270 --> 00:45:42,750
那你觉得我会
现在摆在作为附加输入

998
00:45:42,750 --> 00:45:44,620
对printf？

999
00:45:44,620 --> 00:45:47,380
>> 我不想说
从字面上报价引文结束的X.

1000
00:45:47,380 --> 00:45:52,210
我想在类X和
那么，现在让我们看上

1001
00:45:52,210 --> 00:45:54,420
而我们只是假设
我们可以做我们想要的。

1002
00:45:54,420 --> 00:45:56,330
你接下来想要说什么？

1003
00:45:56,330 --> 00:45:57,070
X加Y。

1004
00:45:57,070 --> 00:45:58,520
事实上，将工作。

1005
00:45:58,520 --> 00:46:01,760
它的最低限度的编程语言
做到了解基本的算术运算，

1006
00:46:01,760 --> 00:46:03,500
所以这其实应该工作。

1007
00:46:03,500 --> 00:46:06,730
>> 因此，让我继续前进，不要让
加法器在我的黑色和白色窗

1008
00:46:06,730 --> 00:46:08,090
到这里，回车。

1009
00:46:08,090 --> 00:46:10,830
神秘的线，但没有错误
消息，所以这是很好的。

1010
00:46:10,830 --> 00:46:14,410
点斜线加法，给我一个整数，1。

1011
00:46:14,410 --> 00:46:16,230
给我一个整数，2。

1012
00:46:16,230 --> 00:46:18,770
的1和2的总和为3。

1013
00:46:18,770 --> 00:46:21,730
>> 好吧，所以很琐碎
程序，但它是什么呢？

1014
00:46:21,730 --> 00:46:25,680
它让我用一个函数
叫这里，这里调用另一个函数，

1015
00:46:25,680 --> 00:46:29,260
两次调用调用getInt中，
第三次调用printf，

1016
00:46:29,260 --> 00:46:30,720
然后用这些占位符。

1017
00:46:30,720 --> 00:46:33,160
所以这是一个多一点
先进的比上一次。

1018
00:46:33,160 --> 00:46:35,260
但是如果我想
得到一个小票友？

1019
00:46:35,260 --> 00:46:38,900
>> 让我继续前进，现在做到这一点。

1020
00:46:38,900 --> 00:46:42,890
让我继续前进，创造一个
新的文件名为为零的条件。

1021
00:46:42,890 --> 00:46:44,890
我要去拯救
一段时间类的缘故

1022
00:46:44,890 --> 00:46:48,260
而刚刚粘贴在
代码为出发点。

1023
00:46:48,260 --> 00:46:51,510
而现在我只是把
一些在中间的是新来的。

1024
00:46:51,510 --> 00:46:55,889
所以printf的，我想一个整数吧。

1025
00:46:55,889 --> 00:46:58,180
而这一切代码都可以
在球场上的网站，

1026
00:46:58,180 --> 00:47:00,556
你不必键入这一切了
在课堂上，如果你不能再喝了。

1027
00:47:00,556 --> 00:47:02,638
INT，现在我要去
用它代替x和y，

1028
00:47:02,638 --> 00:47:05,270
我要使用N，这是
可能是最常见的名称

1029
00:47:05,270 --> 00:47:09,220
用于在计算机程序中的一个整数。

1030
00:47:09,220 --> 00:47:12,060
现在我想做一个
在这里，小的判断。

1031
00:47:12,060 --> 00:47:15,460
我要去当n看
大于0，则

1032
00:47:15,460 --> 00:47:23,670
我会说printf--哎呦，
printf--你选择了一个正数，

1033
00:47:23,670 --> 00:47:25,370
感叹号反斜杠ñ。

1034
00:47:25,370 --> 00:47:26,460
关闭了。

1035
00:47:26,460 --> 00:47:33,150
否则我要打印出来的printf
你选择了一个负数。

1036
00:47:33,150 --> 00:47:35,377
>> 现在你骂我之前，
让我们来运行这个程序。

1037
00:47:35,377 --> 00:47:36,210
让我去这儿吧。

1038
00:47:36,210 --> 00:47:40,730
以及如何编译程序
所谓的条件几许0？

1039
00:47:40,730 --> 00:47:42,300
请条件几许0。

1040
00:47:42,300 --> 00:47:45,560
那种愚蠢的名字，但 - 该死。

1041
00:47:45,560 --> 00:47:47,560
好的，好的教学时刻。

1042
00:47:47,560 --> 00:47:48,410
为什么说分手？

1043
00:47:48,410 --> 00:47:51,360

1044
00:47:51,360 --> 00:47:54,710
>> 什么我不小心把这个文件？

1045
00:47:54,710 --> 00:47:56,876
种可以推断
从选项卡在这里。

1046
00:47:56,876 --> 00:47:58,750
因此，它不是坏的，我
这样做，因为这

1047
00:47:58,750 --> 00:48:00,208
也许会发生一些你。

1048
00:48:00,208 --> 00:48:03,880
所以我不小心叫我
源代码的条件0。

1049
00:48:03,880 --> 00:48:09,950
但是按照惯例，我的源代码应该
在一个名为条件0几许C文件，

1050
00:48:09,950 --> 00:48:11,720
或什么的C点。

1051
00:48:11,720 --> 00:48:12,610
>> 因此，让我解决这个问题。

1052
00:48:12,610 --> 00:48:16,880
就像Microsoft Word中，我可以走了
另存为，做条件0 C点。

1053
00:48:16,880 --> 00:48:20,100
现在只是要整齐，我
要继续前进，并删除

1054
00:48:20,100 --> 00:48:23,020
状态0，这是我的旧版本。

1055
00:48:23,020 --> 00:48:26,550
现在，让我们做制作
状态0，回车。

1056
00:48:26,550 --> 00:48:27,870
好吧，似乎不错。

1057
00:48:27,870 --> 00:48:29,510
>> 条件0，回车。

1058
00:48:29,510 --> 00:48:33,530
我想一个整数请，50，
你选择了一个正数。

1059
00:48:33,530 --> 00:48:35,390
现在怎么样负50？

1060
00:48:35,390 --> 00:48:37,660
你选择了一个负数。

1061
00:48:37,660 --> 00:48:39,605
现在怎么样，0。

1062
00:48:39,605 --> 00:48:42,250

1063
00:48:42,250 --> 00:48:45,350
很肯定的0不是消极的。

1064
00:48:45,350 --> 00:48:47,780
>> 因此，这是怎样的一个逻辑错误。

1065
00:48:47,780 --> 00:48:50,680
我该如何解决这个问题？

1066
00:48:50,680 --> 00:48:57,260
否则，如果n小于0，这样做，否则
我们可以有一个三路分支在这里，

1067
00:48:57,260 --> 00:49:01,740
printf的你选0。

1068
00:49:01,740 --> 00:49:06,150
所以现在，如果我重新运行该
程序，编译后

1069
00:49:06,150 --> 00:49:10,790
再次化妆，现在重新运行
状态0，我会在这里看到

1070
00:49:10,790 --> 00:49:14,570
0给我的输出。

1071
00:49:14,570 --> 00:49:16,280
所以，我们去哪儿了呢？

1072
00:49:16,280 --> 00:49:18,930
>> 那么它很容易忽略
森林中的树木。

1073
00:49:18,930 --> 00:49:23,590
所以，让我们来总结
与此2和1.5分钟的视频

1074
00:49:23,590 --> 00:49:25,710
最终是有点
从谷歌的广告，

1075
00:49:25,710 --> 00:49:28,850
但是这真的是应验了
即使使用这些基本的建筑是什么

1076
00:49:28,850 --> 00:49:33,020
块，我们可以最终做一次
我们有位编程

1077
00:49:33,020 --> 00:49:34,463
根据我们的皮带头脑。

1078
00:49:34,463 --> 00:49:35,150
>> [音乐播放]

1079
00:49:35,150 --> 00:49:38,370

1080
00:49:38,370 --> 00:49:40,540
>> SAROO布赖尔利（旁白）：
那是26年前，

1081
00:49:40,540 --> 00:49:42,470
我正要转5。

1082
00:49:42,470 --> 00:49:45,465
我们到了火车站，
我们登上了火车在一起。

1083
00:49:45,465 --> 00:49:48,010
我哥哥刚才说我会
住在这里，我会回来的。

1084
00:49:48,010 --> 00:49:51,140
我只是在想，嗯，你知道，
我还不如干脆去睡觉

1085
00:49:51,140 --> 00:49:52,690
他将只叫我起床。

1086
00:49:52,690 --> 00:49:55,145
而当我醒来的时候下一个
天，整个滑架

1087
00:49:55,145 --> 00:49:59,125
空了一个失控的火车，鬼
火车带我去，我不知道在哪里。

1088
00:49:59,125 --> 00:50:01,980

1089
00:50:01,980 --> 00:50:06,280
>> 我采用了澳大利亚，
一个澳大利亚家庭。

1090
00:50:06,280 --> 00:50:09,710
和妈妈都装饰了我
房间与印度的地图上，

1091
00:50:09,710 --> 00:50:11,950
她把旁边的我的床边。

1092
00:50:11,950 --> 00:50:15,830
我每天早上醒来的时候
看到地图，并因此

1093
00:50:15,830 --> 00:50:18,530
排序它不停的回忆活着。

1094
00:50:18,530 --> 00:50:20,530
人们会说，你是
试图找到一个针

1095
00:50:20,530 --> 00:50:23,560
在干草堆里，Saroo
你永远也找不到它。

1096
00:50:23,560 --> 00:50:28,540
>> 我曾闪过的地方，我
以前去，我家的闪烁

1097
00:50:28,540 --> 00:50:29,890
面孔。

1098
00:50:29,890 --> 00:50:34,060
这里是我母亲的形象，
坐在她的双腿交叉，

1099
00:50:34,060 --> 00:50:35,740
只是看着她哭。

1100
00:50:35,740 --> 00:50:38,160
人生就是这么辛苦。

1101
00:50:38,160 --> 00:50:41,237
这是我的宝贝。

1102
00:50:41,237 --> 00:50:44,320
我一直在寻找在谷歌地图和
意识到有谷歌地球也是如此。

1103
00:50:44,320 --> 00:50:48,140
在这个世界里，你可以放大，
我开始把所有这些想法

1104
00:50:48,140 --> 00:50:51,500
和什么样的可能性
这可以为我做。

1105
00:50:51,500 --> 00:50:54,890
我对自己说，你知道，你已经
把所有这些照片的回忆

1106
00:50:54,890 --> 00:50:58,590
和标志性建筑你来自哪里，以及
你知道什么是城镇的模样。

1107
00:50:58,590 --> 00:51:03,060
这可以是一个应用程序，它
你可以用它来找到你的归途。

1108
00:51:03,060 --> 00:51:06,720
>> 我想，嗯，我会放
点在加尔各答火车站，

1109
00:51:06,720 --> 00:51:10,890
和半径线，你知道，你
应寻找解决这个地区。

1110
00:51:10,890 --> 00:51:13,750
那种我碰到
这些火车轨道。

1111
00:51:13,750 --> 00:51:18,160
我开始跟随它，并
我来到了火车站的

1112
00:51:18,160 --> 00:51:22,228
反射的同一图像
那是在我的记忆。

1113
00:51:22,228 --> 00:51:23,707
一切都匹配。

1114
00:51:23,707 --> 00:51:27,950
我只是在想是的，我
知道我要去哪里。

1115
00:51:27,950 --> 00:51:30,116
我只是打算让
地图，我在我的脑海

1116
00:51:30,116 --> 00:51:33,080
引导我，带我回到了我的家乡。

1117
00:51:33,080 --> 00:51:36,420
>> 我来到家门口
我出生的房子。

1118
00:51:36,420 --> 00:51:39,140
而走了一圈约15
蠢蠢欲动米，

1119
00:51:39,140 --> 00:51:42,980
有三个女人站
外，彼此相邻。

1120
00:51:42,980 --> 00:51:47,830
而中间的一个走上前去，
我只是觉得，这是你的母亲。

1121
00:51:47,830 --> 00:51:53,450
她走上前来，她抱着我，
我们在那里约五分钟。

1122
00:51:53,450 --> 00:51:56,530

1123
00:51:56,530 --> 00:51:59,000
>> 她抓住我的手，
她把我的房子

1124
00:51:59,000 --> 00:52:02,450
并得到了电话，她在
响了我的妹妹和我的兄弟

1125
00:52:02,450 --> 00:52:05,600
说，你知道吗，
你的兄弟刚

1126
00:52:05,600 --> 00:52:09,340
所有突然出现像幽灵一样。

1127
00:52:09,340 --> 00:52:12,440
然后一家人再次团聚。

1128
00:52:12,440 --> 00:52:15,110
一切都很好，
我帮我妈出去，

1129
00:52:15,110 --> 00:52:17,110
她没有被累死累活。

1130
00:52:17,110 --> 00:52:19,555
她能活休息
她在和平的生活。

1131
00:52:19,555 --> 00:52:23,460
>> 这是一个大海捞针，
但针在那里。

1132
00:52:23,460 --> 00:52:24,400
一切都在那里。

1133
00:52:24,400 --> 00:52:28,260
一切，我们在世界
是一个按钮的点击。

1134
00:52:28,260 --> 00:52:32,010
但你必须有意愿和
决心想要它。

1135
00:52:32,010 --> 00:52:32,950
>> [音乐播放]

1136
00:52:32,950 --> 00:52:36,420

1137
00:52:36,420 --> 00:52:38,170
大卫马兰：奇妙
甜蜜的告别赛

1138
00:52:38,170 --> 00:52:40,540
刚一下即可
现在做的技术。

1139
00:52:40,540 --> 00:52:43,390
我们会看到你下周。

1140
00:52:43,390 --> 00:52:44,374