1
00:00:08,119 --> 00:00:11,630
[Powered by Google Translate] DAVID J.马兰：好吧，这是CS50，这是

2
00:00:11,630 --> 00:00:14,790
本周二开始。

3
00:00:14,790 --> 00:00:16,300
谢谢。

4
00:00:16,300 --> 00:00:19,000
让我们从这里开始，一个电话。

5
00:00:19,000 --> 00:00:30,005
我要拨打617-BUG-CS50。

6
00:00:30,005 --> 00:00:31,230
CS50：这是CS50。

7
00:00:31,230 --> 00:00:33,930
穿梭男孩，按1。

8
00:00:33,930 --> 00:00:36,660
在开始之前，请按9。

9
00:00:36,660 --> 00:00:38,180
DAVID J.马兰：所以他说，班车男孩，请按1。

10
00:00:38,180 --> 00:00:41,560
因此，我们准备按1。

11
00:00:41,560 --> 00:00:43,230
CS50：您的起源是什么？

12
00:00:43,230 --> 00:00:45,340
对于四，请按1。

13
00:00:45,340 --> 00:00:47,080
马瑟，请按2。

14
00:00:47,080 --> 00:00:49,240
斯顿，请按3。

15
00:00:49,240 --> 00:00:51,280
拉蒙特，请按4。

16
00:00:51,280 --> 00:00:53,210
纪念品馆，请按5。

17
00:00:53,210 --> 00:00:55,660
在开始之前，请按0。

18
00:00:55,660 --> 00:00:59,590
DAVID J.马兰：我们会按四。

19
00:00:59,590 --> 00:01:03,610
CS50：下穿梭离开这一刻，在1:10 PM，

20
00:01:03,610 --> 00:01:09,820
然后在1:20 PM，1:30 PM，1:40 PM。

21
00:01:09,820 --> 00:01:12,030
这是CS50。

22
00:01:12,030 --> 00:01:15,570
>> DAVID J.马兰：这是CS50的声音。

23
00:01:15,570 --> 00:01:18,030
这是一个例子的最终的项目，

24
00:01:18,030 --> 00:01:19,500
例如，你可以咬向

25
00:01:19,500 --> 00:01:20,600
学期结束的时候。

26
00:01:20,600 --> 00:01:23,840
比如，，shuttleboy.cs50.net存在 - 

27
00:01:23,840 --> 00:01:28,200
其实一个项目，我第一次写后，CS51

28
00:01:28,200 --> 00:01:29,740
回来时，我是一名大学生。

29
00:01:29,740 --> 00:01:32,250
这里的灵感当年，他们所有的

30
00:01:32,250 --> 00:01:34,320
印刷穿梭巴士时间表，以及有没有

31
00:01:34,320 --> 00:01:35,970
寻找的东西了网上的概念。

32
00:01:35,970 --> 00:01:38,730
所以，我的鸽子在一个周末，通过浇

33
00:01:38,730 --> 00:01:41,460
印刷的时间表，并把它移植到一个计算机程序。

34
00:01:41,460 --> 00:01:43,790
当时，所述计算机程序发生了要写入

35
00:01:43,790 --> 00:01:47,110
在C，你居然跑了它在输入班车男孩

36
00:01:47,110 --> 00:01:48,600
闪烁提示，如我们已经做了迄今。

37
00:01:48,600 --> 00:01:50,450
但这些年来，它演变成瞬间

38
00:01:50,450 --> 00:01:51,390
消息槐树。

39
00:01:51,390 --> 00:01:53,970
最近到本网站的发展，成

40
00:01:53,970 --> 00:01:57,720
基于短信的工具，以及这个基于语音的工具。

41
00:01:57,720 --> 00:02:00,170
这是暗示在各种各样的事情，你可以

42
00:02:00,170 --> 00:02:02,380
学期结束为自己做的。

43
00:02:02,380 --> 00:02:05,490
>> 例如，在那里，发生班车男孩的短信版

44
00:02:05,490 --> 00:02:06,510
操作如下。

45
00:02:06,510 --> 00:02:10,880
，你的手机上，如果你发送一条短信到41411

46
00:02:10,880 --> 00:02:14,300
然后发送的的特殊符号sboy，请为班车男孩，

47
00:02:14,300 --> 00:02:18,350
其次是由A和B，其中A是一个原点和B是一个

48
00:02:18,350 --> 00:02:19,070
目的地 - 

49
00:02:19,070 --> 00:02:21,030
例如，博伊尔斯顿空间四 - 

50
00:02:21,030 --> 00:02:23,330
你应该在几秒钟内是一个文本

51
00:02:23,330 --> 00:02:25,820
从航天飞机男孩的消息告诉你什么时候

52
00:02:25,820 --> 00:02:28,990
未来几年的班车，从A点到该

53
00:02:28,990 --> 00:02:29,640
B点。

54
00:02:29,640 --> 00:02:32,510
这是一个更普遍的例子，被称为什么

55
00:02:32,510 --> 00:02:33,920
使用API​​。

56
00:02:33,920 --> 00:02:36,930
>> 因此，举例来说，这里只是shuttleboy.cs50.net的，

57
00:02:36,930 --> 00:02:39,300
实际的基于Web的化身。

58
00:02:39,300 --> 00:02:42,480
但强调这一点和其他应用程序的数据，CS50

59
00:02:42,480 --> 00:02:45,560
已开发的所有暴露的形式在这里给大家

60
00:02:45,560 --> 00:02:49,340
的API，应用程序编程接口。

61
00:02:49,340 --> 00:02:52,220
而这仅仅是一种奇特的方式，人们喜欢说，我们对

62
00:02:52,220 --> 00:02:56,010
互联网和其他人花了一些时间来创建

63
00:02:56,010 --> 00:02:59,970
为了抢从我们的数据和软件，您可以使用

64
00:02:59,970 --> 00:03:02,510
然后在上面建立自己的应用程序

65
00:03:02,510 --> 00:03:03,840
该数据集。

66
00:03:03,840 --> 00:03:06,610
因此，举例来说，这班车男孩API页面在这里，

67
00:03:06,610 --> 00:03:09,390
恰好是在CS50手册，基本上文件

68
00:03:09,390 --> 00:03:13,080
你可以去CS50服务器的数据要求。

69
00:03:13,080 --> 00:03:16,240
例如，如果你熟悉CSV文件，逗号

70
00:03:16,240 --> 00:03:18,940
分隔的值，这些都只是形式的快速和肮脏的

71
00:03:18,940 --> 00:03:20,310
类似Excel的文件。

72
00:03:20,310 --> 00:03:23,110
所以，你可以问班车上所有的男孩的所有数据

73
00:03:23,110 --> 00:03:25,090
房子和他们的GPS坐标，你会得到

74
00:03:25,090 --> 00:03:27,300
回来了，从本质上讲，一个类似电子表格的，

75
00:03:27,300 --> 00:03:30,820
然后，你可以阅读到自己的程序，然后

76
00:03:30,820 --> 00:03:33,250
产生的结果，就像班车男孩本身

77
00:03:33,250 --> 00:03:34,160
发生做的事情。

78
00:03:34,160 --> 00:03:37,030
对于那些比较熟悉的，更现代的数据表示

79
00:03:37,030 --> 00:03:39,420
包括JSON，JavaScript对象表示法。

80
00:03:39,420 --> 00:03:40,620
东西会回来给你走向

81
00:03:40,620 --> 00:03:41,720
学期结束的时候。

82
00:03:41,720 --> 00:03:45,440
>> 但是，这只是其中的几个CS50自己的API。

83
00:03:45,440 --> 00:03:48,320
而令人兴奋的事情，现在，这些天来，Facebook和

84
00:03:48,320 --> 00:03:51,110
Twitter和谷歌，几乎每一个受欢迎的网站了

85
00:03:51,110 --> 00:03:54,130
有某种形式的API，这意味着如果你读了

86
00:03:54,130 --> 00:03:56,620
在他们的网站上的文档，你注册一个

87
00:03:56,620 --> 00:03:59,980
帐户，您就可以开始编写软件之上

88
00:03:59,980 --> 00:04:03,680
有任何工具或数据公司提供的。

89
00:04:03,680 --> 00:04:06,210
因此，我们自己的教学研究员几年

90
00:04:06,210 --> 00:04:07,620
写了Mac版本的。

91
00:04:07,620 --> 00:04:10,990
因此，在左上角的链接标题为“苹果在这里，你其实可以

92
00:04:10,990 --> 00:04:13,940
下载你自己的Mac上运行的Mac OS部件的做

93
00:04:13,940 --> 00:04:15,040
同样的事情。

94
00:04:15,040 --> 00:04:17,970
因此，它是所有有关的数据集上，像这样的。

95
00:04:17,970 --> 00:04:21,839
但更向本学期结束。

96
00:04:21,839 --> 00:04:25,780
>> 所以我们来看看真正的快速的一个错误，只是一种获得

97
00:04:25,780 --> 00:04:27,990
事情回暖的今天，与回想起一些

98
00:04:27,990 --> 00:04:29,660
事情，我们看到在上周。

99
00:04:29,660 --> 00:04:32,840
特别是，让我去拉起来，说，

100
00:04:32,840 --> 00:04:34,080
这个例子在这里。

101
00:04:34,080 --> 00:04:37,500
Buggy1.c，这是本课程的网站上，如果您想

102
00:04:37,500 --> 00:04:40,250
喜欢下载并戳在自己周围。

103
00:04:40,250 --> 00:04:43,520
但是，让我们在这里的放大在这相当短节目，

104
00:04:43,520 --> 00:04:46,550
超快速的回顾一下一些基本构建块，

105
00:04:46,550 --> 00:04:48,880
我们真的要开始考虑是理所当然的。

106
00:04:48,880 --> 00:04:51,860
>> 因此，蓝色的东西，在第1行至第9行，只是

107
00:04:51,860 --> 00:04:53,670
垒球的问题。

108
00:04:53,670 --> 00:04:54,590
所以，这些都只是意见。

109
00:04:54,590 --> 00:04:56,230
他们有没有功能上的意义。

110
00:04:56,230 --> 00:04:58,460
但他们在这个意义上，他们的意见笔记

111
00:04:58,460 --> 00:05:02,010
我的人，做自己的事情，所以在演讲后

112
00:05:02,010 --> 00:05:04,340
讲座中，我实际上可以记得这是什么程序

113
00:05:04,340 --> 00:05:07,120
没有读通过一行行

114
00:05:07,120 --> 00:05:08,990
在我的脑海里重新创建历史。

115
00:05:08,990 --> 00:05:11,000
此外，如果有人喜欢我把这个程序

116
00:05:11,000 --> 00:05:14,420
你，这是更清晰的你，因为这样的意见，

117
00:05:14,420 --> 00:05:16,680
是什么程序实际上做，或至少是

118
00:05:16,680 --> 00:05:18,210
程序应该做的事情。

119
00:05:18,210 --> 00:05:20,760
无论它是正确的，是另一回事。

120
00:05:20,760 --> 00:05:25,040
现在，在C，多行注释，回想一下，上线

121
00:05:25,040 --> 00:05:27,880
这里是神奇的符号，/ *。

122
00:05:27,880 --> 00:05:30,380
这意味着在这里来了一个注释的开始。

123
00:05:30,380 --> 00:05:34,560
并没有什么别的事情，直到你到达终点终止，

124
00:05:34,560 --> 00:05:36,700
这是* /，相反。

125
00:05:36,700 --> 00:05:39,120
因此，事实上，我这里有80个，一些奇怪的恒星从

126
00:05:39,120 --> 00:05:41,550
从左到右依次是真的只是一个审美的细节。

127
00:05:41,550 --> 00:05:43,370
它没有功能上的意义。

128
00:05:43,370 --> 00:05:44,490
>> 第11行吗？

129
00:05:44,490 --> 00:05:46,940
通俗地说是什么？

130
00:05:51,560 --> 00:05:52,540
那是什么？

131
00:05:52,540 --> 00:05:54,280
听众：包括标准。

132
00:05:54,280 --> 00:05:54,740
DAVID J.马兰：OK，好。

133
00:05:54,740 --> 00:05:57,500
因此，它包括stdio.h中的库。

134
00:05:57,500 --> 00:05:58,230
那么，是什么意思呢？

135
00:05:58,230 --> 00:06:01,570
那么，在这个文件中，stdio.h中，一大堆的

136
00:06:01,570 --> 00:06:03,320
函数声明 - 

137
00:06:03,320 --> 00:06:05,290
那是别人写的代码。

138
00:06:05,290 --> 00:06:08,160
声明一个函数，在一个完美的例子，

139
00:06:08,160 --> 00:06:10,250
stdio.h中 - 

140
00:06:10,250 --> 00:06:11,980
现在最喜欢的？

141
00:06:11,980 --> 00:06:14,300
因此我们知道printf，最常用的方法之一，使用，当然

142
00:06:14,300 --> 00:06:15,840
在初期，该库是存在的。

143
00:06:15,840 --> 00:06:19,290
如果我排除该行的代码，铛大喊

144
00:06:19,290 --> 00:06:22,550
在我一些有关使用未声明的符号。

145
00:06:22,550 --> 00:06:24,930
东西未申报的可能是关键字，因为

146
00:06:24,930 --> 00:06:27,770
我们没有告诉编译器输出看起来

147
00:06:27,770 --> 00:06:29,230
喜欢，除非我们有该行。

148
00:06:29,230 --> 00:06:31,830
而更多的地球，真的，该行说的是

149
00:06:31,830 --> 00:06:34,890
打开该文件，stdio.h中，无论它是在服务器上的

150
00:06:34,890 --> 00:06:38,200
硬盘驱动器或设备的硬盘驱动器，复制粘贴

151
00:06:38,200 --> 00:06:40,240
到我的文件，没有我的

152
00:06:40,240 --> 00:06:41,730
做手工。

153
00:06:41,730 --> 00:06:44,420
>> 现在，一旦我们在这里为主，不久我们将开始

154
00:06:44,420 --> 00:06:46,900
梳理int和空洞。

155
00:06:46,900 --> 00:06:48,430
但现在，让我们来看看在三线

156
00:06:48,430 --> 00:06:50,350
在15到17。

157
00:06:50,350 --> 00:06:52,250
这里，我要求车。

158
00:06:52,250 --> 00:06:54,900
7号线在我的评论说：“如果打印10

159
00:06:54,900 --> 00:06:59,410
星号，但没有。“为什么这不是打印的，其实，

160
00:06:59,410 --> 00:07:01,097
10个这样的明星吗？

161
00:07:01,097 --> 00:07:02,347
观众：[听不清]。

162
00:07:05,210 --> 00:07:05,800
DAVID J.马兰：没错。

163
00:07:05,800 --> 00:07:08,720
所以，请注意，我们从0开始计数。

164
00:07:08,720 --> 00:07:10,780
这实际上是一个编程惯例

165
00:07:10,780 --> 00:07:13,230
计算机科学，更普遍，开始计数

166
00:07:13,230 --> 00:07:14,610
从0而不是1。

167
00:07:14,610 --> 00:07:16,690
这真的只是来自于事实，即

168
00:07:16,690 --> 00:07:18,940
例如，当我们有八人在舞台上时，

169
00:07:18,940 --> 00:07:20,680
没有人举手，他们

170
00:07:20,680 --> 00:07:22,340
所有有效的零。

171
00:07:22,340 --> 00:07:24,260
因此，它只是种一台计算机公约，

172
00:07:24,260 --> 00:07:26,030
因此，从0开始计数。

173
00:07:26,030 --> 00:07:29,130
如果是这样的最低数量，你可以以二进制表示。

174
00:07:29,130 --> 00:07:32,270
>> 所以，在这里，我们已经开始初始化i为0。

175
00:07:32,270 --> 00:07:34,230
我们设定i等于0。

176
00:07:34,230 --> 00:07:37,780
但后来我犯了这个错误，在这里，说我是小于或

177
00:07:37,780 --> 00:07:38,820
等于10。

178
00:07:38,820 --> 00:07:41,700
但是，如果你认为，如果我是从0开始，然后我去

179
00:07:41,700 --> 00:07:46,410
，1，2，3，4，5，6，7，8，9，10，实际上，我要

180
00:07:46,410 --> 00:07:49,980
打印到屏幕上的11颗星，因为我已经走了

181
00:07:49,980 --> 00:07:52,410
和等于10。

182
00:07:52,410 --> 00:07:55,090
因此，简单的办法是什么？

183
00:07:55,090 --> 00:07:56,070
观众：[听不清]。

184
00:07:56,070 --> 00:07:57,350
DAVID J.马兰：只要将它更改为小于。

185
00:07:57,350 --> 00:07:59,700
如果你真的想，你可以做到这一点。

186
00:07:59,700 --> 00:08:01,370
但在一般情况下，是不可取的。

187
00:08:01,370 --> 00:08:04,020
因此，从0开始计数的东西，你应该

188
00:08:04,020 --> 00:08:05,510
通常习惯。

189
00:08:05,510 --> 00:08:07,810
现在，这整个结构本身？

190
00:08:07,810 --> 00:08:10,640
这条线的15 demarks一个for循环。

191
00:08:10,640 --> 00:08:12,510
因此，对于是不是一个函数。

192
00:08:12,510 --> 00:08:13,640
这只是一个声明。

193
00:08:13,640 --> 00:08:16,180
这是一个循环结构，就像我们所看到的划痕。

194
00:08:16,180 --> 00:08:17,600
它由三部分组成。

195
00:08:17,600 --> 00:08:19,740
请注意，这里是第一部分

196
00:08:19,740 --> 00:08:21,350
左边的分号。

197
00:08:21,350 --> 00:08:24,200
两个分号之间的中间部分。

198
00:08:24,200 --> 00:08:26,250
再有就是右手部分的权利

199
00:08:26,250 --> 00:08:27,640
第二个分号。

200
00:08:27,640 --> 00:08:31,822
现在，这些做什么？

201
00:08:31,822 --> 00:08:33,679
观众：[听不清]。

202
00:08:33,679 --> 00:08:34,270
DAVID J.马兰吗？

203
00:08:34,270 --> 00:08:34,816
是吗？

204
00:08:34,816 --> 00:08:35,980
观众：初始化。

205
00:08:35,980 --> 00:08:36,850
>> DAVID J.马兰：初始化。

206
00:08:36,850 --> 00:08:37,840
所以，这是什么意思呢？

207
00:08:37,840 --> 00:08:40,690
我们已经声明了一个变量叫我。

208
00:08:40,690 --> 00:08:43,840
它的类型是int，因为我已经指定了INT I。

209
00:08:43,840 --> 00:08:46,470
我初始化i的值为0。

210
00:08:46,470 --> 00:08:47,730
那么，这是什么真正的意思吗？

211
00:08:47,730 --> 00:08:50,680
它是有效的电脑说：嘿，给我足够的

212
00:08:50,680 --> 00:08:53,660
内存，足够的RAM，以适应数字，然后把

213
00:08:53,660 --> 00:08:56,130
0，块RAM。

214
00:08:56,130 --> 00:08:59,100
顺便说一句，有多大，是一个int通常情况下，至少里面

215
00:08:59,100 --> 00:09:00,280
的产品？

216
00:09:00,280 --> 00:09:01,000
观众：32位。

217
00:09:01,000 --> 00:09:01,670
DAVID J.马兰：32位。

218
00:09:01,670 --> 00:09:04,890
因此，这意味着32位，否则被称为4字节给我，

219
00:09:04,890 --> 00:09:07,250
并把值0，这是很容易的，因为

220
00:09:07,250 --> 00:09:09,110
它只是意味着将所有的位为0。

221
00:09:09,110 --> 00:09:11,690
>> 所以，现在，这里的第二部分是条件。

222
00:09:11,690 --> 00:09:14,590
和条件，顾名思义，就是检查

223
00:09:14,590 --> 00:09:18,100
再，再而三，是否是真还是假。

224
00:09:18,100 --> 00:09:21,410
因此，这只是说做下面的几行代码 - 

225
00:09:21,410 --> 00:09:23,950
即第16行，因为这是唯一一个缩进

226
00:09:23,950 --> 00:09:24,820
下 - 

227
00:09:24,820 --> 00:09:26,980
所以，只要i小于10。

228
00:09:26,980 --> 00:09:30,520
通过这个循环的每次迭代后，做

229
00:09:30,520 --> 00:09:33,840
递加在这种情况下，这是一+ +。

230
00:09:33,840 --> 00:09:35,580
现在，它不具有为i + +。

231
00:09:35,580 --> 00:09:37,610
这可能是我 - 。

232
00:09:37,610 --> 00:09:39,860
但如果我这样做，什么行为会

233
00:09:39,860 --> 00:09:41,370
这个计划吗？

234
00:09:41,370 --> 00:09:42,290
观众：这将是一个无限循环。

235
00:09:42,290 --> 00:09:44,060
DAVID J.马兰：这将是某种形式的无限循环，

236
00:09:44,060 --> 00:09:47,720
除非我们很幸运后2负亿左右。

237
00:09:47,720 --> 00:09:51,320
也许事情会环绕，只是性质的有限

238
00:09:51,320 --> 00:09:53,930
数，我们已经分配给一个int的位数。

239
00:09:53,930 --> 00:09:56,270
但它肯定是要遍历远远超过10

240
00:09:56,270 --> 00:09:58,630
肯定超过11次。

241
00:09:58,630 --> 00:10:02,240
>> 而现在，正如顺便说一句，我+ +和i  - 

242
00:10:02,240 --> 00:10:04,420
真的只是语法糖。

243
00:10:04,420 --> 00:10:07,210
什么是多一点，这只是速记符号

244
00:10:07,210 --> 00:10:08,720
明确写入如下：

245
00:10:08,720 --> 00:10:11,200
I = I + 1。

246
00:10:11,200 --> 00:10:13,460
这是相同的到i + +。

247
00:10:13,460 --> 00:10:15,860
它只是一种看起来更漂亮，说我+ +。

248
00:10:15,860 --> 00:10:17,490
它更简洁，更具可读性。

249
00:10:17,490 --> 00:10:19,030
因此，大多数人做，而不是。

250
00:10:19,030 --> 00:10:21,840
但是，这是相同的功能，以

251
00:10:21,840 --> 00:10:22,900
我们刚才看到的东西。

252
00:10:22,900 --> 00:10:27,770
因此，在短期，快速修复这里只是说重复我的

253
00:10:27,770 --> 00:10:30,690
从0一路攀升至不到10个。

254
00:10:30,690 --> 00:10:32,700
然后，我们将确实得到10颗星。

255
00:10:32,700 --> 00:10:33,430
>> 所以，让我们来试试这个。

256
00:10:33,430 --> 00:10:35,310
让我打开终端底部。

257
00:10:35,310 --> 00:10:37,420
让我进入的目录，这是英寸

258
00:10:37,420 --> 00:10:40,030
我要手动编译铛现在。

259
00:10:40,030 --> 00:10:44,880
而且我要编译为buggy1.c，输入的。

260
00:10:44,880 --> 00:10:50,280
现在buggy1，为什么没有这样的文件或目录

261
00:10:50,280 --> 00:10:52,026
被称为buggy1？

262
00:10:52,026 --> 00:10:53,850
观众：[听不清]。

263
00:10:53,850 --> 00:10:54,240
DAVID J.马兰：是的。

264
00:10:54,240 --> 00:10:55,420
因此，它实际上是名为a.out。

265
00:10:55,420 --> 00:10:57,480
所以，记得，如果你只是运行铛，铛

266
00:10:57,480 --> 00:11:00,420
编译器，和你没有指定你想要的名称

267
00:11:00,420 --> 00:11:03,550
给你的程序，它会默认为a.out的。

268
00:11:03,550 --> 00:11:05,030
事实上，如果我做LS  - 

269
00:11:05,030 --> 00:11:05,510
哎呀。

270
00:11:05,510 --> 00:11:07,680
我没说 - 黑与白的问题的一些

271
00:11:07,680 --> 00:11:08,840
你所面对的已得到修复。

272
00:11:08,840 --> 00:11:10,670
但是，让我这样做。

273
00:11:10,670 --> 00:11:14,570
在那里，我们有a.out的左侧。

274
00:11:14,570 --> 00:11:17,360
因此，我们必须运行a.out，而不是buggy1。

275
00:11:17,360 --> 00:11:19,140
>> 所以，让我继续这样做。

276
00:11:19,140 --> 00:11:22,840
。/ a.out格式，回车。

277
00:11:22,840 --> 00:11:26,160
而我显然没有做什么呢？

278
00:11:26,160 --> 00:11:26,620
观众：保存。

279
00:11:26,620 --> 00:11:27,390
DAVID J.马兰：我的文件。

280
00:11:27,390 --> 00:11:31,520
所以，很容易通过点击控制S，或去解决

281
00:11:31,520 --> 00:11:33,450
文件，保存，就像在大多数程序中。

282
00:11:33,450 --> 00:11:36,360
让我走在这里，清屏，再次运行它。

283
00:11:36,360 --> 00:11:37,960
仍然是一个错误。

284
00:11:37,960 --> 00:11:41,618
这是怎么回事 - 

285
00:11:41,618 --> 00:11:42,980
观众：你没有编译。

286
00:11:42,980 --> 00:11:44,040
DAVID J.马兰：啊，太好了。

287
00:11:44,040 --> 00:11:45,010
我没有编译它。

288
00:11:45,010 --> 00:11:47,250
像一个白痴，我在看代码，看看什么是错的。

289
00:11:47,250 --> 00:11:51,275
所以的的铛buggy1.c，现在的a.out。

290
00:11:51,275 --> 00:11:52,640
和不快，保存。

291
00:11:52,640 --> 00:11:55,090
>> 因此，它看起来有点难看，因为没有新的生产线

292
00:11:55,090 --> 00:11:55,970
在程序的任何地方。

293
00:11:55,970 --> 00:11:57,390
但同样，这只是一个审美的细节。

294
00:11:57,390 --> 00:11:59,430
至少，如果再算上这些的时候，我们应该

295
00:11:59,430 --> 00:12:01,160
现在看到10个这样的恒星。

296
00:12:01,160 --> 00:12:03,260
那么，关于第二个热身的例子？

297
00:12:03,260 --> 00:12:07,750
所以在buggy2的，我要求这个版本中，也将打印

298
00:12:07,750 --> 00:12:10,110
10颗星，每行一个。

299
00:12:10,110 --> 00:12:12,340
所以这一次，我有一个换行符，只是为了让

300
00:12:12,340 --> 00:12:13,520
事情有点漂亮。

301
00:12:13,520 --> 00:12:15,410
但不是我所得到的是这样的。

302
00:12:15,410 --> 00:12:19,590
因此，让我做铛buggy2.c的，Enter键。

303
00:12:19,590 --> 00:12:21,790
现在，它再次名为a.out。

304
00:12:21,790 --> 00:12:23,130
输入。

305
00:12:23,130 --> 00:12:26,900
我只看到一个新的生产线，只有最后一个新行

306
00:12:26,900 --> 00:12:29,370
我的提示移动到下一行。

307
00:12:29,370 --> 00:12:32,660
，但显然我已经打印*，然后一个新的生产线，

308
00:12:32,660 --> 00:12:33,990
*，然后一个新行。

309
00:12:33,990 --> 00:12:35,490
但是，什么是这里的错误？

310
00:12:35,490 --> 00:12:35,974
是吗？

311
00:12:35,974 --> 00:12:37,224
观众：[听不清]。

312
00:12:39,850 --> 00:12:40,470
>> DAVID J.马兰：没错。

313
00:12:40,470 --> 00:12:44,110
因此，不像有些语言，如Python中，缩进

314
00:12:44,110 --> 00:12:46,030
实际上有功能意义，在

315
00:12:46,030 --> 00:12:47,150
语言，如C  - 

316
00:12:47,150 --> 00:12:49,140
正如我们将看到的，PHP，JavaScript的 - 

317
00:12:49,140 --> 00:12:51,940
的的缩进是真的，只是为了人类的利益。

318
00:12:51,940 --> 00:12:55,690
因此，事实上，我已经缩进了16和17号线看起来不错，

319
00:12:55,690 --> 00:12:57,530
但它没有功能上的意义。

320
00:12:57,530 --> 00:13:00,700
如果我想这两条线执行的一部分，

321
00:13:00,700 --> 00:13:05,140
循环，那么我必须把它们括在大括号内这样做。

322
00:13:05,140 --> 00:13:08,540
你只能砍那个角落，省略了花括号，如果

323
00:13:08,540 --> 00:13:10,036
什么情况下？

324
00:13:10,036 --> 00:13:10,410
观众：只要一行。

325
00:13:10,410 --> 00:13:11,130
DAVID J.马兰：只要一行。

326
00:13:11,130 --> 00:13:15,280
所以，这只是一个很好的排序，排序的语法细节，使

327
00:13:15,280 --> 00:13:17,900
你不要浪费时间写三行，其中两个是

328
00:13:17,900 --> 00:13:20,040
花括号，只是写了一行代码。

329
00:13:20,040 --> 00:13:21,650
但是，如果你有两个或两个以上的线，我们

330
00:13:21,650 --> 00:13:22,860
确实需要做到这一点。

331
00:13:22,860 --> 00:13:24,210
>> 所以，现在让我保存这个。

332
00:13:24,210 --> 00:13:27,140
让我继续前进，重新运行铛。

333
00:13:27,140 --> 00:13:31,375
然后让我重新运行a.out的，现在我让他们每行一个。

334
00:13:31,375 --> 00:13:33,670
现在，a.out格式是怎么样的一个愚蠢的程序名称。

335
00:13:33,670 --> 00:13:37,500
我怎么能告诉锵给我一个文件名

336
00:13:37,500 --> 00:13:39,820
更重要的是用户友好的，像buggy2本身？

337
00:13:43,200 --> 00:13:44,466
一个更清楚一点吗？

338
00:13:44,466 --> 00:13:45,220
观众：[听不清]。

339
00:13:45,220 --> 00:13:47,810
DAVID J.马兰：OK，所以我其实可以采取非常

340
00:13:47,810 --> 00:13:51,000
用户友好的快捷方式，只是写buggy2。

341
00:13:51,000 --> 00:13:53,840
我不指定，C在这种情况下，并按下回车键。

342
00:13:53,840 --> 00:13:58,530
做确实是编译buggy2.c我

343
00:13:58,530 --> 00:14:00,260
问铛做到这一点。

344
00:14:00,260 --> 00:14:05,100
具体而言，它会调用铛铛，它运行使用方式

345
00:14:05,100 --> 00:14:08,540
比我真正需要的命令行参数或开关。

346
00:14:08,540 --> 00:14:11,270
随着时间的推移，我们会回来，所有这些不同的

347
00:14:11,270 --> 00:14:13,810
神秘的连字符号的表达的意思。

348
00:14:13,810 --> 00:14:16,910
但就目前而言，这只是救了我的麻烦

349
00:14:16,910 --> 00:14:19,600
记住，不必输入所有的这些

350
00:14:19,600 --> 00:14:21,150
不同的连字符号的表达。

351
00:14:21,150 --> 00:14:23,240
上攻，最终是

352
00:14:23,240 --> 00:14:25,900
现在我有buggy2。

353
00:14:25,900 --> 00:14:27,480
如果我想做到这一点，不过，我手动

354
00:14:27,480 --> 00:14:28,775
而是可以做到这一点 - 

355
00:14:28,775 --> 00:14:34,110
铛-O buggy2然后buggy2.c的。

356
00:14:34,110 --> 00:14:37,980
这同样给我一个名为buggy2。

357
00:14:37,980 --> 00:14:39,710
>> 因此，在短，铛的编译器。

358
00:14:39,710 --> 00:14:43,080
使仅仅是一个用户友好的工具，我们将使用更多的

359
00:14:43,080 --> 00:14:44,420
多，因为它只是开始

360
00:14:44,420 --> 00:14:47,330
简化对我们的事情。

361
00:14:47,330 --> 00:14:49,430
而我们，最后返回0。

362
00:14:49,430 --> 00:14:51,890
现在，只因为，但我们会开始戏弄的那部分

363
00:14:51,890 --> 00:14:52,930
今日（星期三）。

364
00:14:52,930 --> 00:14:55,560
对任何有任何疑问？

365
00:14:55,560 --> 00:14:56,450
是吗？

366
00:14:56,450 --> 00:14:58,234
观众：[听不清]

367
00:14:58,234 --> 00:15:00,020
LS的报价有吗？

368
00:15:00,020 --> 00:15:01,710
DAVID J.马兰：OK。

369
00:15:01,710 --> 00:15:05,880
当我输入ls命令报价，那是我做了一些神奇的

370
00:15:05,880 --> 00:15:07,160
幕后修复一个bug。

371
00:15:07,160 --> 00:15:09,370
我忘了，好像我们已经告诉你了

372
00:15:09,370 --> 00:15:11,600
讨论板，做的 - 

373
00:15:11,600 --> 00:15:17,220
我们会做到这一点现在 - ：sudo的议案Ÿ更新appliance50，。

374
00:15:17,220 --> 00:15:19,790
哎呀，这拼写正确的。

375
00:15:19,790 --> 00:15:23,240
因此，设备，就像是一个操作系统。

376
00:15:23,240 --> 00:15:25,650
它的运行这个名为Fedora操作系统。

377
00:15:25,650 --> 00:15:27,450
而现在，因为我的Internet连接速度较慢，我已经

378
00:15:27,450 --> 00:15:28,260
真的大清洗。

379
00:15:28,260 --> 00:15:31,620
因此，运行sudo yum更新，我们告诉你做的

380
00:15:31,620 --> 00:15:34,080
习题集，基本上是喜欢跑步的自动更新

381
00:15:34,080 --> 00:15:35,420
在Mac OS或Windows。

382
00:15:35,420 --> 00:15:37,280
和的原因，这在一开始的

383
00:15:37,280 --> 00:15:39,640
问题集，因为当我们创建设备时，我

384
00:15:39,640 --> 00:15:42,480
搞砸了，我不小心让所有的程序看

385
00:15:42,480 --> 00:15:45,210
黑色在黑色屏幕上，这就是为什么你没有看到他们

386
00:15:45,210 --> 00:15:45,860
默认情况下。

387
00:15:45,860 --> 00:15:48,020
但设备的最新版本修复了这一点。

388
00:15:48,020 --> 00:15:50,500
我会解决这个问题在休息，一旦我有上网

389
00:15:50,500 --> 00:15:51,280
连通性。

390
00:15:51,280 --> 00:15:54,630
>> 因此，在报价只是隐藏我的错，非常谨慎，

391
00:15:54,630 --> 00:15:55,730
显然。

392
00:15:55,730 --> 00:15:56,980
其他问题吗？

393
00:15:59,750 --> 00:16:00,668
是吗？

394
00:16:00,668 --> 00:16:02,012
观众：不使来自？

395
00:16:02,012 --> 00:16:03,810
[听不清]

396
00:16:03,810 --> 00:16:04,280
DAVID J.马兰：好问题。

397
00:16:04,280 --> 00:16:05,460
在哪里做从何而来？

398
00:16:05,460 --> 00:16:09,390
这是一个Linux程序已经存在了很多年，长

399
00:16:09,390 --> 00:16:10,570
前CS50。

400
00:16:10,570 --> 00:16:12,930
它配备了如Fedora操作系统。

401
00:16:12,930 --> 00:16:14,830
它不来从CS50库。

402
00:16:14,830 --> 00:16:17,560
事实上，来自CS50库的唯一的东西，

403
00:16:17,560 --> 00:16:20,470
到目前为止，我们已经看到的，是GetString时，调用getInt，所有的

404
00:16:20,470 --> 00:16:25,550
这些获取的功能，以及字字符串，并在一定

405
00:16:25,550 --> 00:16:26,575
程度上，这个词的布尔值。

406
00:16:26,575 --> 00:16:29,180
但是，我们会逗，除了当我们深入到CS50

407
00:16:29,180 --> 00:16:30,580
设备本身。

408
00:16:30,580 --> 00:16:32,820
>> 所以，是的，还有一个问题在这里。

409
00:16:32,820 --> 00:16:36,636
听众：当你说，然后车，请问该怎么

410
00:16:36,636 --> 00:16:39,980
计算机知道[听不清]？

411
00:16:39,980 --> 00:16:40,520
DAVID J.马兰：好问题。

412
00:16:40,520 --> 00:16:43,830
所以，当你只需要运行使buggy1或使buggy2，如何

413
00:16:43,830 --> 00:16:45,220
做知道吗？

414
00:16:45,220 --> 00:16:49,900
因此，默认情况下，如果您键入buggy1，寻找一个

415
00:16:49,900 --> 00:16:52,330
文件名为​​buggy1.c。

416
00:16:52,330 --> 00:16:55,570
然后执行的适当铛命令，

417
00:16:55,570 --> 00:17:00,380
从而覆盖默认的输出文件名为a.out。

418
00:17:00,380 --> 00:17:03,670
事实上，如果我们看一下在做什么 - 

419
00:17:03,670 --> 00:17:04,839
让我们退出。

420
00:17:04,839 --> 00:17:09,530
如果我们看一下实际上是做什么的，让buggy2，

421
00:17:09,530 --> 00:17:10,470
它已经是最新的。

422
00:17:10,470 --> 00:17:13,020
因此，让我的rm命令删除，

423
00:17:13,020 --> 00:17:14,319
程序我以前写的。

424
00:17:14,319 --> 00:17:17,319
键入Y-E-S确认，我想删除它。

425
00:17:17,319 --> 00:17:20,480
如果我现在做，请注意，在这个很长的线，

426
00:17:20,480 --> 00:17:22,980
这最后一件事，在这里：-O buggy2。

427
00:17:22,980 --> 00:17:26,959
所有品牌做的是通过这样的说法，可以这么说，到

428
00:17:26,959 --> 00:17:29,665
铛，我没有自己输入。

429
00:17:29,665 --> 00:17:32,660
>> 好了，所以快速夫妇的行政

430
00:17:32,660 --> 00:17:33,470
公告。

431
00:17:33,470 --> 00:17:36,940
因此，对于部分，从而正式开始了这一未来

432
00:17:36,940 --> 00:17:38,970
周日，你会总是要带上，如果

433
00:17:38,970 --> 00:17:40,120
你有一个，一台笔记本电脑。

434
00:17:40,120 --> 00:17:42,570
如果你没有一台笔记本电脑，也达到了我的

435
00:17:42,570 --> 00:17:43,580
把我丢一封电子邮件。

436
00:17:43,580 --> 00:17:44,810
我们会找出一个工作流程。

437
00:17:44,810 --> 00:17:47,100
一般，你会发现在部分是，他们的一部分

438
00:17:47,100 --> 00:17:48,770
的概念，部分动手。

439
00:17:48,770 --> 00:17:52,190
我们会专门用一节的问题，

440
00:17:52,190 --> 00:17:54,110
本周的问题集，通过一些走

441
00:17:54,110 --> 00:17:55,820
从演讲的概念性材料。

442
00:17:55,820 --> 00:17:57,480
而这一切在目前的习题集。

443
00:17:57,480 --> 00:18:00,010
而且我们还深入到一些实践活动，有时

444
00:18:00,010 --> 00:18:02,190
其中将被要求提交，有时

445
00:18:02,190 --> 00:18:02,830
哪些不会。

446
00:18:02,830 --> 00:18:04,630
例如，第一周，他们注定只是作为一个

447
00:18:04,630 --> 00:18:05,780
热身运动。

448
00:18:05,780 --> 00:18:07,800
你会发现，这些问题真的只是。

449
00:18:07,800 --> 00:18:10,220
这意味着他们是相当小的，但不一定

450
00:18:10,220 --> 00:18:13,100
重要的程序写的，不一定

451
00:18:13,100 --> 00:18:16,230
令人兴奋的和自己，但良好的机会

452
00:18:16,230 --> 00:18:19,620
练习用的语法，新的功能，在一个舒适的

453
00:18:19,620 --> 00:18:21,900
部分，在那里你有几个你的同学表现为

454
00:18:21,900 --> 00:18:22,870
以及您的TF。

455
00:18:22,870 --> 00:18:26,210
>> 随着时间的推移，我们要做的是使用称为CS50空间的工具，

456
00:18:26,210 --> 00:18:28,940
据此，而不是仅仅使用CS50家电，你会

457
00:18:28,940 --> 00:18:32,450
而不是去一个网页在浏览器中，你就可以

458
00:18:32,450 --> 00:18:35,610
在部分编写代码在浏览器窗口。

459
00:18:35,610 --> 00:18:38,240
然后，如果你选择的，你的助教可以显示

460
00:18:38,240 --> 00:18:40,980
不管它是你在你的屏幕在浏览器中输入

461
00:18:40,980 --> 00:18:43,930
窗口在全班同学面前，无论是匿名或

462
00:18:43,930 --> 00:18:47,250
公开，因此，他或她可以步行通过与

463
00:18:47,250 --> 00:18:50,080
你的同学，你做得很好，你没有做的很好。

464
00:18:50,080 --> 00:18:52,750
再次，放心，所有这一切都可以很好匿名。

465
00:18:52,750 --> 00:18:54,410
但是这将是一个很好的机会，让更多的

466
00:18:54,410 --> 00:18:56,810
类似讲座的互动性允许的。

467
00:18:56,810 --> 00:18:58,910
>> 在此期间，我们将这些东西叫做超级

468
00:18:58,910 --> 00:19:01,610
部分，这是可选的，但是是向所有人开放

469
00:19:01,610 --> 00:19:04,030
类的，这样你可以做到这一点更合

470
00:19:04,030 --> 00:19:05,190
问题的设置。

471
00:19:05,190 --> 00:19:06,010
这里的时间表。

472
00:19:06,010 --> 00:19:08,870
这是也发布的网页cs50.net。

473
00:19:08,870 --> 00:19:10,850
请注意，这里是一个黑客特定

474
00:19:10,850 --> 00:19:12,430
明天下午。

475
00:19:12,430 --> 00:19:15,460
我们会拍一个今天和明天，发布者

476
00:19:15,460 --> 00:19:16,720
在24小时内在线。

477
00:19:16,720 --> 00:19:19,370
所以，如果你不能做任何的这些时间，不用担心。

478
00:19:19,370 --> 00:19:22,720
再次，日程安排在线cs50.net。

479
00:19:22,720 --> 00:19:25,350
>> 在切片本身而言，你应该得到一个

480
00:19:25,350 --> 00:19:28,520
电子邮件，指示你去的过程找到的网页

481
00:19:28,520 --> 00:19:29,610
你的部分。

482
00:19:29,610 --> 00:19:32,890
如果生活发生了改变，你需要改变你的部分，

483
00:19:32,890 --> 00:19:33,560
不是一个问题。

484
00:19:33,560 --> 00:19:37,900
返回到相同的URL，cs50.net/section，奇异，

485
00:19:37,900 --> 00:19:40,090
你会填写类似的表格，这样就可以

486
00:19:40,090 --> 00:19:41,260
然后给我们您的喜好。

487
00:19:41,260 --> 00:19:43,360
同时，我们会作出跟进，本周的结束，我们所能

488
00:19:43,360 --> 00:19:44,240
容纳。

489
00:19:44,240 --> 00:19:49,530
上周，记得，我们提出使用CS50讨论的，

490
00:19:49,530 --> 00:19:51,370
该课程的讨论工具，在课堂上。

491
00:19:51,370 --> 00:19:53,680
因此，我们不得不问的40个问题，和

492
00:19:53,680 --> 00:19:54,720
在演讲回答。

493
00:19:54,720 --> 00:19:56,280
因此，它似乎很好地工作，因此，我们将继续

494
00:19:56,280 --> 00:19:57,180
努力做到这一点。

495
00:19:57,180 --> 00:19:59,600
如果您在演讲过程中，不只是感觉很舒服提高

496
00:19:59,600 --> 00:20:00,780
你的手，而不是一个问题。

497
00:20:00,780 --> 00:20:04,640
cs50.net/discuss，张贴在那里，我们的教学

498
00:20:04,640 --> 00:20:07,270
研究员将接听电子或提高

499
00:20:07,270 --> 00:20:10,620
匿名问，这取决于您的名义手

500
00:20:10,620 --> 00:20:12,470
问题的性质。

501
00:20:12,470 --> 00:20:15,000
的反馈，一般的pset会

502
00:20:15,000 --> 00:20:16,760
在一个星期内返回。

503
00:20:16,760 --> 00:20:19,080
因为它需要一小会儿的部分实现

504
00:20:19,080 --> 00:20:22,430
均衡，第一pset中，0和1，将一点点

505
00:20:22,430 --> 00:20:24,130
延迟沉淀下来的东西。

506
00:20:24,130 --> 00:20:27,130
但敬请期待，在未来几周内。

507
00:20:27,130 --> 00:20:29,750
>> 好吧，让我把我严重

508
00:20:29,750 --> 00:20:31,040
只是一瞬间的声音。

509
00:20:31,040 --> 00:20:32,690
因此，这实际上是一个有趣的气候

510
00:20:32,690 --> 00:20:35,210
具有这个讨论中，与所有其他的事情

511
00:20:35,210 --> 00:20:37,310
在校园内与之有关的事情。

512
00:20:37,310 --> 00:20:40,220
但CS50当然有其历史的这个特殊的

513
00:20:40,220 --> 00:20:43,360
主题，每年在尽可能多的，这门课程，对许多人来说

514
00:20:43,360 --> 00:20:46,910
年，广告板之类的大约3％。

515
00:20:46,910 --> 00:20:51,620
最近一年，2011年，CS50广告登上35名学生。

516
00:20:51,620 --> 00:20:54,120
，我想，这是不是由于缺乏明确性。

517
00:20:54,120 --> 00:20:56,760
实现课程的教学大纲中，有一个页面

518
00:20:56,760 --> 00:20:59,020
说明，解释的线条。

519
00:20:59,020 --> 00:21:01,350
重复相同的语句上的每一个

520
00:21:01,350 --> 00:21:03,070
问题设置第一页上。

521
00:21:03,070 --> 00:21:05,760
>> 所以，我今天提到这真的只是为了让

522
00:21:05,760 --> 00:21:07,030
人们重视。

523
00:21:07,030 --> 00:21:08,080
我们已经尝试了不同的东西。

524
00:21:08,080 --> 00:21:10,630
我想，今天我们会做的只是花一点时间来

525
00:21:10,630 --> 00:21:13,830
其实看过去的情况下，已经提出了一些。

526
00:21:13,830 --> 00:21:16,160
而不是让这些肮脏的小秘密，其实

527
00:21:16,160 --> 00:21:19,170
指出学生做了什么，以及我们如何检测

528
00:21:19,170 --> 00:21:21,630
它和真正的首要动机是什么

529
00:21:21,630 --> 00:21:23,950
甚至讨论这个问题。

530
00:21:23,950 --> 00:21:27,060
因此，随着中说，该行基本上是这样的 - 

531
00:21:27,060 --> 00:21:29,200
根据教学大纲，你不客气，你被鼓励，以

532
00:21:29,200 --> 00:21:30,210
与同学交谈。

533
00:21:30,210 --> 00:21:31,910
这就是全部的这些合作的目的

534
00:21:31,910 --> 00:21:34,470
办公时间安嫩伯格和鼓励的人

535
00:21:34,470 --> 00:21:35,755
最后的项目协同工作。

536
00:21:35,755 --> 00:21:38,590
当它来的时候，其实写的，但界线

537
00:21:38,590 --> 00:21:39,790
您的最终解决方案。

538
00:21:39,790 --> 00:21:42,590
说到英语，完全正常，伪代码，

539
00:21:42,590 --> 00:21:43,400
完全罚款。

540
00:21:43,400 --> 00:21:46,340
通过电子邮件发送同学PSET，让他们看

541
00:21:46,340 --> 00:21:48,610
屏幕上的手继续键入，

542
00:21:48,610 --> 00:21:50,110
过线。

543
00:21:50,110 --> 00:21:52,250
不要看教学大纲的特定行。

544
00:21:52,250 --> 00:21:55,850
>> 但为了画一幅画，这是怎么不幸的是

545
00:21:55,850 --> 00:21:58,370
现实中，实现有网站在那里，

546
00:21:58,370 --> 00:22:01,490
有这一类的解决方案和许多其他类。

547
00:22:01,490 --> 00:22:04,940
事实上，你或约3％，你知道这存在

548
00:22:04,940 --> 00:22:07,240
这意味着，我们知道存在的。

549
00:22:07,240 --> 00:22:09,340
事实上，有这样的网站，在那里你

550
00:22:09,340 --> 00:22:11,540
可以花钱找人做你的问题集 - 这是

551
00:22:11,540 --> 00:22:13,450
实际的情况下，来到了去年。

552
00:22:13,450 --> 00:22:15,790
这是一个网站叫做odesk.com。

553
00:22:15,790 --> 00:22:20,090
和TIM的名字是这里的人到底是谁发布

554
00:22:20,090 --> 00:22:24,580
本网站，并要求别人做他的pset 7

555
00:22:24,580 --> 00:22:25,570
这种特殊情况下。

556
00:22:25,570 --> 00:22:28,350
那么，odesk.com是非常谷歌能，我们也没有

557
00:22:28,350 --> 00:22:30,310
在谷歌搜索非常好。

558
00:22:30,310 --> 00:22:32,360
在这里，有网站 - 这是相当

559
00:22:32,360 --> 00:22:34,234
残酷的，坦率地说。

560
00:22:34,234 --> 00:22:38,050
[笑]

561
00:22:38,050 --> 00:22:39,610
DAVID J.马兰：关于本网站的有趣的事情是，如果

562
00:22:39,610 --> 00:22:41,970
你读了“关于”页面，他们谈论他们的企业

563
00:22:41,970 --> 00:22:44,390
文化和客户服务是他们的头号

564
00:22:44,390 --> 00:22:46,190
优先顺序，以确保您的任务获得

565
00:22:46,190 --> 00:22:47,890
开启时间。

566
00:22:47,890 --> 00:22:50,580
>> 再次，但在所有的严重性，事实上，这些网站

567
00:22:50,580 --> 00:22:52,910
存在，实现我们也认识到，

568
00:22:52,910 --> 00:22:53,730
这些类型的站点。

569
00:22:53,730 --> 00:22:55,890
给你什么样的感觉形成一般

570
00:22:55,890 --> 00:22:58,570
需要，我们一般不会有很大的丑闻，人们

571
00:22:58,570 --> 00:23:01,080
任何形式的大规模合作，而是

572
00:23:01,080 --> 00:23:04,540
它的这些弱点，深夜的时刻，你有

573
00:23:04,540 --> 00:23:07,550
很多工作要做，这是上午04点00分，你累了，和你

574
00:23:07,550 --> 00:23:09,770
心里对自己说，好吧，让我来看看我的

575
00:23:09,770 --> 00:23:11,770
室友或朋友的代码等。

576
00:23:11,770 --> 00:23:14,800
的表现，这不幸的是涉及学生

577
00:23:14,800 --> 00:23:17,640
像这样的学生B一起提交一个提交的东西

578
00:23:17,640 --> 00:23:20,370
这样的事情，其中​​肯定的是，在一台电脑

579
00:23:20,370 --> 00:23:23,830
理科类，是非常简单的计算机科学家

580
00:23:23,830 --> 00:23:25,690
检测软件。

581
00:23:25,690 --> 00:23:28,410
这是另一种常见的范例，在那里，你

582
00:23:28,410 --> 00:23:31,010
一起工作的人，也许说

583
00:23:31,010 --> 00:23:32,360
英语，就好了，伪代码。

584
00:23:32,360 --> 00:23:35,080
但后来它的时候，实际提交，pset时

585
00:23:35,080 --> 00:23:37,910
刚刚获得通过电子邮件或Dropbox或类似的交换。

586
00:23:37,910 --> 00:23:41,120
但是，在不那么明显，这是企图使

587
00:23:41,120 --> 00:23:44,830
发生了什么事，那么这就是提交的。

588
00:23:44,830 --> 00:23:47,880
这也是，不跳闸，写得很好件

589
00:23:47,880 --> 00:23:50,360
之类的软件，我们必须实际检测

590
00:23:50,360 --> 00:23:51,280
这些各种各样的东西。

591
00:23:51,280 --> 00:23:53,760
事实上，我们要做的是运行的软件比较所有

592
00:23:53,760 --> 00:23:55,540
今年提交的文件对过去一年的

593
00:23:55,540 --> 00:23:57,380
意见书，反对一切我们发现在

594
00:23:57,380 --> 00:24:00,060
互联网，在那里对每一个招聘网站。

595
00:24:00,060 --> 00:24:01,710
这一切都非常自动化。

596
00:24:01,710 --> 00:24:05,665
因此，我们这样做真的很大公正的97％的

597
00:24:05,665 --> 00:24:07,760
真正的工作在这方面和其他的驴

598
00:24:07,760 --> 00:24:11,530
类，并把所有的努力，使工作

599
00:24:11,530 --> 00:24:13,030
他们最终提交的是自己。

600
00:24:13,030 --> 00:24:14,220
我可以去的年龄。

601
00:24:14,220 --> 00:24:16,030
>> 去年的情况下，只是极少数。

602
00:24:16,030 --> 00:24:19,350
一些学生提交的这些文件相同的pset 2，

603
00:24:19,350 --> 00:24:22,460
pset中3，PSET 4，6，PSET 9 5，PSET的pset。

604
00:24:22,460 --> 00:24:26,360
在这种情况下，这是竞猜0并在去年，其中两个

605
00:24:26,360 --> 00:24:29,570
学生提交相同的这句话在许多

606
00:24:29,570 --> 00:24:32,210
其他“类型的请求 - ”点，点，点。

607
00:24:32,210 --> 00:24:34,530
因此，即使在一类600，我们发现这

608
00:24:34,530 --> 00:24:36,310
对提交的测验。

609
00:24:36,310 --> 00:24:39,080
因此，在短期，这 - 坦率地说，我讨厌这种

610
00:24:39,080 --> 00:24:41,300
谈话 - 但是这的确是一个刻意

611
00:24:41,300 --> 00:24:43,540
今年尽量压低这个数字。

612
00:24:43,540 --> 00:24:45,650
因为即使我们说这些事情每

613
00:24:45,650 --> 00:24:48,100
今年，我觉得现实有得住就可以了几个

614
00:24:48,100 --> 00:24:50,800
比平常多秒，其实只是指出

615
00:24:50,800 --> 00:24:53,600
，看起来可能，嗯，没有什么大不了的，至少

616
00:24:53,600 --> 00:24:56,390
回想起这个特殊的时刻，无论是在公平性

617
00:24:56,390 --> 00:25:00,100
你自己和你的同学在这里。

618
00:25:00,100 --> 00:25:02,480
所以，如果你有任何问题就行了

619
00:25:02,480 --> 00:25:04,290
，请伸出手，就我个人。

620
00:25:04,290 --> 00:25:07,190
但是我的回答永远是，完全强调，

621
00:25:07,190 --> 00:25:09,090
最后一分钟，在晚一天的现金。

622
00:25:09,090 --> 00:25:11,080
或者，如果这是一个问题，没有任何迟交天数，

623
00:25:11,080 --> 00:25:12,900
说实话，亲自给我发电子邮件。

624
00:25:12,900 --> 00:25:14,110
我们会想出一些东西。

625
00:25:14,110 --> 00:25:17,480
请不要把你的时间在哈佛的风险。

626
00:25:17,480 --> 00:25:18,570
>> 现在，我想我们应该减轻情绪，所以我

627
00:25:18,570 --> 00:25:20,264
包括下一张幻灯片。

628
00:25:20,264 --> 00:25:22,770
[笑]

629
00:25:22,770 --> 00:25:23,630
DAVID J.马兰：此网站是伟大的。

630
00:25:23,630 --> 00:25:24,820
事实上，我有点心烦意乱。

631
00:25:24,820 --> 00:25:26,330
有这一个。

632
00:25:26,330 --> 00:25:29,590
那么这个人是惊人的。

633
00:25:29,590 --> 00:25:35,190
好了，所以想到，小猫在深夜时，

634
00:25:35,190 --> 00:25:36,040
这些决定。

635
00:25:36,040 --> 00:25:40,110
好，那么更多的乐趣和不太严重的东西，比如

636
00:25:40,110 --> 00:25:40,780
条件。

637
00:25:40,780 --> 00:25:43,900
>> 好，那么我们短暂交谈，了解这些。

638
00:25:43,900 --> 00:25:46,080
这是这可能是相当熟悉的

639
00:25:46,080 --> 00:25:47,260
从头开始的世界。

640
00:25:47,260 --> 00:25:49,860
在世界上的划痕，我们有这方面的需要，有时

641
00:25:49,860 --> 00:25:51,110
去岔路。

642
00:25:51,110 --> 00:25:54,840
可以这样做或这样或那样的东西在这里。

643
00:25:54,840 --> 00:25:58,990
而当我们要做到这一点，我们就可以使用，在C，这一点，如果

644
00:25:58,990 --> 00:26:00,860
else结构。

645
00:26:00,860 --> 00:26:06,420
那么在这里我们有布尔表达式。

646
00:26:06,420 --> 00:26:09,260
例如，布尔表达式在这里，我们可以或

647
00:26:09,260 --> 00:26:12,260
他们在一起，在这个意义上，我们有这个条件，或

648
00:26:12,260 --> 00:26:13,200
这一条件。

649
00:26:13,200 --> 00:26:15,100
我们可以和他们一起，在这个意义上，我们要

650
00:26:15,100 --> 00:26:17,710
检查此条件，但该条件。

651
00:26:17,710 --> 00:26:22,440
在这里，我们有一个switch语句，这是不那么

652
00:26:22,440 --> 00:26:26,040
类似的语法上的那些种条件，但它

653
00:26:26,040 --> 00:26:30,160
允许我们这样做相当于，如果，如​​果，如​​果，否则，

654
00:26:30,160 --> 00:26:34,990
如果，并通过简单地枚举他们个案等

655
00:26:34,990 --> 00:26:36,670
由个案。

656
00:26:36,670 --> 00:26:38,370
于是，我们看到了这些最​​后的时间。

657
00:26:38,370 --> 00:26:40,430
然后我们就开始接触后，循环类的东西。

658
00:26:40,430 --> 00:26:42,070
我们刚才看到其中一个。

659
00:26:42,070 --> 00:26:44,180
但也有其他循环结构。

660
00:26:44,180 --> 00:26:46,370
>> 比如，这一个在这里。

661
00:26:46,370 --> 00:26:50,140
因此，虽然（条件），一次又一次地做这件事情。

662
00:26:50,140 --> 00:26:53,070
因此，从根本上说，这之间似乎是不同的

663
00:26:53,070 --> 00:26:55,760
这里for循环，这个while循环？

664
00:27:00,810 --> 00:27:05,045
这for循环，这个while循环。

665
00:27:05,045 --> 00:27:07,840
是吗？

666
00:27:07,840 --> 00:27:08,800
那是什么？

667
00:27:08,800 --> 00:27:10,050
观众：[听不清]。

668
00:27:14,632 --> 00:27:15,120
DAVID J.马兰：好。

669
00:27:15,120 --> 00:27:17,130
而在循环条件，显然有

670
00:27:17,130 --> 00:27:17,940
更多的语法。

671
00:27:17,940 --> 00:27:20,560
有这样的初始化，此更新。

672
00:27:20,560 --> 00:27:23,820
在while循环中，只是有这个条件。

673
00:27:23,820 --> 00:27:26,630
如此看来，这是一个有点缩减兑

674
00:27:26,630 --> 00:27:28,770
循环，这意味着如果我们希望有变量，我们希望

675
00:27:28,770 --> 00:27:30,800
有递增，我们实际上有

676
00:27:30,800 --> 00:27:32,500
我们自己做这件事情。

677
00:27:32,500 --> 00:27:34,420
>> 所以，让我去进取，不断开拓gedit的。

678
00:27:34,420 --> 00:27:36,320
让我切换到设备。

679
00:27:36,320 --> 00:27:38,110
让我们做一个快速的小例子，

680
00:27:38,110 --> 00:27:40,550
区别之一从其他。

681
00:27:40,550 --> 00:27:42,490
在我的脑海，我应该说的一件事。

682
00:27:42,490 --> 00:27:44,120
我特别提到了名添。

683
00:27:44,120 --> 00:27:47,740
蒂姆是确实有人，有学生试图找到做

684
00:27:47,740 --> 00:27:48,680
他们为他们的功课。

685
00:27:48,680 --> 00:27:51,280
我们没有添在特定的部分。

686
00:27:51,280 --> 00:27:53,690
因此，实现好，免得我透露一个学生，是不是学生。

687
00:27:53,690 --> 00:27:55,720
这是一个素不相识的人在互联网上做的事情

688
00:27:55,720 --> 00:27:57,180
由代理在去年。

689
00:27:57,180 --> 00:27:58,670
因此我们发现了。

690
00:27:58,670 --> 00:28:00,630
因此，在这种情况下，在这里，让我继续前进，

691
00:28:00,630 --> 00:28:02,810
打开一个新的文件。

692
00:28:02,810 --> 00:28:04,800
文件，新建。

693
00:28:04,800 --> 00:28:06,050
这给了我一个标签。

694
00:28:06,050 --> 00:28:09,940
让我继续前进，将其保存为loop.c.

695
00:28:09,940 --> 00:28:11,810
让我走，单击“保存”。

696
00:28:11,810 --> 00:28:15,340
那么在这里，让我们继续前进，并开始写

697
00:28:15,340 --> 00:28:16,605
等级。

698
00:28:19,116 --> 00:28:20,520
让我放大。

699
00:28:20,520 --> 00:28:23,410
现在，我们要做的诠释主要（无效）。

700
00:28:23,410 --> 00:28:30,020
现在，让我继续做（INT I = 0;

701
00:28:30,020 --> 00:28:33,480
哦，我+ +）。

702
00:28:33,480 --> 00:28:36,620
现在我要继续做打印的明星，我

703
00:28:36,620 --> 00:28:37,890
前面所做的那样。

704
00:28:37,890 --> 00:28:39,390
然后在课程结束后，我们只是要

705
00:28:39,390 --> 00:28:41,130
打印新的生产线，只是让我的提示

706
00:28:41,130 --> 00:28:42,470
不看所有的凌乱。

707
00:28:42,470 --> 00:28:45,170
返回0。

708
00:28:45,170 --> 00:28:47,610
似乎语法上是正确的吗？

709
00:28:47,610 --> 00:28:48,040
到目前为止。

710
00:28:48,040 --> 00:28:48,560
所以，让我们来看看。

711
00:28:48,560 --> 00:28:51,290
>> 因此，让我放大了，进入我的终端窗口。

712
00:28:51,290 --> 00:28:54,570
让我继续运行循环，因为我把这个

713
00:28:54,570 --> 00:28:55,690
事情loop.c.

714
00:28:55,690 --> 00:28:56,780
所以循环。

715
00:28:56,780 --> 00:28:57,840
似乎编译OK。

716
00:28:57,840 --> 00:29:00,210
让我跑环，现在输入。

717
00:29:00,210 --> 00:29:01,820
它似乎已经印刷了10位明星。

718
00:29:01,820 --> 00:29:03,780
因此，让我们将它转​​换为一个while循环，看看有什么

719
00:29:03,780 --> 00:29:05,220
种问题，我们绊倒。

720
00:29:05,220 --> 00:29:11,290
因此，而不是这个，让我就在这里说，而我是

721
00:29:11,290 --> 00:29:12,760
小于10  - 

722
00:29:12,760 --> 00:29:14,910
让我摆脱的for循环。

723
00:29:14,910 --> 00:29:17,170
好了，我们已经有一对夫妇的问题。

724
00:29:17,170 --> 00:29:21,110
因此，条件是相同的，但我明显缺失

725
00:29:21,110 --> 00:29:21,680
初始化。

726
00:29:21,680 --> 00:29:23,840
我错过了递增。

727
00:29:23,840 --> 00:29:28,020
那么应该怎样编译器可能会告诉我，当我尝试

728
00:29:28,020 --> 00:29:29,170
编译这个程序？

729
00:29:29,170 --> 00:29:29,666
是吗？

730
00:29:29,666 --> 00:29:31,154
观众：[听不清]。

731
00:29:31,154 --> 00:29:31,650
>> DAVID J.马兰：好。

732
00:29:31,650 --> 00:29:34,180
因此，它会说类似未申报 - 在这种

733
00:29:34,180 --> 00:29:35,280
在这种情况下，变量。

734
00:29:35,280 --> 00:29:37,980
事实上，使用未声明的标识符我。

735
00:29:37,980 --> 00:29:40,960
所以这是在对比的语言，如PHP，

736
00:29:40,960 --> 00:29:43,120
Python和Ruby，有些人可能是熟悉的，

737
00:29:43,120 --> 00:29:44,820
在那里你可以开始使用一种变量

738
00:29:44,820 --> 00:29:47,420
不管三七二十一，而不必担心有关声明

739
00:29:47,420 --> 00:29:48,560
明确的始终。

740
00:29:48,560 --> 00:29:51,770
在C语言如Java和C + +，你必须要

741
00:29:51,770 --> 00:29:53,020
超明确。

742
00:29:53,020 --> 00:29:55,760
如果你要一个变量叫我，你一定要告诉我

743
00:29:55,760 --> 00:29:57,360
它是什么类型的变量。

744
00:29:57,360 --> 00:29:59,360
因此，我们要解决这个问题如下。

745
00:29:59,360 --> 00:30:05,510
我要在这里输入INT I，因此，

746
00:30:05,510 --> 00:30:07,860
我声明了一个变量叫我。

747
00:30:07,860 --> 00:30:09,180
现在，我已经跳过一个步骤。

748
00:30:09,180 --> 00:30:11,340
我显然没有初始化它，但让我们看看，在

749
00:30:11,340 --> 00:30:13,650
品牌铛停止抱怨。

750
00:30:13,650 --> 00:30:15,770
因此，让我重新制作这个节目。

751
00:30:15,770 --> 00:30:16,770
>> 好了，现在它只是抱怨

752
00:30:16,770 --> 00:30:17,870
出于不同的原因。

753
00:30:17,870 --> 00:30:21,130
“变数”我未初始化的时候用在这里。“好，那么

754
00:30:21,130 --> 00:30:22,340
这是非常清楚的。

755
00:30:22,340 --> 00:30:25,510
初始化设置它的值等于。

756
00:30:25,510 --> 00:30:30,820
我们还没有这样做，所以让我来试试等于0。

757
00:30:30,820 --> 00:30:35,030
现在，让我们再试一次，然后重新运行铛。

758
00:30:35,030 --> 00:30:36,140
编译时间。

759
00:30:36,140 --> 00:30:37,210
我运行它。

760
00:30:37,210 --> 00:30:43,120
但是又大又老的无限循环，因为我已经做了

761
00:30:43,120 --> 00:30:45,530
初始化时，我已经做了的情况，但我从来没有做过

762
00:30:45,530 --> 00:30:47,030
任何形式的递增。

763
00:30:47,030 --> 00:30:48,780
那么，我该怎么办递增？

764
00:30:48,780 --> 00:30:51,170
那么，在一个while循环，那感觉就像我要去有

765
00:30:51,170 --> 00:30:54,180
做它的内部循环，因为非常类似于第一个

766
00:30:54,180 --> 00:30:56,570
本周的的做循环结构的例子，如与

767
00:30:56,570 --> 00:30:59,040
袜子和计数，我们不得不这样做

768
00:30:59,040 --> 00:31:01,550
在最后的东西，想回去到下一行。

769
00:31:01,550 --> 00:31:05,040
如果我继续做这个，我+ +吗？

770
00:31:05,040 --> 00:31:06,030
让我们甚至不能编译这个。

771
00:31:06,030 --> 00:31:06,890
赶上我了。

772
00:31:06,890 --> 00:31:09,704
什么是错的吗？

773
00:31:09,704 --> 00:31:10,690
观众：[听不清]。

774
00:31:10,690 --> 00:31:11,770
>> DAVID J.马兰：这绝对不是整数。

775
00:31:11,770 --> 00:31:13,080
这是我。

776
00:31:13,080 --> 00:31:15,110
和花括号，像以前一样，

777
00:31:15,110 --> 00:31:16,800
缩进是不够的。

778
00:31:16,800 --> 00:31:18,410
所以，现在我有这个。

779
00:31:18,410 --> 00:31:21,780
因此，虽然我是小于10，打印的明星，

780
00:31:21,780 --> 00:31:23,220
然后递增。

781
00:31:23,220 --> 00:31:25,680
的方式，而循环的作品，只要你打的

782
00:31:25,680 --> 00:31:29,630
底部的循环，在这种情况下，看起来像10行，

783
00:31:29,630 --> 00:31:32,880
它会回到6号线，在这一点上，

784
00:31:32,880 --> 00:31:34,400
条件将被再次审核。

785
00:31:34,400 --> 00:31:37,500
，如果我仍然低于10，我们会做8号线和

786
00:31:37,500 --> 00:31:41,250
然后按9，然后我们会打10，并返回至6，再和

787
00:31:41,250 --> 00:31:45,580
一遍又一遍，这样，只要i小于10。

788
00:31:45,580 --> 00:31:47,860
因此，让我们重新运行。

789
00:31:47,860 --> 00:31:48,940
>> 好了，我们已经编制了还好。

790
00:31:48,940 --> 00:31:50,300
让我重新运行循环。

791
00:31:50,300 --> 00:31:52,620
现在它实际上似乎工作。

792
00:31:52,620 --> 00:31:55,100
所以，这里的长处和短处？

793
00:31:55,100 --> 00:31:58,910
嗯，到目前为止，有其实并没有一个整体的巴解组织 - 

794
00:31:58,910 --> 00:31:59,420
太可爱了。

795
00:31:59,420 --> 00:32:01,870
所有的权利，这是一个 - 啊，那是个意外。

796
00:32:01,870 --> 00:32:05,200
好吧，让我们回到for循环。

797
00:32:05,200 --> 00:32:07,530
因此，for循环是不错的，因为他们是超级明确。

798
00:32:07,530 --> 00:32:09,720
即使他们写的是一个有点笨拙，这是

799
00:32:09,720 --> 00:32:11,500
非常强大，它可以让你做

800
00:32:11,500 --> 00:32:12,980
多件事情。

801
00:32:12,980 --> 00:32:16,240
While循环不似乎有一个巨大的量的值

802
00:32:16,240 --> 00:32:18,500
然而，因为它感觉就像是我们必须做更多的工作。

803
00:32:18,500 --> 00:32:20,670
我们必须把初始化在这里，

804
00:32:20,670 --> 00:32:23,480
更新在这里，我们要记住做的一切。

805
00:32:23,480 --> 00:32:26,260
因此，我们会看到在while循环的时间，实际上是借

806
00:32:26,260 --> 00:32:29,380
只是不同的背景，不同的数据

807
00:32:29,380 --> 00:32:33,900
列表和哈希表等结构的事，我们会得到

808
00:32:33,900 --> 00:32:34,970
学期中。

809
00:32:34,970 --> 00:32:37,900
但现在，知道有这第三类被称为一个做

810
00:32:37,900 --> 00:32:38,480
while循环。

811
00:32:38,480 --> 00:32:39,540
我们已经看到了这个简单。

812
00:32:39,540 --> 00:32:41,830
这可能是超级有帮助的pset 1。

813
00:32:41,830 --> 00:32:45,570
任何时候你想要做的事，然后检查

814
00:32:45,570 --> 00:32:48,940
用户合作，如果他们没有，再这样做，一做，

815
00:32:48,940 --> 00:32:51,460
while循环适合自己的那种逻辑。

816
00:32:51,460 --> 00:32:55,640
因为作为从顶部到底部的顺序在这里表明，

817
00:32:55,640 --> 00:32:57,750
“的字面意思是”做到这一点。

818
00:32:57,750 --> 00:32:59,830
一次又一次的做到这一点，可能是什么？

819
00:32:59,830 --> 00:33:03,000
也许这意味着调用getInt或GetString和

820
00:33:03,000 --> 00:33:05,830
调用getInt或GetString的检查值，然后大呼小叫

821
00:33:05,830 --> 00:33:08,260
在用户，如果他们没有要求他们合作，

822
00:33:08,260 --> 00:33:10,100
再次，一遍又一遍。

823
00:33:10,100 --> 00:33:11,730
如果您想要做的事一次，

824
00:33:11,730 --> 00:33:13,210
然后检查一些条件。

825
00:33:13,210 --> 00:33:14,110
>> 所以，让我们来试试这个。

826
00:33:14,110 --> 00:33:17,130
让我真正改变现在到do-whil​​e循环。

827
00:33:17,130 --> 00:33:18,830
我要继续前进并执行以下操作。

828
00:33:18,830 --> 00:33:21,830
因此，请执行以下操作。

829
00:33:21,830 --> 00:33:26,870
让我们做INT I =调用getInt（），但让我们先告诉用户

830
00:33:26,870 --> 00:33:27,410
该怎么做。

831
00:33:27,410 --> 00:33:29,050
有那么一点点不同，这一次。

832
00:33:29,050 --> 00:33:31,270
“给我一个int”。

833
00:33:31,270 --> 00:33:32,910
所以，我会使用printf。

834
00:33:32,910 --> 00:33:35,740
现在我来这儿的，我要做到这一点

835
00:33:35,740 --> 00:33:41,520
而我，比方说，大于 - 

836
00:33:41,520 --> 00:33:47,540
让我们来看看，我是，让我们说，小于0，或I

837
00:33:47,540 --> 00:33:48,730
大于10。

838
00:33:48,730 --> 00:33:51,810
换句话说，我想一个数字从1到9，只

839
00:33:51,810 --> 00:33:52,720
随意。

840
00:33:52,720 --> 00:33:55,290
所以，我使用的是组合布尔表达式，这里

841
00:33:55,290 --> 00:33:59,930
确保i是小于0或大于10时，在其中

842
00:33:59,930 --> 00:34:02,530
情况下，我会在这里做这个循环。

843
00:34:02,530 --> 00:34:04,400
所以，再一次，做到这一点 - 

844
00:34:04,400 --> 00:34:08,480
而i是小于0或i是大于10。

845
00:34:08,480 --> 00:34:11,440
>> 现在让我们继续前进，做到这一点，一旦我们做到了这一点。

846
00:34:11,440 --> 00:34:13,270
让我们做一个快速的完整性检查。

847
00:34:13,270 --> 00:34:18,929
printf（“请谢谢你，我是％d”，I）。

848
00:34:18,929 --> 00:34:21,350
因此，这个简单的程序要求用户类型为int的，

849
00:34:21,350 --> 00:34:24,000
确保是在一定范围内，1至9，

850
00:34:24,000 --> 00:34:26,280
感谢用户，提醒他们什么，他们只是

851
00:34:26,280 --> 00:34:27,940
输入的，只是作为一个小的完整性检查。

852
00:34:27,940 --> 00:34:30,659
但是，让我们来看看，如果这个工程预期​​。

853
00:34:30,659 --> 00:34:34,533
让我去低着头，并重新运行make循环。

854
00:34:34,533 --> 00:34:35,350
嗯。

855
00:34:35,350 --> 00:34:38,600
“使用未声明的标识符'我'”。这很奇怪。

856
00:34:38,600 --> 00:34:41,509
我想，我们议决。

857
00:34:45,489 --> 00:34:47,560
相同的症状，但不同的代码。

858
00:34:47,560 --> 00:34:47,899
是吗？

859
00:34:47,899 --> 00:34:50,191
观众：[听不清]里面的两个，我们必须

860
00:34:50,191 --> 00:34:52,639
[听不清]。

861
00:34:52,639 --> 00:34:53,260
>> DAVID J.马兰：没错。

862
00:34:53,260 --> 00:34:55,989
因此，这实际上导致我们的主题被称为范围。

863
00:34:55,989 --> 00:34:59,350
原来，C，再次，它真的需要你从字面上。

864
00:34:59,350 --> 00:35:02,970
如果你做这样的事情，你声明一个int

865
00:35:02,970 --> 00:35:06,120
然后将其分配一定的价值，但你这样做，里面的

866
00:35:06,120 --> 00:35:09,840
一对花括号，什么C也就是它假设你

867
00:35:09,840 --> 00:35:14,800
只希望知道，因为我存在于那些32位

868
00:35:14,800 --> 00:35:18,200
这些花括号的情况下，行范围内

869
00:35:18,200 --> 00:35:22,420
6至9。所以我宣布，它被赋予一个

870
00:35:22,420 --> 00:35:26,530
在第8行，但只要你以外的

871
00:35:26,530 --> 00:35:30,270
9号线以下的花括号，我不再是

872
00:35:30,270 --> 00:35:31,910
范围，可以这么说。

873
00:35:31,910 --> 00:35:35,030
S-C-O-P-E。它不再是在正确的上下文。

874
00:35:35,030 --> 00:35:37,940
所以，现在有没有我，所以，虽然我们甚至没有

875
00:35:37,940 --> 00:35:38,770
宣布它在所有。

876
00:35:38,770 --> 00:35:41,520
>> 那么，什么是修复这样的事情，如果

877
00:35:41,520 --> 00:35:44,300
原因是，我花括号内声明的，

878
00:35:44,300 --> 00:35:45,120
显然是坏？

879
00:35:45,120 --> 00:35:45,410
在这里吗？

880
00:35:45,410 --> 00:35:46,820
观众：[听不清]。

881
00:35:46,820 --> 00:35:47,150
DAVID J.马兰：是的。

882
00:35:47,150 --> 00:35:48,710
因此，我们可以初始化外面。

883
00:35:48,710 --> 00:35:53,530
因此，让我继续和删除的声明部分，

884
00:35:53,530 --> 00:35:55,820
我指定的类型，并让我在这里做起来。

885
00:35:55,820 --> 00:36:00,220
因此，在第5行，现在说“给我一个int。”我呼叫它。

886
00:36:00,220 --> 00:36:03,400
请注意，在第9行，我并不想这样做，因为我

887
00:36:03,400 --> 00:36:04,830
已经有32位。

888
00:36:04,830 --> 00:36:06,140
我不想问电脑中

889
00:36:06,140 --> 00:36:07,630
不同的32比特。

890
00:36:07,630 --> 00:36:09,850
我想使用相同的32位。

891
00:36:09,850 --> 00:36:13,190
而现在，因为我是第5行中宣布，它仍然是合法的

892
00:36:13,190 --> 00:36:16,550
使用它在第11行和第12行。

893
00:36:16,550 --> 00:36:19,310
>> 因此，让我尝试重新编译，看看

894
00:36:19,310 --> 00:36:20,490
如果铛停止叫喊。

895
00:36:20,490 --> 00:36:22,380
使循环。

896
00:36:22,380 --> 00:36:25,470
因此，现在是“隐式声明函数

897
00:36:25,470 --> 00:36:29,880
调用getInt“在C99是无效的。”那是什么？“

898
00:36:29,880 --> 00:36:30,400
是吗？

899
00:36:30,400 --> 00:36:32,330
观众：[听不清]。

900
00:36:32,330 --> 00:36:32,690
DAVID J.马兰：是的。

901
00:36:32,690 --> 00:36:35,520
所以，现在，我实际使用的调用getInt，这是不是

902
00:36:35,520 --> 00:36:38,190
这只是配备了C.这是来自CS50。

903
00:36:38,190 --> 00:36:39,890
因此，我们需要在这里。

904
00:36:39,890 --> 00:36:41,450
让我回去的迅速下降

905
00:36:41,450 --> 00:36:43,500
在这里，重新运行。

906
00:36:43,500 --> 00:36:44,160
好了，终于。

907
00:36:44,160 --> 00:36:46,270
现在我们已经解决了，其它的错误。

908
00:36:46,270 --> 00:36:48,930
让我跑去循环，并看看会发生什么。

909
00:36:48,930 --> 00:36:51,740
“给我一个int。”我给它11。

910
00:36:51,740 --> 00:36:53,100
我给它-1。

911
00:36:53,100 --> 00:36:54,470
我给它富。

912
00:36:54,470 --> 00:36:56,080
我给它5。

913
00:36:56,080 --> 00:36:57,450
而现在，它确实工作的。

914
00:36:57,450 --> 00:36:59,410
但提示改变的原因就在这里。

915
00:36:59,410 --> 00:37:02,800
为什么说重试这些时间，但给我一个

916
00:37:02,800 --> 00:37:03,920
int的三倍吗？

917
00:37:03,920 --> 00:37:05,500
这是为什么行为有什么不同？

918
00:37:05,500 --> 00:37:06,980
听众：给它一个字符串。

919
00:37:06,980 --> 00:37:07,830
DAVID J.马兰：你说什么？

920
00:37:07,830 --> 00:37:08,570
观众：你给它一个字符串。

921
00:37:08,570 --> 00:37:08,990
DAVID J.马兰：是的。

922
00:37:08,990 --> 00:37:11,450
所以我们给它一个字符串在这第三次尝试，

923
00:37:11,450 --> 00:37:12,490
当我输入foo的。

924
00:37:12,490 --> 00:37:13,200
foo是一个字符串。

925
00:37:13,200 --> 00:37:14,340
这显然​​不是一个int。

926
00:37:14,340 --> 00:37:17,500
CS50已实施的方式调用getInt的是，我们

927
00:37:17,500 --> 00:37:20,330
不检查，如果事情是小于0或大于10

928
00:37:20,330 --> 00:37:22,260
你，因为我们该如何提前知道什么样的

929
00:37:22,260 --> 00:37:23,130
int的你要吗？

930
00:37:23,130 --> 00:37:25,880
最低限度，但我们可以检查你的，没用户至少

931
00:37:25,880 --> 00:37:26,730
输入一个整数？

932
00:37:26,730 --> 00:37:30,500
如果他们没有，我们喊在用户键入“重试”

933
00:37:30,500 --> 00:37:31,440
在屏幕上。

934
00:37:31,440 --> 00:37:34,210
>> 所以，现在我们有一个程序的循环。好吧。

935
00:37:34,210 --> 00:37:37,070
现在，这是一种更好的结构？

936
00:37:37,070 --> 00:37:39,060
因此，这是事情开始变得有些混乱，

937
00:37:39,060 --> 00:37:42,360
事实上，你一定要记住在这里声明一个变量

938
00:37:42,360 --> 00:37:44,630
如果你想使用它里面的一些

939
00:37:44,630 --> 00:37:46,460
花括号外。

940
00:37:46,460 --> 00:37:48,490
但是，即使这看起来有点神秘

941
00:37:48,490 --> 00:37:50,750
一目了然，只是，记得简单的逻辑。

942
00:37:50,750 --> 00:37:54,630
为了使用任何C，它是否是一个函数或

943
00:37:54,630 --> 00:37:57,680
它是一个变量，你必须包括它，如果它是一个函数

944
00:37:57,680 --> 00:37:59,770
在一些图书馆，或者你需要声明它。

945
00:37:59,770 --> 00:38:02,405
但现在你需要额外注意的事实，

946
00:38:02,405 --> 00:38:04,940
你宣布它在正确的范围内。

947
00:38:04,940 --> 00:38:08,150
你不把它得紧紧的括号内。

948
00:38:08,150 --> 00:38:09,410
>> 所以，让我真正回滚。

949
00:38:09,410 --> 00:38:12,660
如果我们回到我们的例子前面的内容，和我一起去

950
00:38:12,660 --> 00:38:19,245
为int i = 0; <10; i + +，和我

951
00:38:19,245 --> 00:38:26,370
做printf的明星，这样，然后关闭括号，现在

952
00:38:26,370 --> 00:38:30,410
printf的，我是现在 - 

953
00:38:30,410 --> 00:38:33,500
根据同样的逻辑，会发生什么事，当我尝试

954
00:38:33,500 --> 00:38:35,500
编译这个程序？

955
00:38:35,500 --> 00:38:36,790
观众：无效的标识符。

956
00:38:36,790 --> 00:38:38,560
DAVID J.马兰：这是另一种无效的标识符，

957
00:38:38,560 --> 00:38:39,470
未声明的标识符。

958
00:38:39,470 --> 00:38:41,810
现在，原因是有一点不同。

959
00:38:41,810 --> 00:38:44,370
这里显然没有花括号，但同样

960
00:38:44,370 --> 00:38:46,790
的想法，同样的故事，适用范围。

961
00:38:46,790 --> 00:38:50,340
如果你像我声明了一个变量内的

962
00:38:50,340 --> 00:38:53,960
循环，即使你没有明确的书面的花

963
00:38:53,960 --> 00:38:56,980
括号，认为他们在精神上仍然存在，在

964
00:38:56,980 --> 00:39:00,310
情况下，我是唯一有效的内部循环。

965
00:39:00,310 --> 00:39:03,080
它是无效的，一旦你到下一行，这

966
00:39:03,080 --> 00:39:05,090
这种情况下，现在是10。

967
00:39:05,090 --> 00:39:09,060
因此，只要几个问题的范围之类。

968
00:39:09,060 --> 00:39:12,620
好吧，什么问题吗？

969
00:39:12,620 --> 00:39:15,310
>> 正确的，所以这是一个简单的小程序，

970
00:39:15,310 --> 00:39:17,450
打印小星星。

971
00:39:17,450 --> 00:39:20,400
但是，让我们来看看，如果你还记得这首歌。

972
00:39:20,400 --> 00:39:22,530
这是一个令人难以置信的讨厌的歌曲，孩子们会唱

973
00:39:22,530 --> 00:39:23,550
校车等。

974
00:39:23,550 --> 00:39:25,990
但好处是，它有这样的周期性，

975
00:39:25,990 --> 00:39:27,910
据此，它的“99瓶啤酒在墙壁上，

976
00:39:27,910 --> 00:39:28,520
99瓶啤酒。

977
00:39:28,520 --> 00:39:31,030
拿一个，通过它，98瓶啤酒

978
00:39:31,030 --> 00:39:34,330
墙上。“的歌曲，然后重复97，然后96，然后

979
00:39:34,330 --> 00:39:38,040
95，94，一路下降到0，如果你真的得到了，

980
00:39:38,040 --> 00:39:38,920
远在总线上。

981
00:39:38,920 --> 00:39:41,960
因此，这是一个很好的方案的实施进行排序，因为我的

982
00:39:41,960 --> 00:39:43,650
上帝，如果你可以只实施这几个

983
00:39:43,650 --> 00:39:46,660
行代码，你可以吐出这整个歌词

984
00:39:46,660 --> 00:39:48,240
歌曲相当快。

985
00:39:48,240 --> 00:39:50,420
但前进的道路上，我们现在就可以开始梳理除了一些

986
00:39:50,420 --> 00:39:52,460
这些基本的循环结构，现在也

987
00:39:52,460 --> 00:39:55,830
介绍，我们写自己的函数，返回值

988
00:39:55,830 --> 00:39:57,020
我们通过左右。

989
00:39:57,020 --> 00:39:58,910
但是，第一，为什么我们不继续前进，并采取我们的五分钟

990
00:39:58,910 --> 00:39:59,320
在这里休息一下吗？

991
00:39:59,320 --> 00:40:01,480
当我们回来时，我们会唱这首歌。

992
00:40:05,680 --> 00:40:08,760
>> 好了，所以我们又回来了。

993
00:40:08,760 --> 00:40:11,850
我说，我们现在唱这首歌时，我的意思是

994
00:40:11,850 --> 00:40:13,250
通过编程，而不是口头上。

995
00:40:13,250 --> 00:40:19,370
所以在这里我们beer1.c，这是一个实现

996
00:40:19,370 --> 00:40:20,580
特别的歌。

997
00:40:20,580 --> 00:40:23,110
而仅仅是明确的，对于那些不熟悉

998
00:40:23,110 --> 00:40:24,460
这件事情的样子，让我继续

999
00:40:24,460 --> 00:40:27,070
使beer1，回车。

1000
00:40:27,070 --> 00:40:30,400
现在让我跑beer1，我们会看到什么 - 有多少瓶

1001
00:40:30,400 --> 00:40:31,140
啤酒有吗？

1002
00:40:31,140 --> 00:40:33,240
我会输入99，喜欢的歌。

1003
00:40:33,240 --> 00:40:34,040
输入。

1004
00:40:34,040 --> 00:40:35,650
现在，如果我们通过滚动 - 

1005
00:40:35,650 --> 00:40:38,280
很抱歉 - 如果滚动通过这一切，我们会看到，

1006
00:40:38,280 --> 00:40:41,350
这确实唱整首歌曲。

1007
00:40:44,050 --> 00:40:44,540
等待一分钟。

1008
00:40:44,540 --> 00:40:46,240
我的滚动条有点乱。

1009
00:40:46,240 --> 00:40:47,940
让我们用更大的窗口。

1010
00:40:47,940 --> 00:40:53,500
因此，beer1，99，我们走吧。

1011
00:40:53,500 --> 00:40:56,420
所以在这里我们唱整首歌曲，更快，

1012
00:40:56,420 --> 00:40:58,450
计算机，它可能是我们。

1013
00:40:58,450 --> 00:41:00,340
所以注意到，虽然，这里的周期性质。

1014
00:41:00,340 --> 00:41:03,380
它说99，然后99，然后拿一个下来，通过它

1015
00:41:03,380 --> 00:41:04,740
围绕“98。

1016
00:41:04,740 --> 00:41:06,640
现在，它重复了一次又一次。

1017
00:41:06,640 --> 00:41:08,840
>> 因此，这实际上是一个绝好的机会某种

1018
00:41:08,840 --> 00:41:10,400
循环结构。

1019
00:41:10,400 --> 00:41:12,950
请注意，我这里种切割一个角落。

1020
00:41:12,950 --> 00:41:15,960
请注意，我说：“在墙壁上的98瓶啤酒，

1021
00:41:15,960 --> 00:41:19,010
在墙壁上，97瓶啤酒“，这仅仅是

1022
00:41:19,010 --> 00:41:21,640
当我们得到一个瓶啤酒，我没有

1023
00:41:21,640 --> 00:41:23,300
担心的英语语法。

1024
00:41:23,300 --> 00:41:25,790
但我们也可以解决这个问题的，如果一点点

1025
00:41:25,790 --> 00:41:26,910
的情况下，也许。

1026
00:41:26,910 --> 00:41:30,110
如果这个数字是单数，继续说：“瓶子”，

1027
00:41:30,110 --> 00:41:31,840
否则，如果它是多元的，说：“瓶”。

1028
00:41:31,840 --> 00:41:34,150
但现在，我完全切断那个角落。

1029
00:41:34,150 --> 00:41:35,520
因此，让我们来看看我们有什么。

1030
00:41:35,520 --> 00:41:37,150
因此，我们在上面已经得到了一些意见。

1031
00:41:37,150 --> 00:41:39,450
我包括这两个库，

1032
00:41:39,450 --> 00:41:41,140
我们已经普遍了。

1033
00:41:41,140 --> 00:41:43,610
现在让我向下滚动到第一

1034
00:41:43,610 --> 00:41:44,990
实际的代码行。

1035
00:41:44,990 --> 00:41:47,020
第17行揭开序幕主。

1036
00:41:47,020 --> 00:41:50,610
21和20号线将有多少瓶啤酒？

1037
00:41:50,610 --> 00:41:52,060
然后调用调用getInt。

1038
00:41:52,060 --> 00:41:53,800
现在我有一个位的完整性检查。

1039
00:41:53,800 --> 00:41:57,030
>> 因此，这是一个约定，我们现在将开始采用

1040
00:41:57,030 --> 00:41:59,620
更严格检查用户的输入。

1041
00:41:59,620 --> 00:42:01,710
有时候，你只是不希望促使他们再次

1042
00:42:01,710 --> 00:42:02,630
一遍又一遍。

1043
00:42:02,630 --> 00:42:05,620
如果用户螺钉和不配合，挺好的。

1044
00:42:05,620 --> 00:42:07,430
退出，只是不处理。

1045
00:42:07,430 --> 00:42:08,990
所以这是我在这里做什么。

1046
00:42:08,990 --> 00:42:12,520
如果n是小于1的，我只是骂的用户，

1047
00:42:12,520 --> 00:42:14,330
“对不起，这是没有意义的。”然后我去

1048
00:42:14,330 --> 00:42:16,650
随意返回1。

1049
00:42:16,650 --> 00:42:18,550
所以，再一次，这仅仅是一个惯例习惯。

1050
00:42:18,550 --> 00:42:19,850
现在，只要相信。

1051
00:42:19,850 --> 00:42:22,700
但到现在为止，我们一直返回0，因为

1052
00:42:22,700 --> 00:42:25,204
我们说过的话返回0表示什么呢？

1053
00:42:25,204 --> 00:42:26,000
观众：成功。

1054
00:42:26,000 --> 00:42:27,320
DAVID J.马兰：成功，仅此而已。

1055
00:42:27,320 --> 00:42:29,740
所以，现在我们终于开始思考

1056
00:42:29,740 --> 00:42:31,330
非成功 - 

1057
00:42:31,330 --> 00:42:33,760
换句话说，角的情况下，错误条件 - 

1058
00:42:33,760 --> 00:42:37,520
现在我有一个无限供给，或至少四个亿

1059
00:42:37,520 --> 00:42:39,790
可能的事情，可以去在我的程序错误。

1060
00:42:39,790 --> 00:42:42,300
我就可以开始给他们分配单独的数字。

1061
00:42:42,300 --> 00:42:44,340
现在，一般就足够了刚刚返回

1062
00:42:44,340 --> 00:42:45,730
0以外的东西。

1063
00:42:45,730 --> 00:42:48,040
因此，我们现在简单地返回1。

1064
00:42:48,040 --> 00:42:51,440
但是，返回1的原因是，一旦你返回

1065
00:42:51,440 --> 00:42:55,110
1，你猜对其余的程序会发生什么情况？

1066
00:42:55,110 --> 00:42:55,720
它停止。

1067
00:42:55,720 --> 00:42:56,560
就是这样。

1068
00:42:56,560 --> 00:42:59,150
因此，事实上，我返回1是有效的

1069
00:42:59,150 --> 00:43:02,950
短路这个程序的执行，使

1070
00:43:02,950 --> 00:43:06,780
第27行以下将继续执行。

1071
00:43:06,780 --> 00:43:09,210
一旦作为主要的回报，就是它了。

1072
00:43:09,210 --> 00:43:13,160
>> 所有权利，因此，如果用户合作，我们到达第30行

1073
00:43:13,160 --> 00:43:15,680
因为他们中键入一个合法的号码，这是我的

1074
00:43:15,680 --> 00:43:16,990
这首歌的实施。

1075
00:43:16,990 --> 00:43:19,050
所以，我第一次打印一个换行符，只为

1076
00:43:19,050 --> 00:43:19,880
美学。

1077
00:43:19,880 --> 00:43:21,500
我现在有一个for循环。

1078
00:43:21,500 --> 00:43:22,930
请注意，我做的事情位

1079
00:43:22,930 --> 00:43:23,880
不同的方向。

1080
00:43:23,880 --> 00:43:26,210
我没有想得多做得少，我没有做+ +。

1081
00:43:26,210 --> 00:43:30,660
相反，我可以说初始化变量i，它设置为等于

1082
00:43:30,660 --> 00:43:35,080
N，用户输入的数量，然后执行以下操作，所以

1083
00:43:35,080 --> 00:43:39,590
只要我是大于0的，然后我 - 

1084
00:43:39,590 --> 00:43:42,070
一旦你完成了这个循环的一次迭代。

1085
00:43:42,070 --> 00:43:44,310
因此，我们可以使用for循环倒计时为好。

1086
00:43:44,310 --> 00:43:47,520
现在，这是相当多星期的东西现在，用printf。

1087
00:43:47,520 --> 00:43:51,770
因此，打印“％d的啤酒瓶在墙上。”打印“％d

1088
00:43:51,770 --> 00:43:54,990
瓶啤酒。“”拿一个下来，传递它。“打印

1089
00:43:54,990 --> 00:43:58,880
“％d个啤酒瓶在墙上。”因此，它仍然是％d，但

1090
00:43:58,880 --> 00:44:02,770
注意的参数printf是不断变化的。

1091
00:44:02,770 --> 00:44:05,840
在逗号后面，我有我的，因为我想说的是99。

1092
00:44:05,840 --> 00:44:08,590
这个逗号后，我有我的，因为我想说的是99。

1093
00:44:08,590 --> 00:44:14,030
这个逗号后，我有我 -  1，因为我想说98

1094
00:44:14,030 --> 00:44:16,260
这第一次迭代中，等等。

1095
00:44:16,260 --> 00:44:18,520
现在在这里，我只是有一些鸡毛蒜皮的话。

1096
00:44:18,520 --> 00:44:22,270
然后第42行，返回0，按照惯例，表示

1097
00:44:22,270 --> 00:44:23,650
一切都正常。

1098
00:44:23,650 --> 00:44:24,490
>> 那么，如果我弄错了吗？

1099
00:44:24,490 --> 00:44:26,350
一个常见的​​错误是什么？

1100
00:44:26,350 --> 00:44:29,200
那么，如果我不小心说好了，我要算

1101
00:44:29,200 --> 00:44:31,640
下降到0，我想0的啤酒瓶在墙上吗？

1102
00:44:31,640 --> 00:44:34,620
所以我说，我是大于或等于0。

1103
00:44:34,620 --> 00:44:38,920
这是怎么回事，是我现在的症状看，如果我重新编译

1104
00:44:38,920 --> 00:44:41,173
beer1并运行它呢？

1105
00:44:41,173 --> 00:44:42,120
观众：阴性。

1106
00:44:42,120 --> 00:44:43,590
DAVID J.马兰：是的，这是要去负。

1107
00:44:43,590 --> 00:44:45,950
这是一个令人难以置信的一个off-by-one错误，

1108
00:44:45,950 --> 00:44:47,270
常见的错误。

1109
00:44:47,270 --> 00:44:48,960
让我们回到终端窗口

1110
00:44:48,960 --> 00:44:50,620
在这里，所以我们可以看到更多的时间。

1111
00:44:50,620 --> 00:44:53,280
输入，99瓶啤酒。

1112
00:44:53,280 --> 00:44:56,580
关闭，但我们就非常轻微太远。

1113
00:44:56,580 --> 00:45:00,500
我们唱的歌曲太远了，这样，我们现在打的

1114
00:45:00,500 --> 00:45:01,510
负数。

1115
00:45:01,510 --> 00:45:03,680
因此，它不是那么回事。

1116
00:45:03,680 --> 00:45:06,450
>> 好了，这样我们就可以很容易地解决这个问题，回去

1117
00:45:06,450 --> 00:45:07,650
它曾经是。

1118
00:45:07,650 --> 00:45:10,360
但有一些机会

1119
00:45:10,360 --> 00:45:11,190
改善？

1120
00:45:11,190 --> 00:45:17,200
好吧，让我们我打开beer2.c，向下滚动这里，并采取

1121
00:45:17,200 --> 00:45:19,310
看看这个版本。

1122
00:45:19,310 --> 00:45:21,370
什么跳出来的第一件事情就是在你为不同的

1123
00:45:21,370 --> 00:45:23,715
在这个版本在这里？

1124
00:45:23,715 --> 00:45:24,190
观众：[听不清]。

1125
00:45:24,190 --> 00:45:26,510
DAVID J.马兰：是的，所以没有更多的我，是因为它发生在

1126
00:45:26,510 --> 00:45:29,350
我说你知道什么，我询问用户的n，然后我

1127
00:45:29,350 --> 00:45:33,580
设定i等于n，然后我改变了我，但我从来没有

1128
00:45:33,580 --> 00:45:34,590
接触N键。

1129
00:45:34,590 --> 00:45:37,390
那么到底什么是你点的分配另外32个

1130
00:45:37,390 --> 00:45:45,210
位叫我，这样我可以有一个不同的变量？

1131
00:45:45,210 --> 00:45:47,960
因此，在这种情况下，我认识到不必要的

1132
00:45:47,960 --> 00:45:49,190
设计功能。

1133
00:45:49,190 --> 00:45:52,730
我现在去说，而n是大于0的，去

1134
00:45:52,730 --> 00:45:56,180
进行打印同一首歌，通过一个n的printf的

1135
00:45:56,180 --> 00:46:00,210
第二个参数，N  -  1，第二个参数在这里。

1136
00:46:00,210 --> 00:46:02,930
然后在这个循环的每次迭代，继续前进，只是

1137
00:46:02,930 --> 00:46:05,080
减n本身。

1138
00:46:05,080 --> 00:46:06,960
现在，在功能上，这个方案

1139
00:46:06,960 --> 00:46:08,010
会是相同的。

1140
00:46:08,010 --> 00:46:10,730
如果我输入99，正开始在99。

1141
00:46:10,730 --> 00:46:12,890
我递减，递减，递减，递减。

1142
00:46:12,890 --> 00:46:15,875
我要一路下调至“一瓶啤酒

1143
00:46:15,875 --> 00:46:16,740
在墙上，一瓶啤酒。

1144
00:46:16,740 --> 00:46:18,020
拿一个，到处传递。

1145
00:46:18,020 --> 00:46:21,480
0的啤酒瓶在墙上。“结束，因为我做

1146
00:46:21,480 --> 00:46:23,200
得到正确的条件。

1147
00:46:23,200 --> 00:46:24,280
这是大于0。

1148
00:46:24,280 --> 00:46:26,220
我没有犯这样的错误。

1149
00:46:26,220 --> 00:46:28,470
>> 因此，这是更好的，版本1或版本2？

1150
00:46:31,380 --> 00:46:33,480
所以，我听到了一堆怨言了两个。

1151
00:46:33,480 --> 00:46:34,730
为什么是两个呢？

1152
00:46:37,210 --> 00:46:38,225
那是什么？

1153
00:46:38,225 --> 00:46:39,215
观众：[听不清]。

1154
00:46:39,215 --> 00:46:40,070
DAVID J.马兰：哦，好吧。

1155
00:46:40,070 --> 00:46:42,870
因此，它不会低于0，但要记住，在一个版本，

1156
00:46:42,870 --> 00:46:45,870
原来正确的版本不低于0或者去。

1157
00:46:45,870 --> 00:46:48,340
所以请记住，这是正确的版本。

1158
00:46:48,340 --> 00:46:51,630
因此，让我们至少比较正确的版本。

1159
00:46:51,630 --> 00:46:53,300
什么是赞成的版本的参数

1160
00:46:53,300 --> 00:46:55,146
两个分别是，嗯，更好的吗？

1161
00:46:55,146 --> 00:46:55,642
是吗？

1162
00:46:55,642 --> 00:46:57,630
观众：它使用较少的空间。

1163
00:46:57,630 --> 00:46:59,530
DAVID J.马兰：好了，所以它使用更少的空间，对不对？

1164
00:46:59,530 --> 00:47:02,900
而使用一个版本的32位为n，然后又

1165
00:47:02,900 --> 00:47:07,680
32位我。

1166
00:47:07,680 --> 00:47:10,060
版本只使用32位为n，所以

1167
00:47:10,060 --> 00:47:11,700
似乎是一个加号。

1168
00:47:11,700 --> 00:47:12,950
其他的想法？

1169
00:47:18,070 --> 00:47:21,520
有谁不想争辩赞成，1？

1170
00:47:21,520 --> 00:47:22,070
是吗？

1171
00:47:22,070 --> 00:47:25,240
观众：你必须使用额外的代码为n  - 。

1172
00:47:25,240 --> 00:47:26,090
>> DAVID J.马兰：好，确保万无一失。

1173
00:47:26,090 --> 00:47:26,960
所以这是公平的。

1174
00:47:26,960 --> 00:47:29,040
所以这只不过是，至少对我来说 - 

1175
00:47:29,040 --> 00:47:31,940
我的意思是，这其实感觉稍微复杂一些，但事实上，

1176
00:47:31,940 --> 00:47:35,120
我不能在一个封装了所有我的逻辑排序

1177
00:47:35,120 --> 00:47:38,030
线条美，for循环，for循环可以。

1178
00:47:38,030 --> 00:47:40,240
在这里，我有钉在这n  - 

1179
00:47:40,240 --> 00:47:41,120
在循环结束时，由于

1180
00:47:41,120 --> 00:47:42,550
它的必然逻辑。

1181
00:47:42,550 --> 00:47:45,190
但它种磨我走错了路，只是因为它

1182
00:47:45,190 --> 00:47:48,260
似乎从这里的逻辑分开，即使

1183
00:47:48,260 --> 00:47:49,430
再次，它是必要的。

1184
00:47:49,430 --> 00:47:50,990
其他的想法？

1185
00:47:50,990 --> 00:47:51,490
是吗？

1186
00:47:51,490 --> 00:47:52,740
观众：[听不清]。

1187
00:47:57,990 --> 00:47:58,350
>> DAVID J.马兰：是的。

1188
00:47:58,350 --> 00:48:00,730
那么，如果你去，在结尾的歌曲，希望

1189
00:48:00,730 --> 00:48:02,950
再次打印出这首歌的名字吗？

1190
00:48:02,950 --> 00:48:05,660
打了99瓶啤酒，如“谢谢”，或者什么

1191
00:48:05,660 --> 00:48:06,690
这样的傻吗？

1192
00:48:06,690 --> 00:48:09,750
但问题是，你想进入到原来的值。

1193
00:48:09,750 --> 00:48:13,180
事实上，你已经突变或改变n在每

1194
00:48:13,180 --> 00:48:16,330
迭代，因此破坏了其原有的价值

1195
00:48:16,330 --> 00:48:18,650
意味着你不能做到这一点底。

1196
00:48:18,650 --> 00:48:20,660
可以说，现在，我们可以清楚地不想要做的

1197
00:48:20,660 --> 00:48:21,450
，在这种方案。

1198
00:48:21,450 --> 00:48:22,350
那么，谁在乎呢？

1199
00:48:22,350 --> 00:48:23,630
但是，这是一个非常有效的一点。

1200
00:48:23,630 --> 00:48:25,520
而且说实话，现在真的是没有人

1201
00:48:25,520 --> 00:48:26,630
正确的答案。

1202
00:48:26,630 --> 00:48:28,740
他们两个人都同样正确。

1203
00:48:28,740 --> 00:48:30,210
我可以确信无论哪种方式。

1204
00:48:30,210 --> 00:48:33,310
我会说，在一般情况下，这是一个很好的原则，如果你

1205
00:48:33,310 --> 00:48:36,030
要求用户为某个值，并且将存储在变量

1206
00:48:36,030 --> 00:48:38,730
如N，只是有点原则上，它可能是好

1207
00:48:38,730 --> 00:48:40,160
保持周围。

1208
00:48:40,160 --> 00:48:43,400
和任何你想要的数据变异，一遍又一遍，

1209
00:48:43,400 --> 00:48:46,030
给自己一个该变量的副本，只是让你

1210
00:48:46,030 --> 00:48:47,830
有机会到原来的。

1211
00:48:47,830 --> 00:48:51,040
你花32位，但现实的情况是这样的

1212
00:48:51,040 --> 00:48:53,490
电脑，喜欢，2 GB的RAM，这些天，

1213
00:48:53,490 --> 00:48:55,310
我们纠缠了32位？

1214
00:48:55,310 --> 00:48:56,320
真的不是什么大不了的。

1215
00:48:56,320 --> 00:48:58,550
甚至在此设备，用半的演出或

1216
00:48:58,550 --> 00:49:01,700
千兆字节的RAM，32位和64位，

1217
00:49:01,700 --> 00:49:02,920
没有什么大不了的。

1218
00:49:02,920 --> 00:49:05,890
当然，今天，这将是不堪重负的大小的方法

1219
00:49:05,890 --> 00:49:08,400
程序本身，这将是几百

1220
00:49:08,400 --> 00:49:10,890
千字节，如果不是几百兆，这些天。

1221
00:49:10,890 --> 00:49:13,550
>> 因此，合理的关切，没有一个正确的答案。

1222
00:49:13,550 --> 00:49:15,490
但至少这些都是想法，应该开始

1223
00:49:15,490 --> 00:49:16,790
经过你的头脑吗？

1224
00:49:16,790 --> 00:49:19,600
由于在pset中0，即使我们真的只有预期

1225
00:49:19,600 --> 00:49:22,340
正确性，或者至少是否认的各种错误，

1226
00:49:22,340 --> 00:49:25,440
你可能也遇到过，因为我们向前迈进，设计

1227
00:49:25,440 --> 00:49:27,910
将是另一个重要方面，编写代码

1228
00:49:27,910 --> 00:49:29,770
也是我们的评估代码。

1229
00:49:29,770 --> 00:49:32,310
因此，至少给想这样的事情。

1230
00:49:32,310 --> 00:49:35,590
只是因为一些作品，并不意味着它的好，

1231
00:49:35,590 --> 00:49:37,130
并不意味着它的精心设计。

1232
00:49:37,130 --> 00:49:38,820
而那是一个的教学研究员的东西，

1233
00:49:38,820 --> 00:49:41,990
问题集将帮助我们逗随着时间的推移。

1234
00:49:41,990 --> 00:49:45,020
>> 好了，怎么样，让我们​​说，这个版本吗？

1235
00:49:45,020 --> 00:49:49,090
让我做的东西一点点性感这里的时刻。

1236
00:49:49,090 --> 00:49:50,740
首先，让我摆脱这一点。

1237
00:49:50,740 --> 00:49:54,120
现在让我们来解决这个语法问题。

1238
00:49:54,120 --> 00:49:58,780
所以，我想在这个版本中修复的语法，所以，

1239
00:49:58,780 --> 00:50:02,460
而不是仅仅说括号中的S，如“瓶”

1240
00:50:02,460 --> 00:50:03,360
或“瓶” - 

1241
00:50:03,360 --> 00:50:04,900
我不想砍那个角落 - 

1242
00:50:04,900 --> 00:50:08,350
我也想动态地打印出来的字“瓶”

1243
00:50:08,350 --> 00:50:12,820
“瓶”，从而利用这些％S占位符。

1244
00:50:12,820 --> 00:50:16,550
所以，我需要有条件地检查i的值是什么。

1245
00:50:16,550 --> 00:50:19,590
如果是1，我想说的“瓶”，而如果它的任何东西

1246
00:50:19,590 --> 00:50:23,115
否则，我想说的“瓶”。因此，让我们尝试这样做。

1247
00:50:23,115 --> 00:50:31,340
所以，如果我== 1，然后就让我去，并宣布 - 

1248
00:50:31,340 --> 00:50:34,080
我需要一个字符串，所以让我做字符串s1，因为它是

1249
00:50:34,080 --> 00:50:36,070
第一个字符串我只关心现在。

1250
00:50:36,070 --> 00:50:40,980
我会说：“瓶子”。然后，让我们来看看，串

1251
00:50:40,980 --> 00:50:43,110
S2  - ，我将解释我要去的地方在一个时刻 - 

1252
00:50:43,110 --> 00:50:47,650
“瓶”。所以记得，在这首歌中，我们需要能够

1253
00:50:47,650 --> 00:50:50,580
打印的东西，两个不同的词可能。

1254
00:50:50,580 --> 00:50:53,590
因此，如果我们回头看看在这里要注意的是，当我们到达

1255
00:50:53,590 --> 00:50:56,440
这个例子在这里，“两瓶啤酒在墙壁上，

1256
00:50:56,440 --> 00:50:59,490
两瓶啤酒，一跌，通过它，我想

1257
00:50:59,490 --> 00:51:02,380
这第四行说：“一瓶啤酒

1258
00:51:02,380 --> 00:51:04,900
墙“，所以我需要决定，我想说的”瓶“

1259
00:51:04,900 --> 00:51:07,780
“瓶”吗？所以，我要武断地说，没事的，

1260
00:51:07,780 --> 00:51:10,530
我现在宣布一个名为S1的变量，字符串

1261
00:51:10,530 --> 00:51:13,830
一，要插在这里和这里，

1262
00:51:13,830 --> 00:51:16,070
因为这些话都是相同的，只是因为

1263
00:51:16,070 --> 00:51:17,290
歌曲的性质。

1264
00:51:17,290 --> 00:51:20,100
我现在就打电话给S2的话，我想

1265
00:51:20,100 --> 00:51:21,560
最终会出现在这里。

1266
00:51:21,560 --> 00:51:25,530
现在，从字面上看，满分100分的99倍，它的将是

1267
00:51:25,530 --> 00:51:28,820
在这种情况下，因为是复数，2

1268
00:51:28,820 --> 00:51:30,200
复数，4个是复数。

1269
00:51:30,200 --> 00:51:34,640
但在这个角落里的情况下，我们得到为2，然后按1，或

1270
00:51:34,640 --> 00:51:37,250
即使是1和0，我需要这样的逻辑。

1271
00:51:37,250 --> 00:51:41,020
所以，我必须花一些时间在我理解的正确的代码。

1272
00:51:41,020 --> 00:51:47,530
所以，如果我这样做，如果我== 1，则集合S1等于“瓶”

1273
00:51:47,530 --> 00:51:52,010
和S2等于“瓶”，因为这将是1

1274
00:51:52,010 --> 00:51:56,340
瓶，而这将是0瓶。

1275
00:51:56,340 --> 00:51:58,250
而这里，这是什么代表什么呢？

1276
00:51:58,250 --> 00:51:59,780
只要是明确的。

1277
00:51:59,780 --> 00:52:00,620
这仅仅是一个评论。

1278
00:52:00,620 --> 00:52:03,730
因此，事实上，你可以有单行注释意味着你

1279
00:52:03,730 --> 00:52:06,110
注释你的代码，但另一种常见的

1280
00:52:06,110 --> 00:52:09,050
范例，也就是如果你有一个超级短的短语，

1281
00:52:09,050 --> 00:52:11,410
你想要把自己和它只是更具可读性，把

1282
00:52:11,410 --> 00:52:13,270
正确的代码行的末尾，你可以

1283
00:52:13,270 --> 00:52:15,230
绝对做这样的事情。

1284
00:52:15,230 --> 00:52:20,150
>> 所以，现在如果我这样做呢？否则，如果i不等于1。

1285
00:52:20,150 --> 00:52:21,620
因此，砰等于 - 

1286
00:52:21,620 --> 00:52:23,150
被称为“砰”的惊叹号。

1287
00:52:23,150 --> 00:52:25,080
因此，砰= 1。

1288
00:52:25,080 --> 00:52:28,530
所以，如果我是不等于1，什么我不是想这样做吗？

1289
00:52:28,530 --> 00:52:31,700
那么，第一个字我要的是什么吗？

1290
00:52:34,620 --> 00:52:40,030
因此，字符串1用于多瓶“瓶”，

1291
00:52:40,030 --> 00:52:42,440
那么这将是复数的“瓶”为好，现在。

1292
00:52:42,440 --> 00:52:43,800
我们来看看这实际上是让我们

1293
00:52:43,800 --> 00:52:44,870
我们想要去的地方。

1294
00:52:44,870 --> 00:52:47,680
所以，现在如果我在这里向下滚动，请注意，我堵在

1295
00:52:47,680 --> 00:52:50,170
不仅是我，但S1。

1296
00:52:50,170 --> 00:52:51,860
我堵在我和S1。

1297
00:52:51,860 --> 00:52:54,440
然后向下这里，我减1，这是相同的

1298
00:52:54,440 --> 00:52:55,920
之前，但s2的。

1299
00:52:55,920 --> 00:52:58,730
换句话说，我想改变基础的英文单词

1300
00:52:58,730 --> 00:52:59,930
这个逻辑。

1301
00:52:59,930 --> 00:53:03,310
现在，已经有一些在这段代码中的问题。

1302
00:53:03,310 --> 00:53:08,460
什么是已经出了门坏了吗？

1303
00:53:08,460 --> 00:53:10,796
是吗？

1304
00:53:10,796 --> 00:53:13,210
观众：[听不清]。

1305
00:53:13,210 --> 00:53:13,800
>> DAVID J.马兰：没错。

1306
00:53:13,800 --> 00:53:16,030
所以，我已经侵犯范围的教训。

1307
00:53:16,030 --> 00:53:19,610
所以，我宣布s1和s2，但我已经做了它里面的

1308
00:53:19,610 --> 00:53:22,980
花括号，里面是啊，这段代码将工作

1309
00:53:22,980 --> 00:53:27,430
直到第42行，但只要我打43号线，你猜怎么没有

1310
00:53:27,430 --> 00:53:28,900
不再存在？

1311
00:53:28,900 --> 00:53:32,600
好了，你猜怎么着不再在范围 - 既不s1或s2。

1312
00:53:32,600 --> 00:53:33,780
因此，我们必须解决这个问题。

1313
00:53:33,780 --> 00:53:36,180
因此，让我删除的声明。

1314
00:53:36,180 --> 00:53:39,320
我会离开的变量名，这里删除

1315
00:53:39,320 --> 00:53:40,120
并删除在这里。

1316
00:53:40,120 --> 00:53:43,557
在什么线我真的应该声明这些东西吗？

1317
00:53:43,557 --> 00:53:44,960
观众：[听不清]。

1318
00:53:44,960 --> 00:53:45,410
DAVID J.马兰：是啊，所以可能

1319
00:53:45,410 --> 00:53:46,850
在这里，直到33上下的。

1320
00:53:46,850 --> 00:53:50,670
因此，字符串s1和字符串s2。

1321
00:53:50,670 --> 00:53:51,950
而事实证明，我可以做到这一点。

1322
00:53:51,950 --> 00:53:54,260
如果你声明了两个变量相同类型的，

1323
00:53:54,260 --> 00:53:57,420
实际上，你可以只用一个逗号和做到这一点。所有

1324
00:53:57,420 --> 00:53:58,970
正确的，所以我现在有两个变量 - 

1325
00:53:58,970 --> 00:53:59,860
s1和s2。

1326
00:53:59,860 --> 00:54:02,000
我给他们分配这些值

1327
00:54:02,000 --> 00:54:04,210
条件在这里，或者在这里。

1328
00:54:04,210 --> 00:54:06,690
然后我使用了下面。

1329
00:54:06,690 --> 00:54:10,960
如何以及现在去上班？

1330
00:54:10,960 --> 00:54:12,740
>> 那么，它仍然是一个小马车，但至少让我们看到

1331
00:54:12,740 --> 00:54:13,730
有多远，我们已经得到了。

1332
00:54:13,730 --> 00:54:16,500
所以，让我继续，并beer3的。

1333
00:54:16,500 --> 00:54:17,695
是这beer3吗？

1334
00:54:17,695 --> 00:54:19,410
是的，这是beer3。

1335
00:54:19,410 --> 00:54:21,510
现在让我们我继续运行beer3的。

1336
00:54:21,510 --> 00:54:23,820
399 99。

1337
00:54:23,820 --> 00:54:25,840
我们可以跳过其中的大多数。

1338
00:54:25,840 --> 00:54:29,100
在这里，你看那个。

1339
00:54:29,100 --> 00:54:31,110
“在墙壁上一瓶啤酒，一瓶啤酒，

1340
00:54:31,110 --> 00:54:34,306
一跌，通过它周围，啤酒瓶在墙上。“

1341
00:54:34,306 --> 00:54:37,570
但我提请你注意，只有一半的解决方案。

1342
00:54:37,570 --> 00:54:39,620
类搞砸了这里。

1343
00:54:39,620 --> 00:54:43,030
因此，它似乎角落的情况下出现时，我等于什么

1344
00:54:43,030 --> 00:54:44,030
两个值吗？

1345
00:54:44,030 --> 00:54:45,020
观众：1。

1346
00:54:45,020 --> 00:54:46,190
DAVID J.马兰：2和1。

1347
00:54:46,190 --> 00:54:48,180
这是不为1，而不是1。

1348
00:54:48,180 --> 00:54:51,890
这真的只是这些这首歌曲的最后两段。

1349
00:54:51,890 --> 00:54:53,890
那么，什么我不是想要做什么？

1350
00:54:53,890 --> 00:54:58,890
因此，我似乎已经陷入的情况下，如果我是== 1，

1351
00:54:58,890 --> 00:55:02,240
那么第一个字是“瓶”，但第二个字

1352
00:55:02,240 --> 00:55:07,230
“瓶”。但在这里，我想改变这是== 2。

1353
00:55:07,230 --> 00:55:08,570
而如果是这样的话，我该怎么想的

1354
00:55:08,570 --> 00:55:09,620
第一个字是什么？

1355
00:55:09,620 --> 00:55:10,430
观众：“瓶”。

1356
00:55:10,430 --> 00:55:12,890
DAVID J.马兰：“瓶”，所以两瓶。

1357
00:55:12,890 --> 00:55:14,690
然后，这个词在这里应该是 - 

1358
00:55:14,690 --> 00:55:15,340
观众：“瓶子”。

1359
00:55:15,340 --> 00:55:17,316
DAVID J.马兰：“瓶子”，单数。

1360
00:55:20,430 --> 00:55:25,160
>> 好吧，让我们放大了，回到这里，重新运行make，

1361
00:55:25,160 --> 00:55:28,590
重新运行，99式再次beer3。

1362
00:55:28,590 --> 00:55:30,710
好吧，“分割故障（核心转储）。”

1363
00:55:30,710 --> 00:55:32,780
我做了什么错了吗？

1364
00:55:36,050 --> 00:55:38,722
观众：你不必值[听不清]。

1365
00:55:38,722 --> 00:55:40,480
DAVID J.马兰：啊，良好的出发点。

1366
00:55:40,480 --> 00:55:43,310
好吧，有什么错吗？

1367
00:55:43,310 --> 00:55:45,450
所以分割故障，我们其实要看到

1368
00:55:45,450 --> 00:55:49,020
这是一个几十倍的未来，是故意的。

1369
00:55:49,020 --> 00:55:51,030
但现在，这其实是什么意思？

1370
00:55:51,030 --> 00:55:53,620
几乎总是意味着你有一个分割故障

1371
00:55:53,620 --> 00:55:56,760
不知何故试图存取记忆体，RAM在您的计算机上，

1372
00:55:56,760 --> 00:56:00,600
不属于你的，你有没有问

1373
00:56:00,600 --> 00:56:02,050
操作系统。

1374
00:56:02,050 --> 00:56:04,440
因此，在这种情况下，请注意我做了什么，这是

1375
00:56:04,440 --> 00:56:05,870
在我的逻辑有缺陷的。

1376
00:56:05,870 --> 00:56:09,500
我已经指定S1和S2的值如果我等于1。

1377
00:56:09,500 --> 00:56:11,590
我也做了，如果i等于2。

1378
00:56:11,590 --> 00:56:13,710
但我没有这样做，在无限多的其他

1379
00:56:13,710 --> 00:56:14,690
可能性 - 

1380
00:56:14,690 --> 00:56:17,940
特别是，3或4，点，99点，或点。

1381
00:56:17,940 --> 00:56:20,100
所以固定的，这可能仅仅是让我们的

1382
00:56:20,100 --> 00:56:22,190
有其他条件。

1383
00:56:22,190 --> 00:56:26,780
让我就在这里说，S1等于 - 

1384
00:56:26,780 --> 00:56:28,180
在这里，它应该是什么？

1385
00:56:28,180 --> 00:56:28,750
观众：[听不清]。

1386
00:56:28,750 --> 00:56:30,460
>> DAVID J.马兰：“瓶子”，因为在通常情况下，

1387
00:56:30,460 --> 00:56:32,020
它只是同样的事情。

1388
00:56:32,020 --> 00:56:35,580
所以等于报价，引文结束，“瓶”。因此，对于复数

1389
00:56:35,580 --> 00:56:41,010
瓶，然后在​​这里，多个瓶。

1390
00:56:41,010 --> 00:56:44,580
好了，现在让我回到我的终端窗口，

1391
00:56:44,580 --> 00:56:47,200
重新编译，再运行它。

1392
00:56:47,200 --> 00:56:48,440
99。

1393
00:56:48,440 --> 00:56:49,150
哇！

1394
00:56:49,150 --> 00:56:50,610
让我们做一个快速的完整性检查。

1395
00:56:50,610 --> 00:56:52,400
从技术上讲，我们要阅读所有这些，以确保

1396
00:56:52,400 --> 00:56:53,370
他们是正确的，但让我们来看看

1397
00:56:53,370 --> 00:56:54,640
至少已知的罪魁祸首。

1398
00:56:54,640 --> 00:56:57,370
3瓶，2瓶，2瓶，1

1399
00:56:57,370 --> 00:57:00,380
瓶，1瓶，瓶。

1400
00:57:00,380 --> 00:57:03,080
我们似乎已经固定在至少它现在。

1401
00:57:03,080 --> 00:57:06,010
但这里的捕获量是什么神烂摊子这是

1402
00:57:06,010 --> 00:57:07,470
只是为了解决一个愚蠢的

1403
00:57:07,470 --> 00:57:09,540
一个字符的语法细节。

1404
00:57:09,540 --> 00:57:11,150
因此，有一个原因，我将这个角落种

1405
00:57:11,150 --> 00:57:14,090
早些时候，因为它是完全恼人的

1406
00:57:14,090 --> 00:57:15,020
写这么多的代码。

1407
00:57:15,020 --> 00:57:17,530
但事实证明，有更优雅的方式

1408
00:57:17,530 --> 00:57:20,110
表示完全一样的东西。

1409
00:57:20,110 --> 00:57:22,040
我们可以做到这一点，如下所示。

1410
00:57:22,040 --> 00:57:23,890
>> 让我离开这了一会儿在屏幕上，

1411
00:57:23,890 --> 00:57:27,320
介绍一些被称为一个三元运算符。

1412
00:57:27,320 --> 00:57:29,600
这是一个班轮，只是为了让我们

1413
00:57:29,600 --> 00:57:31,880
生活一点点的性感，如许。

1414
00:57:31,880 --> 00:57:33,130
我要做到这一点，如下。

1415
00:57:33,130 --> 00:57:35,810
给我一个字符串名为S1，让我

1416
00:57:35,810 --> 00:57:37,200
分配如下。

1417
00:57:37,200 --> 00:57:39,900
（我== 1）？

1418
00:57:39,900 --> 00:57:47,820
“瓶”，否则“瓶”。字符串s2得到（我== 2）？

1419
00:57:47,820 --> 00:57:52,670
“瓶”，否则“瓶”。

1420
00:57:52,670 --> 00:57:57,050
所以，这里的区别又是什么呢？

1421
00:57:57,050 --> 00:57:59,370
这两行代码，我认为，

1422
00:57:59,370 --> 00:58:02,200
更换整个的混乱。

1423
00:58:02,200 --> 00:58:04,280
所以我把它称为一个烂摊子，只是因为它让我反感

1424
00:58:04,280 --> 00:58:05,940
走错了路，它是那么多行代码。

1425
00:58:05,940 --> 00:58:06,650
没有错。

1426
00:58:06,650 --> 00:58:07,700
这不是糟糕的设计。

1427
00:58:07,700 --> 00:58:10,140
喜欢，这是完全正确的，完全没有问题。

1428
00:58:10,140 --> 00:58:12,970
不过，编码很乏味，如果你有表达自己的

1429
00:58:12,970 --> 00:58:15,530
该死的专门一而再，再而再次用一个简单的

1430
00:58:15,530 --> 00:58:16,620
场景是这样的。

1431
00:58:16,620 --> 00:58:19,470
所以C有一些快捷键，像这样。

1432
00:58:19,470 --> 00:58:24,270
因此，这实质上是说声明一个字符串名为S1，

1433
00:58:24,270 --> 00:58:32,610
指定此值，这个值，如果我是==  - 

1434
00:58:32,610 --> 00:58:35,290
对不起，我应该说得更清楚。

1435
00:58:35,290 --> 00:58:41,680
声明一个变量s1，指定此值，如果这是真的。

1436
00:58:41,680 --> 00:58:44,280
否则，指定此值。

1437
00:58:44,280 --> 00:58:47,220
所以，换句话说，这是一个行的方式

1438
00:58:47,220 --> 00:58:51,490
如果别人说，但前进的道路上做一个赋值。

1439
00:58:51,490 --> 00:58:55,540
所以，如果我是1，然后继续前进，称此为“瓶”。和

1440
00:58:55,540 --> 00:58:59,830
那么这个东西，称之为“瓶”。同时，s2中，

1441
00:58:59,830 --> 00:59:04,060
第二个字，我们需要定义，如果i等于2，我们将

1442
00:59:04,060 --> 00:59:08,350
集S2“瓶”。否则，将其设置为“瓶”。有什么

1443
00:59:08,350 --> 00:59:11,460
这意味着现在是我可以通过这一点，并删除所有的

1444
00:59:11,460 --> 00:59:12,860
这些代码行。

1445
00:59:12,860 --> 00:59:17,220
当我说，有点可笑的是，这是目前

1446
00:59:17,220 --> 00:59:20,060
性感的性感，这是在排序的文体意识。

1447
00:59:20,060 --> 00:59:22,660
事实上功能，这段代码实际上是要

1448
00:59:22,660 --> 00:59:24,610
做完全一样的东西。

1449
00:59:24,610 --> 00:59:26,890
尽管它可能看起来有点神秘

1450
00:59:26,890 --> 00:59:29,250
一目了然，因为我们从来没见过这个结构之前，我

1451
00:59:29,250 --> 00:59:31,850
认为它是最终要这么多

1452
00:59:31,850 --> 00:59:34,820
可读性和更容易为我们人类排序

1453
00:59:34,820 --> 00:59:36,830
理解，因为现在你可以只读取

1454
00:59:36,830 --> 00:59:38,830
所有代码在一行上。

1455
00:59:38,830 --> 00:59:41,550
它仍然是类似的，如果这是在精神

1456
00:59:41,550 --> 00:59:44,920
条件，然后，这是内部的，如果这

1457
00:59:44,920 --> 00:59:46,480
是的else里面有什么。

1458
00:59:46,480 --> 00:59:49,450
但我们可以做到这一点只是更优雅的。

1459
00:59:49,450 --> 00:59:52,650
>> 如果我现在回去，我的终端，删除所有

1460
00:59:52,650 --> 00:59:55,530
这些生产线，取而代之的只是这两个，

1461
00:59:55,530 --> 01:00:00,150
重新编译，重新运行的99瓶啤酒，请注意，我

1462
01:00:00,150 --> 01:00:03,350
语法是，其实仍然是正确的。

1463
01:00:03,350 --> 01:00:06,160
所以，再一次，事情开始。

1464
01:00:06,160 --> 01:00:08,840
2瓶啤酒，1瓶啤酒。

1465
01:00:08,840 --> 01:00:09,370
看起来是对的。

1466
01:00:09,370 --> 01:00:10,100
是啊。

1467
01:00:10,100 --> 01:00:13,900
因此，我们有一个更简洁的解决方案。

1468
01:00:13,900 --> 01:00:16,020
因此，这也一样，你获得更舒适的C，而不是

1469
01:00:16,020 --> 01:00:18,630
一定pset或第二，但

1470
01:00:18,630 --> 01:00:21,170
认识到这些结构可以让我们做的事情永远

1471
01:00:21,170 --> 01:00:22,810
更优雅。

1472
01:00:22,810 --> 01:00:25,200
现在，让我们在这里做的另一件事情。

1473
01:00:25,200 --> 01:00:31,460
让我走进取，不断开拓return1.c。

1474
01:00:31,460 --> 01:00:34,340
现在，让我们开始解决其他问题的方式，

1475
01:00:34,340 --> 01:00:37,140
使我们能够编写更复杂的代码。

1476
01:00:37,140 --> 01:00:39,960
>> 所以这里有一个简单的小程序，其目的在生活中

1477
01:00:39,960 --> 01:00:41,870
是增加值。

1478
01:00:41,870 --> 01:00:43,100
其实，让我们退后一步。

1479
01:00:43,100 --> 01:00:44,400
让我这样做手工。

1480
01:00:44,400 --> 01:00:52,200
让我做包括和int的主要（无效）。

1481
01:00:52,200 --> 01:00:53,450
让我叫increment.c。

1482
01:00:57,150 --> 01:00:58,570
我该怎么办？

1483
01:00:58,570 --> 01:01:02,240
我要继续前进，这样说 - 

1484
01:01:02,240 --> 01:01:04,280
我们所说的数字是相同的 - 

1485
01:01:04,280 --> 01:01:04,980
诠释x。

1486
01:01:04,980 --> 01:01:13,670
所以int X取得的printf x是％d，新线，X。

1487
01:01:13,670 --> 01:01:16,780
所以，我打字快​​，但现在有点熟悉的东西。

1488
01:01:16,780 --> 01:01:18,830
然后，我会做x + +。

1489
01:01:18,830 --> 01:01:21,710
然后，我要再次打印相同的句子。

1490
01:01:21,710 --> 01:01:24,550
然后我将返回0只退出程序。

1491
01:01:24,550 --> 01:01:25,960
所有的权利，所以这是一个程序，

1492
01:01:25,960 --> 01:01:26,960
增加一个数。

1493
01:01:26,960 --> 01:01:29,830
它的第一要初始化的东西2，那么它的

1494
01:01:29,830 --> 01:01:33,470
要增加它，并再次打印。

1495
01:01:33,470 --> 01:01:36,930
>> 因此，让我们的运行增量，令人难以置信的简单的程序。

1496
01:01:36,930 --> 01:01:40,940
但是，假设现在我要对多维数据集的值，这样做

1497
01:01:40,940 --> 01:01:42,490
东西有点乱。

1498
01:01:42,490 --> 01:01:45,140
我真正想要做X取得的立方。

1499
01:01:45,140 --> 01:01:47,570
所以，我可以使用什么所谓的pow函数，但我不

1500
01:01:47,570 --> 01:01:48,650
真的知道它在哪儿还。

1501
01:01:48,650 --> 01:01:50,580
所以，我要做到这一点，老式的方法。

1502
01:01:50,580 --> 01:01:54,550
x次，这等于x次，x倍所述。

1503
01:01:54,550 --> 01:01:56,880
所以我刺再次乘以它本身的价值，

1504
01:01:56,880 --> 01:02:00,440
一次又一次，使我们获得的权力

1505
01:02:00,440 --> 01:02:02,050
在这种情况下，共3。

1506
01:02:02,050 --> 01:02:06,000
所以，现在我要打印的数字应该是，正如我们将看到的

1507
01:02:06,000 --> 01:02:08,450
 - 增量，因此它实际上并没有真正增加

1508
01:02:08,450 --> 01:02:10,260
了，但我们会离开的名称孤独 - 

1509
01:02:10,260 --> 01:02:11,590
2和8。

1510
01:02:11,590 --> 01:02:17,670
现在，我们已经有了一个初步的机会细化

1511
01:02:17,670 --> 01:02:21,570
在这里，由此这种魔方事情乘以一个数字

1512
01:02:21,570 --> 01:02:24,680
由自己本身的感觉，这样做可能是

1513
01:02:24,680 --> 01:02:27,920
作为一个功能非常有用的，就像有人决定

1514
01:02:27,920 --> 01:02:30,430
年前 - 你知道吗，有用的，如果我们坐下

1515
01:02:30,430 --> 01:02:33,120
并写入输出使世界的其余部分可以用它

1516
01:02:33,120 --> 01:02:36,160
我们为什么不坐下来写一个函数调用的立方体

1517
01:02:36,160 --> 01:02:39,250
做这个魔方给我们，这样我们就不必手动

1518
01:02:39,250 --> 01:02:41,500
实施立方值的概念呢？

1519
01:02:41,500 --> 01:02:44,040
>> 因此，一个简单的例子，但是让我们继续使用，这是作为一个

1520
01:02:44,040 --> 01:02:46,280
写我们自己的函数。

1521
01:02:46,280 --> 01:02:49,110
因此，到目前为止，我们已经用主，我们已经使用了其他

1522
01:02:49,110 --> 01:02:51,780
人的职能，但我们还没有实现我们自己的。

1523
01:02:51,780 --> 01:02:52,650
所以，在这里，我们走了。

1524
01:02:52,650 --> 01:02:56,330
我要继续前进，写一个函数，称为立方体。

1525
01:02:56,330 --> 01:02:58,490
我想，有需要的输入。

1526
01:02:58,490 --> 01:03:02,070
所以它的输入将是一个整数。

1527
01:03:02,070 --> 01:03:03,570
又是什么呢怎么办呢？

1528
01:03:03,570 --> 01:03:08,500
这将声明int输出输入的输入时间

1529
01:03:08,500 --> 01:03:09,880
次输入。

1530
01:03:09,880 --> 01:03:12,190
那么它会返回的输出。

1531
01:03:12,190 --> 01:03:14,500
然后，我现在要具体。

1532
01:03:14,500 --> 01:03:16,820
这个函数会返回一个int。

1533
01:03:16,820 --> 01:03:19,130
所以在这里告诉您如何编写自己的函数。

1534
01:03:19,130 --> 01:03:20,850
您可以决定什么是你的名字

1535
01:03:20,850 --> 01:03:21,720
功能将是。

1536
01:03:21,720 --> 01:03:23,964
而且一般的东西解释是不错的，所以我会

1537
01:03:23,964 --> 01:03:25,060
把它立方体。

1538
01:03:25,060 --> 01:03:27,180
然后，你必须指定它会返回什么，有什么

1539
01:03:27,180 --> 01:03:28,240
将是它的输出。

1540
01:03:28,240 --> 01:03:29,595
同时，我们也没有那么多的选项。

1541
01:03:29,595 --> 01:03:32,260
int，char和浮点型，布尔型，字符串。

1542
01:03:32,260 --> 01:03:34,260
现在，我要坚持用一个int，因为我想它

1543
01:03:34,260 --> 01:03:35,880
返回一个整数。

1544
01:03:35,880 --> 01:03:38,770
然后，你必须指定其输入，如果有的话，是什么。

1545
01:03:38,770 --> 01:03:41,570
如果多维数据集需要一个参数，需要的东西之间

1546
01:03:41,570 --> 01:03:44,970
括号，你必须给该参数的名称，使

1547
01:03:44,970 --> 01:03:47,860
你可以把它的东西，因为你正在实施或写

1548
01:03:47,860 --> 01:03:50,550
这个功能，你必须给它一个类型，在这种

1549
01:03:50,550 --> 01:03:51,810
案件正在为int。

1550
01:03:51,810 --> 01:03:54,690
因此，在短，多维数据集是一个函数，它接受一个整数

1551
01:03:54,690 --> 01:03:57,560
作为输入，并返回一个整数作为输出。

1552
01:03:57,560 --> 01:03:59,240
>> 所以它是做什么用的输入？

1553
01:03:59,240 --> 01:04:03,710
那么，在第14行中，我声明了一个变量称为输出，和我

1554
01:04:03,710 --> 01:04:07,410
分配给它的值，输入时间输入时间输入。

1555
01:04:07,410 --> 01:04:11,490
然后，我返回的输出。

1556
01:04:11,490 --> 01:04:14,890
所以，我怎么使用呢？

1557
01:04:14,890 --> 01:04:19,210
我该怎么改变这些高亮显示的字符上线

1558
01:04:19,210 --> 01:04:21,006
7〜，你觉得呢？

1559
01:04:21,006 --> 01:04:21,800
观众：[听不清]。

1560
01:04:21,800 --> 01:04:25,570
DAVID J.马兰：是啊，所以多维数据集的x。

1561
01:04:25,570 --> 01:04:28,290
因此，x是一个变量，这意味着它拥有一定的价值。

1562
01:04:28,290 --> 01:04:30,190
幸运的是，它是整数类型。

1563
01:04:30,190 --> 01:04:34,280
因为x是一个整数，这意味着我可以将它传递到立方体。

1564
01:04:34,280 --> 01:04:39,500
即使我压倒一切的x的值的值

1565
01:04:39,500 --> 01:04:42,780
多维数据集x，迄今为止的情况下，任何时候你

1566
01:04:42,780 --> 01:04:46,150
有等号的一行代码，在正确的东西

1567
01:04:46,150 --> 01:04:49,090
被执行，然后被分配到

1568
01:04:49,090 --> 01:04:50,150
左侧值。

1569
01:04:50,150 --> 01:04:52,950
因此，操作的顺序是我们希望的。

1570
01:04:52,950 --> 01:04:56,620
所以做这项工作？

1571
01:04:56,620 --> 01:04:58,410
好了，让我去这里。

1572
01:04:58,410 --> 01:04:59,970
让我打开了我的终端窗口。

1573
01:04:59,970 --> 01:05:03,610
让我做增量，输入。

1574
01:05:03,610 --> 01:05:07,140
“隐式声明的函数”立方体“是无效的，

1575
01:05:07,140 --> 01:05:13,700
C99。“顺便说一句，C99指的是C语言，因为它是

1576
01:05:13,700 --> 01:05:16,790
定义于1999年，是一个在版本更新

1577
01:05:16,790 --> 01:05:19,360
1989，这是一个较原来的更新。

1578
01:05:19,360 --> 01:05:21,740
因此，所有的手段。

1579
01:05:21,740 --> 01:05:24,250
>> 所以，这是什么意思，“隐式声明

1580
01:05:24,250 --> 01:05:26,790
功能“立方体”是无效的吗？“就在这里。

1581
01:05:26,790 --> 01:05:28,430
在第12行，这是正确的。

1582
01:05:28,430 --> 01:05:30,460
观众：[听不清]。

1583
01:05:30,460 --> 01:05:30,730
DAVID J.马兰：那是什么？

1584
01:05:30,730 --> 01:05:32,470
观众：这是不是之前。

1585
01:05:32,470 --> 01:05:33,540
DAVID J.马兰：这是不是之前。

1586
01:05:33,540 --> 01:05:34,740
所以这是事情。

1587
01:05:34,740 --> 01:05:38,190
C是一种愚蠢的，或C编译器是一种​​愚蠢。

1588
01:05:38,190 --> 01:05:41,060
他们真的只能做你告诉他们做什么。

1589
01:05:41,060 --> 01:05:44,770
而他们，尤其是只阅读你的代码顶部至底部，

1590
01:05:44,770 --> 01:05:45,620
左到右。

1591
01:05:45,620 --> 01:05:49,140
因此，如果编译器，铛，阅读你的代码，1号线，

1592
01:05:49,140 --> 01:05:50,120
如何做到这一点。

1593
01:05:50,120 --> 01:05:50,940
哦，来这里主要的。

1594
01:05:50,940 --> 01:05:53,000
好吧，让我继续前进，声明一个变量x。

1595
01:05:53,000 --> 01:05:54,160
让我打印的东西。

1596
01:05:54,160 --> 01:05:55,890
7号线，到底是什么魔方？

1597
01:05:55,890 --> 01:05:58,230
这不是stdio.h中声明的。

1598
01:05:58,230 --> 01:06:00,950
它不来，我不知道该怎么办。

1599
01:06:00,950 --> 01:06:03,960
因此，铛刚刚捞出，并退出该错误消息。

1600
01:06:03,960 --> 01:06:05,850
因此，我们可以在一对夫妇的方式来解决这个问题。

1601
01:06:05,850 --> 01:06:10,530
多维数据集是什么，只是移动的，我们可以教铛

1602
01:06:10,530 --> 01:06:11,820
声明。

1603
01:06:11,820 --> 01:06:14,640
所以，我的剪切和粘贴上面主要。

1604
01:06:14,640 --> 01:06:17,770
现在认识到，只是因为主不再是第一，这是

1605
01:06:17,770 --> 01:06:19,150
默认情况下，仍然执行。

1606
01:06:19,150 --> 01:06:20,060
主要是主要的。

1607
01:06:20,060 --> 01:06:21,022
这是默认的函数名。

1608
01:06:21,022 --> 01:06:22,930
它并不重要，它是在一个文件中。

1609
01:06:22,930 --> 01:06:26,910
但至少现在铛已经看到立方体之前，我使用它。

1610
01:06:26,910 --> 01:06:28,500
因此，让我们来看看如果铛现在是非常美好的。

1611
01:06:28,500 --> 01:06:31,410
增加，并编译这个时间。

1612
01:06:31,410 --> 01:06:33,060
>> 让我跑的增量。

1613
01:06:33,060 --> 01:06:34,810
而事实上，它似乎是工作。

1614
01:06:34,810 --> 01:06:36,810
现在，你可以拿出情况下，最终在那里

1615
01:06:36,810 --> 01:06:38,650
它把每一个功能是不可行的

1616
01:06:38,650 --> 01:06:39,740
以上所有其它功能。

1617
01:06:39,740 --> 01:06:42,140
你会陷在这个无限循环在现实中，

1618
01:06:42,140 --> 01:06:43,480
这家伙想在这里，但这个

1619
01:06:43,480 --> 01:06:44,390
家伙在那里。

1620
01:06:44,390 --> 01:06:45,830
所以，这并不总是工作。

1621
01:06:45,830 --> 01:06:49,020
幸运的是，C有一个更优雅的解决方案。

1622
01:06:49,020 --> 01:06:50,790
我打算把它这回是，只是因为我

1623
01:06:50,790 --> 01:06:53,390
喜欢的话，作为一个原则问题，即主永远是

1624
01:06:53,390 --> 01:06:55,550
在顶部，因为它只是很高兴看到这是什么程序

1625
01:06:55,550 --> 01:06:56,920
的默认操作。

1626
01:06:56,920 --> 01:06:58,950
我要在这里做了什么，宣布什么叫​​做

1627
01:06:58,950 --> 01:07:00,250
一个原型。

1628
01:07:00,250 --> 01:07:05,730
我要重新申报，我的立方体函数的字面意思

1629
01:07:05,730 --> 01:07:07,180
复制和粘贴。

1630
01:07:07,180 --> 01:07:08,290
其实，这是不是真的。

1631
01:07:08,290 --> 01:07:13,060
因此，从字面上复制和粘贴15行

1632
01:07:13,060 --> 01:07:15,160
第6行以上。

1633
01:07:15,160 --> 01:07:17,010
不要紧，哪行结束了。

1634
01:07:17,010 --> 01:07:18,380
它正好是在第4行。

1635
01:07:18,380 --> 01:07:19,950
但它确实有前主。

1636
01:07:19,950 --> 01:07:21,150
但是，注意到其中的差别。

1637
01:07:21,150 --> 01:07:24,100
4号线以分号结束，这意味着哎，

1638
01:07:24,100 --> 01:07:27,510
铛，把我的话，存在一个函数

1639
01:07:27,510 --> 01:07:31,350
称为多维数据集采用了一个int并返回一个int。

1640
01:07:31,350 --> 01:07:33,020
但我不会告诉你它是什么，但。

1641
01:07:33,020 --> 01:07:35,180
只知道，我承诺最终告诉你。

1642
01:07:35,180 --> 01:07:38,490
事实上，现在没事，这是在下面。

1643
01:07:38,490 --> 01:07:41,275
>> 因此，这通常是更好的，因为这时的顶部

1644
01:07:41,275 --> 01:07:44,240
你的文件，你就可以背出，速射，一行

1645
01:07:44,240 --> 01:07:46,470
，你的职责是什么名字，他们的

1646
01:07:46,470 --> 01:07:49,120
输入，其输出是什么。

1647
01:07:49,120 --> 01:07:52,210
更清晰，输入通常是指参数或

1648
01:07:52,210 --> 01:07:54,110
参数的代名词。

1649
01:07:54,110 --> 01:07:56,890
输出装置的返回值，这是什么

1650
01:07:56,890 --> 01:07:58,700
手回到我的身边。

1651
01:07:58,700 --> 01:08:03,420
因此，在这种情况下，在这里，多维数据集已宣布在顶部，但

1652
01:08:03,420 --> 01:08:06,940
定义，否则被称为实施，在底部。

1653
01:08:06,940 --> 01:08:09,620
所以，现在让我们回到这里，重新运行。

1654
01:08:09,620 --> 01:08:13,430
所以，现在让我继续前进，重新运行make，重新运行增量。

1655
01:08:13,430 --> 01:08:16,500
它现在似乎工作得很好。

1656
01:08:16,500 --> 01:08:19,450
所以，现在我们可以继续分解出类似的

1657
01:08:19,450 --> 01:08:23,720
这第四个版本的啤酒例子。

1658
01:08:23,720 --> 01:08:25,590
因此，让我向下滚动。

1659
01:08:25,590 --> 01:08:28,149
注意到，我种了心刚才的教训。

1660
01:08:28,149 --> 01:08:31,140
事实上，我是唱同一节再次

1661
01:08:31,140 --> 01:08:34,130
一遍又一遍，同样的合唱队中的歌曲，感觉

1662
01:08:34,130 --> 01:08:36,439
喜欢我为什么不成为一个功能的因素，出吗？

1663
01:08:36,439 --> 01:08:38,470
事实上，这应该是的动机之一。

1664
01:08:38,470 --> 01:08:40,960
另外一个事实，在世界上其他的人可能要

1665
01:08:40,960 --> 01:08:42,390
使用多维数据集的功能 - 

1666
01:08:42,390 --> 01:08:44,560
这是一个很好的理由因素的东西，写你的

1667
01:08:44,560 --> 01:08:45,720
自己的自定义功能 - 

1668
01:08:45,720 --> 01:08:48,720
如果有一个块中的代码，只是让你的程序

1669
01:08:48,720 --> 01:08:51,370
概念意义上说，你有种想给它一个

1670
01:08:51,370 --> 01:08:53,740
名称 - 像在这种情况下，合唱 - 

1671
01:08:53,740 --> 01:08:57,380
那么你同样可以写，作为一个单独的函数。

1672
01:08:57,380 --> 01:08:59,560
你不写的一切，如果它只是在主

1673
01:08:59,560 --> 01:09:02,609
感觉清洁剂分离出来，并给它一个名称。

1674
01:09:02,609 --> 01:09:05,529
>> 因此，在这种情况下，在这里，请注意，我有一个评论顶上

1675
01:09:05,529 --> 01:09:06,859
这个功能，只是唱

1676
01:09:06,859 --> 01:09:08,630
指定数目的瓶子。

1677
01:09:08,630 --> 01:09:10,609
请注意，在这里，我不需要调用这些

1678
01:09:10,609 --> 01:09:12,520
输入和输出的事情。

1679
01:09:12,520 --> 01:09:16,090
其实，这个时候，我只是叫我输入b瓶。

1680
01:09:16,090 --> 01:09:19,960
注意的，无效的建议是什么？

1681
01:09:19,960 --> 01:09:21,309
该合唱团 - 

1682
01:09:21,309 --> 01:09:22,660
听众：不会返回。

1683
01:09:22,660 --> 01:09:23,870
DAVID J. MALAN：不返回一个值。

1684
01:09:23,870 --> 01:09:26,800
事实上，函数没有返回值。

1685
01:09:26,800 --> 01:09:28,060
他们可以做一些事情。

1686
01:09:28,060 --> 01:09:30,270
他们可以有什么是所谓的副作用，而在这种

1687
01:09:30,270 --> 01:09:33,109
情况下，仅仅是打印在屏幕上一大堆。

1688
01:09:33,109 --> 01:09:36,580
所以请注意，此代码在这里，我真的只是偷

1689
01:09:36,580 --> 01:09:37,680
前面的例子。

1690
01:09:37,680 --> 01:09:39,930
唯一的区别是，而不是利用i作为我

1691
01:09:39,930 --> 01:09:42,890
可变的，我现在使用b作为我的变量。

1692
01:09:42,890 --> 01:09:45,880
所以，我有b在这里，我有b在这里，我有b

1693
01:09:45,880 --> 01:09:47,109
减去1这里。

1694
01:09:47,109 --> 01:09:49,279
但代码是完全一样的。

1695
01:09:49,279 --> 01:09:52,529
但就现在向您展示如何我们可以利用这一点，让我去

1696
01:09:52,529 --> 01:09:56,780
进取，实际上这是一个循环。

1697
01:09:56,780 --> 01:10:03,850
（INT I = i> N时，我 - ）。

1698
01:10:03,850 --> 01:10:06,230
>> 所以，我偷了，从我们前面的例子。

1699
01:10:06,230 --> 01:10:08,970
在此之前，它是在第37行，我就已经开始

1700
01:10:08,970 --> 01:10:10,640
唱这讨厌的歌曲。

1701
01:10:10,640 --> 01:10:15,810
但是，我只是去，我现在请合唱团。

1702
01:10:15,810 --> 01:10:16,870
完成。

1703
01:10:16,870 --> 01:10:20,260
所以，现在这个循环在每次迭代中，我把这种

1704
01:10:20,260 --> 01:10:22,220
功能，合唱，，我碰巧写的。

1705
01:10:22,220 --> 01:10:24,110
它不是别人几年前写的。

1706
01:10:24,110 --> 01:10:27,930
但是，合唱团，同时，使用printf来打印

1707
01:10:27,930 --> 01:10:29,840
出这四行。

1708
01:10:29,840 --> 01:10:32,720
但事实上我打电话合唱一遍又一遍的

1709
01:10:32,720 --> 01:10:35,900
循环意味着，我要得到的，在最后一刻，

1710
01:10:35,900 --> 01:10:39,310
相同的歌曲，因此，我有。

1711
01:10:39,310 --> 01:10:42,130
因此，在短期，如果我现在回头看我的代码，即使

1712
01:10:42,130 --> 01:10:44,240
在功能上，这是等价的，发现它的

1713
01:10:44,240 --> 01:10:46,020
开始变得更可读。

1714
01:10:46,020 --> 01:10:48,410
我并不确切地知道如何调用getInt

1715
01:10:48,410 --> 01:10:49,250
实施。

1716
01:10:49,250 --> 01:10:52,050
坦率地说，我不知道如何合唱实施。

1717
01:10:52,050 --> 01:10:52,970
不过，这并不重要，我。

1718
01:10:52,970 --> 01:10:55,620
我不在乎，因为我现在可以排序的，作为一个人，读

1719
01:10:55,620 --> 01:10:57,050
这从顶部向底部。

1720
01:10:57,050 --> 01:10:59,950
因为这些功能根据他们命名

1721
01:10:59,950 --> 01:11:02,910
这样做，我的代码是越来越可读。

1722
01:11:02,910 --> 01:11:05,190
我们的计划复杂得多 - 

1723
01:11:05,190 --> 01:11:07,220
学期结束，你会写几百行

1724
01:11:07,220 --> 01:11:10,970
代码语言，如PHP和JavaScript之类的 - 

1725
01:11:10,970 --> 01:11:13,550
你会发现，它是如此容易得多跟踪

1726
01:11:13,550 --> 01:11:14,080
你做了什么。

1727
01:11:14,080 --> 01:11:15,810
当你开始与朋友或

1728
01:11:15,810 --> 01:11:19,010
合作伙伴或同事，你就可以写更多

1729
01:11:19,010 --> 01:11:22,910
大规模计划开始行使这些基本

1730
01:11:22,910 --> 01:11:23,990
积木。

1731
01:11:23,990 --> 01:11:25,550
>> 因此，随着中说，为什么我们不收工了吗？

1732
01:11:25,550 --> 01:11:27,190
我们将看到你（星期三）。

1733
01:11:27,190 --> 01:11:33,611
[掌声]