1
00:00:00,000 --> 00:00:02,880
>> [音乐播放]

2
00:00:02,880 --> 00:00:10,580

3
00:00:10,580 --> 00:00:13,500
>> 扬声器1：这是CS50和
这是二周的开始。

4
00:00:13,500 --> 00:00:18,400
所以，让我们深入到一些东西
这是越野车，可以这么说。

5
00:00:18,400 --> 00:00:24,015
所以，在这里是CS50的IDE，我已经
停在推动这一screen--该死

6
00:00:24,015 --> 00:00:25,070
它。

7
00:00:25,070 --> 00:00:25,760
剧透。

8
00:00:25,760 --> 00:00:26,260
好吧。

9
00:00:26,260 --> 00:00:29,060
我拉起这个屏幕在这里，
其中有一个非常简单的程序。

10
00:00:29,060 --> 00:00:32,659
如果我们向下滚动，最
这只是评论，

11
00:00:32,659 --> 00:00:36,730
但在这里，在第13行至
17我们有一个计划。

12
00:00:36,730 --> 00:00:40,580
>> 这是语法上有效的，这意味着如果
我编译它，它会编译并运行，

13
00:00:40,580 --> 00:00:41,920
但它的越野车。

14
00:00:41,920 --> 00:00:47,330
在评论该方案要求
往上顶，它应该打印10星，

15
00:00:47,330 --> 00:00:48,870
但事实并非如此。

16
00:00:48,870 --> 00:00:53,290
并可以根据你的经验，
或即将用C的经验，

17
00:00:53,290 --> 00:00:56,820
你能在逻辑上辨别
这是为什么，其实，马车？

18
00:00:56,820 --> 00:00:57,804
是吗？

19
00:00:57,804 --> 00:00:59,220
听众：它从零至10。

20
00:00:59,220 --> 00:01:01,884
这是11次迭代。

21
00:01:01,884 --> 00:01:02,550
扬声器1：是啊。

22
00:01:02,550 --> 00:01:06,030
因此，它是从零持续
通过向上和等于10，

23
00:01:06,030 --> 00:01:08,140
这当然是11迭代。

24
00:01:08,140 --> 00:01:10,020
因此，这将
打印，的确，11星。

25
00:01:10,020 --> 00:01:13,040
因此，计算机科学大会
在大多数编程语言

26
00:01:13,040 --> 00:01:15,270
确实是，只是
从零开始计数，

27
00:01:15,270 --> 00:01:18,800
但算上，但不通过
值，你真正关心的。

28
00:01:18,800 --> 00:01:21,216
>> 现在，这是一件事，
需要一点时间来适应

29
00:01:21,216 --> 00:01:25,350
甚至划痕，设计，因为它是
对于非程序员或非计算机

30
00:01:25,350 --> 00:01:28,070
科学家和儿童
基本上，被设计成具有

31
00:01:28,070 --> 00:01:29,570
你开始在一个普遍计数。

32
00:01:29,570 --> 00:01:30,277
这很好。

33
00:01:30,277 --> 00:01:33,110
您完全可以开始计数
在一个，如果这是更舒适。

34
00:01:33,110 --> 00:01:37,210
而数到，并通过10位，但
你就会明白尤其是本周

35
00:01:37,210 --> 00:01:39,950
超越，仅仅如此
在规划很多东西

36
00:01:39,950 --> 00:01:42,465
假设0是第一个
数字与你算，

37
00:01:42,465 --> 00:01:45,590
那你会觉得它更容易
刚进入这个习惯出发

38
00:01:45,590 --> 00:01:49,490
从零计数达到值
你的关心，现在

39
00:01:49,490 --> 00:01:49,990
得到去。

40
00:01:49,990 --> 00:01:50,990
>> 因此，已固定的。

41
00:01:50,990 --> 00:01:53,670
我们改变了小于或
等于只以内。

42
00:01:53,670 --> 00:01:56,050
让我们来看看
这里的第二示例。

43
00:01:56,050 --> 00:01:59,585
>> 因此，这个程序也要求其
评论往上顶，它应该打印

44
00:01:59,585 --> 00:02:02,260
十星，但事实并非如此。

45
00:02:02,260 --> 00:02:05,540
这里有什么错误？

46
00:02:05,540 --> 00:02:07,930
>> 因此，what--对不起，我们要清楚。

47
00:02:07,930 --> 00:02:08,610
10星。

48
00:02:08,610 --> 00:02:11,644
每行一个，但事实并非如此。

49
00:02:11,644 --> 00:02:14,810
所以，实际上，让我继续前进，编译
这一个，因为它是一个少

50
00:02:14,810 --> 00:02:16,900
基于这样的描述清楚。

51
00:02:16,900 --> 00:02:18,720
让我进入我们的源代码目录。

52
00:02:18,720 --> 00:02:25,110
让车一个点斜线，越野车之一。

53
00:02:25,110 --> 00:02:28,680
好了，我看11星，这
还是有问题，

54
00:02:28,680 --> 00:02:30,090
但他们也都在同一行。

55
00:02:30,090 --> 00:02:31,500
什么是这里的问题？

56
00:02:31,500 --> 00:02:32,339
是啊。

57
00:02:32,339 --> 00:02:33,255
听众：[听不清]。

58
00:02:33,255 --> 00:02:36,194

59
00:02:36,194 --> 00:02:36,860
扬声器1：是啊。

60
00:02:36,860 --> 00:02:40,210
所以这是一个微妙的，你可以
记得我作简要的提到。

61
00:02:40,210 --> 00:02:42,793
尽管一切看起来
漂亮，而且它很好地缩进，

62
00:02:42,793 --> 00:02:45,850
一种，它看起来刮样
在该行的16和17是，

63
00:02:45,850 --> 00:02:47,600
事实上，缩进下，对于循环。

64
00:02:47,600 --> 00:02:48,400
这是无关紧要的。

65
00:02:48,400 --> 00:02:50,460
电脑不
知道或看到空白。

66
00:02:50,460 --> 00:02:52,910
白色的空间只为
我们人类，曲风。

67
00:02:52,910 --> 00:02:57,010
电脑不知道，当你有
大括号，这，的确，

68
00:02:57,010 --> 00:02:58,280
解决这个问题。

69
00:02:58,280 --> 00:03:02,350
>> 所以，如果我们真正走进去，
明确提出在这些大括号

70
00:03:02,350 --> 00:03:05,220
这将通过解决这个问题
昭示编译器

71
00:03:05,220 --> 00:03:07,930
我居然要执行
两行代码再次，

72
00:03:07,930 --> 00:03:09,220
又一次，又一次。

73
00:03:09,220 --> 00:03:11,680
但是，什么是根本的解释？

74
00:03:11,680 --> 00:03:12,180
对？

75
00:03:12,180 --> 00:03:15,260
我们不严格需要
大括号的时候，

76
00:03:15,260 --> 00:03:18,210
即使它可能是最好的
实践进入这个习惯呢

77
00:03:18,210 --> 00:03:20,878
即使它增加了两个
字符代码。为什么呢？

78
00:03:20,878 --> 00:03:22,380
>> 听众：[听不清]？

79
00:03:22,380 --> 00:03:24,630
扬声器1：是啊，这样的
另一种解决方案完全。

80
00:03:24,630 --> 00:03:25,130
对？

81
00:03:25,130 --> 00:03:28,250
特别是如果乍一看你不
真正体会到这是怎么回事。

82
00:03:28,250 --> 00:03:31,070
好了，我们肯定能
只是做两件事

83
00:03:31,070 --> 00:03:32,710
和刚刚完全避免这个问题。

84
00:03:32,710 --> 00:03:36,080
这很好，但现在，
对于今天的目的是什么

85
00:03:36,080 --> 00:03:38,200
对于错误的解释？

86
00:03:38,200 --> 00:03:39,810
为什么在同一行所有的星星？

87
00:03:39,810 --> 00:03:40,806
是吗？

88
00:03:40,806 --> 00:03:43,296
>> 听众：看来，如果
你有一行代码，

89
00:03:43,296 --> 00:03:46,649
你可以不用那些。

90
00:03:46,649 --> 00:03:47,440
扬声器1：没错。

91
00:03:47,440 --> 00:03:48,750
这仅仅是一个人的约定。

92
00:03:48,750 --> 00:03:50,750
人们认识到，这是一个
有点恼人或繁琐

93
00:03:50,750 --> 00:03:53,470
有把花括号所有
如果你想要做的时候

94
00:03:53,470 --> 00:03:55,090
是执行的一行代码。

95
00:03:55,090 --> 00:03:57,660
所以，人类决定一些
时间以前，这很好。

96
00:03:57,660 --> 00:04:01,180
如果你想要把所有的循环
上只是这样一行，

97
00:04:01,180 --> 00:04:04,030
这很好跟单
分号结尾。

98
00:04:04,030 --> 00:04:07,210
但是，你只能做一个这样的
行没有花括号。

99
00:04:07,210 --> 00:04:09,900
>> 所以，当CS50风格指南
如将指向你，

100
00:04:09,900 --> 00:04:11,980
你会看到，一般
这是好习惯

101
00:04:11,980 --> 00:04:14,920
进入这个直到你
相当舒适的飘游

102
00:04:14,920 --> 00:04:17,404
从这类公约
，做自己的事。

103
00:04:17,404 --> 00:04:18,820
只要你是自洽。

104
00:04:18,820 --> 00:04:21,540
我们将详细讨论
风格有点今天晚些时候。

105
00:04:21,540 --> 00:04:23,200
>> 所以，让我打开另一个程序。

106
00:04:23,200 --> 00:04:24,930
当然，我们应该
修复10为好。

107
00:04:24,930 --> 00:04:32,470
让我继续前进，写一个真正的
快速程序，我会打电话，

108
00:04:32,470 --> 00:04:38,140
比方说，循环点C.因此，循环点C.
而在环路C点我就要有，

109
00:04:38,140 --> 00:04:41,970
包括标准I / O
点^ h诠释主要无效。

110
00:04:41,970 --> 00:04:44,020
现在，就让我们做的，的确是一个循环。

111
00:04:44,020 --> 00:04:46,020
因此，4 INT我得到零。

112
00:04:46,020 --> 00:04:48,660
我不到，也就是说，50。

113
00:04:48,660 --> 00:04:49,950
我加分，加分。

114
00:04:49,950 --> 00:04:53,350
然后在下面就让我们来
继续前进，不要打印F.

115
00:04:53,350 --> 00:04:56,400
然后我要打印我
和一个新行，分号。

116
00:04:56,400 --> 00:05:00,015
>> 这应该打印所有
从零号至50？

117
00:05:00,015 --> 00:05:02,900

118
00:05:02,900 --> 00:05:03,680
几头点点头。

119
00:05:03,680 --> 00:05:04,270
几号。

120
00:05:04,270 --> 00:05:05,339
什么是已经是错误吗？

121
00:05:05,339 --> 00:05:06,630
什么是容易犯的错误我犯了？

122
00:05:06,630 --> 00:05:07,170
是啊。

123
00:05:07,170 --> 00:05:08,544
>> 听众：[听不清]。

124
00:05:08,544 --> 00:05:09,210
扬声器1：是啊。

125
00:05:09,210 --> 00:05:11,520
因此，即使它看起来
像这就是我打算，

126
00:05:11,520 --> 00:05:13,920
记得，我也是
只是一个ASCII字符。

127
00:05:13,920 --> 00:05:14,955
>> 所以，如果我说，打印“一”

128
00:05:14,955 --> 00:05:16,670
它从字面上去
打印一，所以，如果我

129
00:05:16,670 --> 00:05:20,030
想插件的占位符
价值其实我需要这样做

130
00:05:20,030 --> 00:05:22,630
然后插件的
我值动态。

131
00:05:22,630 --> 00:05:25,200
否则，我只是要
获得50我的屏幕上。

132
00:05:25,200 --> 00:05:28,140
>> 所以，让我继续前进，
使这个循环，运行它，

133
00:05:28,140 --> 00:05:30,650
而事实上，我们都
一路攀升至49。

134
00:05:30,650 --> 00:05:34,140
如果我的时间向后滚动我见
数字零的开头。

135
00:05:34,140 --> 00:05:36,050
>> 好吧，如果我有点搞砸？

136
00:05:36,050 --> 00:05:37,800
如果我这样做呢？

137
00:05:37,800 --> 00:05:40,120
只是因为我没有想到。

138
00:05:40,120 --> 00:05:40,970
这是什么程序。

139
00:05:40,970 --> 00:05:43,970
一旦重新编译和运行，
要做到逻辑？

140
00:05:43,970 --> 00:05:44,870
>> 听众：没有。

141
00:05:44,870 --> 00:05:45,661
>> 扬声器1：没有。

142
00:05:45,661 --> 00:05:47,156
这是为什么？

143
00:05:47,156 --> 00:05:49,124
>> 听众：我是专为为零。

144
00:05:49,124 --> 00:05:51,899
因此，条件为假。

145
00:05:51,899 --> 00:05:52,940
扬声器1：是的，没错。

146
00:05:52,940 --> 00:05:55,110
所有的代码是正确的，语法上。

147
00:05:55,110 --> 00:05:57,310
这将编译，这
代码将运行，但它不是

148
00:05:57,310 --> 00:06:00,110
打算做什么有用的东西
因为我初始化我到零。

149
00:06:00,110 --> 00:06:02,240
然后，我们检查一下，我是大于50？

150
00:06:02,240 --> 00:06:03,810
显然，不，不是这样的。

151
00:06:03,810 --> 00:06:05,760
因此，循环永远不会执行的。

152
00:06:05,760 --> 00:06:09,580
>> 如果我们做一些事情
多一点鲁莽？

153
00:06:09,580 --> 00:06:12,890
那么，如果我们不喜欢INT我得到零。

154
00:06:12,890 --> 00:06:15,640
现在让我用，而
循环，这是另一种情况。

155
00:06:15,640 --> 00:06:21,810
虽然我说，而我是大于
或等于零，然后在这里我

156
00:06:21,810 --> 00:06:26,070
继续前进，保存文件，进行循环。

157
00:06:26,070 --> 00:06:27,070
而我要运行它。

158
00:06:27,070 --> 00:06:30,230
我该怎么看到这个
时间while循环？

159
00:06:30,230 --> 00:06:30,852
是啊。

160
00:06:30,852 --> 00:06:32,120
>> 听众：一个无限循环？

161
00:06:32,120 --> 00:06:35,360
>> 扬声器1：一个无限循环？

162
00:06:35,360 --> 00:06:36,662
是的，为什么？

163
00:06:36,662 --> 00:06:38,120
听众：因为它始终为零。

164
00:06:38,120 --> 00:06:38,786
扬声器1：是啊。

165
00:06:38,786 --> 00:06:40,100
所以，我被初始化为零。

166
00:06:40,100 --> 00:06:44,470
当然，我总是更大
大于或等于0作为一个结果。

167
00:06:44,470 --> 00:06:46,460
所以，我只是要
看到这个无限。

168
00:06:46,460 --> 00:06:49,850
而现在，这已经上来一次
或两次课程的负责人。

169
00:06:49,850 --> 00:06:52,417
当你发生什么
有一个无限循环？

170
00:06:52,417 --> 00:06:53,314
>> 听众：控制C.

171
00:06:53,314 --> 00:06:53,980
扬声器1：是啊。

172
00:06:53,980 --> 00:06:56,250
因此，对照C最终会作出反应。

173
00:06:56,250 --> 00:06:59,520
不幸的是，我们已经打印出来
亿万零已经

174
00:06:59,520 --> 00:07:01,520
所以计算机有
种了我前面。

175
00:07:01,520 --> 00:07:03,394
因此，它会忽略
我要一点点。

176
00:07:03,394 --> 00:07:06,560
但如果你只是打对照C几
你的Mac或PC键盘上的时候，

177
00:07:06,560 --> 00:07:08,790
最终它应该确实终止。

178
00:07:08,790 --> 00:07:11,770
如果没有的话，我们会告诉你一些
用不了多久，你的技术

179
00:07:11,770 --> 00:07:14,850
其实可以强行杀程序，
就像在Windows和Mac OS，

180
00:07:14,850 --> 00:07:15,562
如果需要的话。

181
00:07:15,562 --> 00:07:16,770
但是，让我们尝试别的东西。

182
00:07:16,770 --> 00:07:19,895
让我们实际上会增加一。
这仍然将是无限的？

183
00:07:19,895 --> 00:07:22,870

184
00:07:22,870 --> 00:07:25,140
让我跑这一点。

185
00:07:25,140 --> 00:07:27,090
现在你可以种
看到发生了什么。

186
00:07:27,090 --> 00:07:30,140
此，也同样是一个无限循环。

187
00:07:30,140 --> 00:07:33,080
但是，这是一个有点很难回答的问题。

188
00:07:33,080 --> 00:07:35,460
这是怎么回事永远打印的数字呢？

189
00:07:35,460 --> 00:07:36,647
>> 听众：第

190
00:07:36,647 --> 00:07:37,230
扬声器1：否。

191
00:07:37,230 --> 00:07:37,620
为什么呢？

192
00:07:37,620 --> 00:07:38,820
我听到一些号在这里。

193
00:07:38,820 --> 00:07:41,859
Someone--呀。

194
00:07:41,859 --> 00:07:44,275
听众：您没有足够的
位真正坚持下去。

195
00:07:44,275 --> 00:07:44,730
扬声器1：所有权利。

196
00:07:44,730 --> 00:07:46,000
所以，我没有足够的
位继续下去。

197
00:07:46,000 --> 00:07:47,124
那么，有什么事情发生？

198
00:07:47,124 --> 00:07:49,320
它只是要停下来？

199
00:07:49,320 --> 00:07:52,542
>> 听众：在某些时候
它将关闭the--

200
00:07:52,542 --> 00:07:54,500
扬声器1：将关闭
循环下来，但是为什么呢？

201
00:07:54,500 --> 00:07:57,950
这是怎么回事发生在
其边界的尽头？

202
00:07:57,950 --> 00:07:58,479
是吗？

203
00:07:58,479 --> 00:08:00,520
听众：它会循环
回到负数。

204
00:08:00,520 --> 00:08:02,900
扬声器1：负数，或
如果我们只是积极的治疗，

205
00:08:02,900 --> 00:08:03,570
零最少。

206
00:08:03,570 --> 00:08:04,550
所以，是的，绝对的。

207
00:08:04,550 --> 00:08:08,059
回想一下，我们看到的最后一次，如果你
增加你的点点太多次，

208
00:08:08,059 --> 00:08:10,225
你有FORE溢出
你INT的能力

209
00:08:10,225 --> 00:08:13,058
或任何数据类型，你
要环绕，很可能，

210
00:08:13,058 --> 00:08:14,020
两个负号。

211
00:08:14,020 --> 00:08:16,644
或者，如果你指定你
范围应仅是正的，

212
00:08:16,644 --> 00:08:18,560
你可以这样做，但
我们还没有看到的是，

213
00:08:18,560 --> 00:08:21,420
你可能最终至少回到零。

214
00:08:21,420 --> 00:08:22,410
虽然，实际上是。

215
00:08:22,410 --> 00:08:24,320
在这种情况下，负
号，在这种情况

216
00:08:24,320 --> 00:08:26,870
环路将要终止
因为我是不是，事实上，

217
00:08:26,870 --> 00:08:29,220
大于或等于
零，如果是负面的。

218
00:08:29,220 --> 00:08:31,780
>> 所以，不幸的是，如何
长会，我们不得不等待？

219
00:08:31,780 --> 00:08:35,490
现在，我们正达
什么，200万上下的？

220
00:08:35,490 --> 00:08:37,705
我们是如2十亿，
我们将不得不等待

221
00:08:37,705 --> 00:08:39,330
直到我们可以清楚地看到这种现象。

222
00:08:39,330 --> 00:08:46,200
但是，我们可以看到它快一点，
maybe--让我们看看我们是否可以中断。

223
00:08:46,200 --> 00:08:46,700
来吧。

224
00:08:46,700 --> 00:08:49,500

225
00:08:49,500 --> 00:08:51,331
就连菜单出现缓慢。

226
00:08:51,331 --> 00:08:51,830
好吧。

227
00:08:51,830 --> 00:08:54,270
所以，我们会回来的，不久。

228
00:08:54,270 --> 00:08:56,320
这是一个很好的时间 - 该死的，小狗。

229
00:08:56,320 --> 00:08:58,280
>> 这是一个好时机一些短片。

230
00:08:58,280 --> 00:09:01,225
所以，如果你可能会喜欢
从事YHack，

231
00:09:01,225 --> 00:09:03,600
该事件是
我们的朋友在耶鲁大学主办。

232
00:09:03,600 --> 00:09:05,990
而且，事实上，一些过程的
课题组在耶鲁涉及与此有关。

233
00:09:05,990 --> 00:09:08,610
YHack是国际
黑客马拉松主办和举行

234
00:09:08,610 --> 00:09:12,395
在耶鲁大学，汇集1500
志同道合的黑客和广告的所有

235
00:09:12,395 --> 00:09:13,120
全世界。

236
00:09:13,120 --> 00:09:14,610
如果这是感兴趣的，
看看这里。

237
00:09:14,610 --> 00:09:17,401
如果这是过于短暂的
屏幕，看看今天的幻灯片

238
00:09:17,401 --> 00:09:19,622
对于网址yhack.org。

239
00:09:19,622 --> 00:09:21,080
因此，也有一些快速的公告。

240
00:09:21,080 --> 00:09:24,410
因此，正式部分将启动
下周在这里和纽黑文。

241
00:09:24,410 --> 00:09:27,660
请记住，你会得到一个
电子邮件后来这个周末最有可能的。

242
00:09:27,660 --> 00:09:29,390
这需要很长的时间
为CS50节，

243
00:09:29,390 --> 00:09:32,080
给所有的人在
一流的，每个人走动。

244
00:09:32,080 --> 00:09:34,871
而所有的教学研究员“
时间表也仍在巩固，

245
00:09:34,871 --> 00:09:38,110
但敬请关注电子邮件，如果需要的话
可以，你可以有后再次部分。

246
00:09:38,110 --> 00:09:39,580
>> Study.cs50.net。

247
00:09:39,580 --> 00:09:43,280
所以，即使你是一个恒定的与会者
在段，实现几乎所有

248
00:09:43,280 --> 00:09:46,786
资源，我们在部分使用
公布于CS50

249
00:09:46,786 --> 00:09:48,460
在研究这个网址在这里。

250
00:09:48,460 --> 00:09:51,630
所以，如果你曾经想重新审查
材料部分，或读取提前，

251
00:09:51,630 --> 00:09:54,170
或者你不能让一些周，
认识到样品的幻灯片，

252
00:09:54,170 --> 00:09:58,210
和问题，和定义，
而更多的是所有有作为。

253
00:09:58,210 --> 00:10:00,645
>> 今天办公时间恢复，
明天，周三，

254
00:10:00,645 --> 00:10:03,020
周四检查过程中的
网站的日程安排。

255
00:10:03,020 --> 00:10:05,690
>> 而且，现在推出
今天是CS50讨论。

256
00:10:05,690 --> 00:10:09,230
因此，如果当你有问题
对方或过程的工作人员，

257
00:10:09,230 --> 00:10:12,099
且通常工作
一些习题集，

258
00:10:12,099 --> 00:10:15,015
认识到你不一定
不得不转向你旁边的人。

259
00:10:15,015 --> 00:10:17,810
如果有一个人也没有，你可以
伸手给我们和同学

260
00:10:17,810 --> 00:10:19,890
网上通过CS50讨论。

261
00:10:19,890 --> 00:10:22,600
所以，这是一个讨论
板的过程中，

262
00:10:22,600 --> 00:10:24,550
并认识到这
也许是最好的

263
00:10:24,550 --> 00:10:28,480
开始的地方，当你有
办公时间问题时，外

264
00:10:28,480 --> 00:10:29,470
特别是。

265
00:10:29,470 --> 00:10:31,070
>> 午餐将在本周启动了。

266
00:10:31,070 --> 00:10:33,170
在火与冰
[听不清]在纽黑文。

267
00:10:33,170 --> 00:10:35,379
看一看在课程的
网站以RSVP。

268
00:10:35,379 --> 00:10:36,753
先来先服务于这一点。

269
00:10:36,753 --> 00:10:39,380
如果你没有得到在这一周
我们将这些最每周五做

270
00:10:39,380 --> 00:10:40,400
在此期限内。

271
00:10:40,400 --> 00:10:41,830
>> OK，现在大约分级字。

272
00:10:41,830 --> 00:10:44,690
特别是当我们进入的问题
设置一个，这是这个星期，

273
00:10:44,690 --> 00:10:46,670
与问题设置两个，其后。

274
00:10:46,670 --> 00:10:51,680
如何做才好在计算P套
和评价其质量？

275
00:10:51,680 --> 00:10:55,560
所以，这是我们在使用四轴
CS50，他们是这四个位置。

276
00:10:55,560 --> 00:10:59,200
>> 适用范围，它可以捕获一个数字
依据到底有多少在P组

277
00:10:59,200 --> 00:10:59,860
你解决。

278
00:10:59,860 --> 00:11:02,890
它大致与对应
努力，这是我们的拍摄方式

279
00:11:02,890 --> 00:11:05,190
你尝试一半在P
设置，所有P组。

280
00:11:05,190 --> 00:11:08,860
这是一个容易得到完美
分数，如果你做，事实上，

281
00:11:08,860 --> 00:11:11,020
尝试在P组的每一个方面。

282
00:11:11,020 --> 00:11:12,010
所以，记住这一点。

283
00:11:12,010 --> 00:11:13,420
>> 正确性正是如此。

284
00:11:13,420 --> 00:11:17,760
请问你的代码工作规范
而作为员工的样品溶液

285
00:11:17,760 --> 00:11:19,730
建议你的代码
应，实际上，正常工作。

286
00:11:19,730 --> 00:11:23,260
检查50，如果你还没有遇见它
然而，是P中设置一种规格

287
00:11:23,260 --> 00:11:25,060
并且一般
给你是/否的答案

288
00:11:25,060 --> 00:11:26,518
是否你的代码是正确的。

289
00:11:26,518 --> 00:11:30,680
至少到目前为止，我们要​​去
对其进行评估的基础上测试

290
00:11:30,680 --> 00:11:32,430
我们的程序中运行。

291
00:11:32,430 --> 00:11:33,850
>> 设计更加主观的。

292
00:11:33,850 --> 00:11:35,994
这是怎么写得很好，是你的代码。

293
00:11:35,994 --> 00:11:38,410
这是东西
你会得到在一段时间内比较好，

294
00:11:38,410 --> 00:11:41,201
和它的东西，我们会
提供更多的定性反馈。

295
00:11:41,201 --> 00:11:43,350
并通过设计，我可能
过不了多久意味着你

296
00:11:43,350 --> 00:11:47,650
中了一些p-可能会受到诱惑
设置做一些loopingly，

297
00:11:47,650 --> 00:11:51,590
但有可能三个或四个，或
5嵌套循环前或嵌套而

298
00:11:51,590 --> 00:11:52,090
循环。

299
00:11:52,090 --> 00:11:54,130
这一般应
开始做你畏缩

300
00:11:54,130 --> 00:11:56,070
一般会
认为是不好的设计。

301
00:11:56,070 --> 00:11:59,490
你会开始看到在课堂上
出来做事的类好方法，

302
00:11:59,490 --> 00:12:02,920
做事不好的方式，
可能全部是正确的，但不能

303
00:12:02,920 --> 00:12:04,304
一定精心设计的。

304
00:12:04,304 --> 00:12:05,220
就像写论文。

305
00:12:05,220 --> 00:12:08,100
你也许能够把字上
网页是语法正确，

306
00:12:08,100 --> 00:12:10,016
但作文或
论文他们在仅仅是

307
00:12:10,016 --> 00:12:11,810
完全语无伦次或缺乏说服力。

308
00:12:11,810 --> 00:12:15,930
因此，可能是在该模拟
不良或良好的设计编写的世界。

309
00:12:15,930 --> 00:12:18,490
>> 和风格，也同样是相当主观的。

310
00:12:18,490 --> 00:12:20,060
但至少我们期望的一致性。

311
00:12:20,060 --> 00:12:21,480
这是多么漂亮是你的代码。

312
00:12:21,480 --> 00:12:22,840
事情很好地缩进？

313
00:12:22,840 --> 00:12:26,600
是你的变量以及名为/是否所有
你的括号和大括号

314
00:12:26,600 --> 00:12:27,920
对准他们应该是什么？

315
00:12:27,920 --> 00:12:31,490
我们确实有一个CS50风格指南作为
问题集将指向你的。

316
00:12:31,490 --> 00:12:33,730
那些更舒适的
欢迎来自流浪

317
00:12:33,730 --> 00:12:35,771
只要你是自洽。

318
00:12:35,771 --> 00:12:38,020
而这，也同样是一个教训
我们将加强在部分。

319
00:12:38,020 --> 00:12:40,990
因此，如果这一切是一个小
速度快，实现了在P组和部分

320
00:12:40,990 --> 00:12:42,900
将进入更深入没多久。

321
00:12:42,900 --> 00:12:45,490
>> 但一般我们有
很少有水桶为CS50。

322
00:12:45,490 --> 00:12:48,170
分数一般的规模
的一至三个，或者一至五个。

323
00:12:48,170 --> 00:12:50,836
我们literally--，我不能说
这足以在第一周。

324
00:12:50,836 --> 00:12:51,582
三是良好的。

325
00:12:51,582 --> 00:12:54,290
所以，尽管，是的，四分之三
五通常，数学，

326
00:12:54,290 --> 00:12:57,240
可能是一个60％或像A D减去。

327
00:12:57,240 --> 00:12:58,840
三是，其实不错的。

328
00:12:58,840 --> 00:13:01,050
而且，事实上，我们预期
大多数学生在课堂上

329
00:13:01,050 --> 00:13:04,280
各地开始术语
三三两两，和三分球，和四肢。

330
00:13:04,280 --> 00:13:05,510
也许没有那么多五岁以下儿童。

331
00:13:05,510 --> 00:13:06,661
没有太多的人。

332
00:13:06,661 --> 00:13:08,910
但一般开始于
甜蜜点的曲线

333
00:13:08,910 --> 00:13:11,694
使得随着时间的推进，
实际上有空间，

334
00:13:11,694 --> 00:13:13,360
和机会上的进展。

335
00:13:13,360 --> 00:13:15,810
所以，请不要等同于三连60％。

336
00:13:15,810 --> 00:13:17,410
这是比这更抽象。

337
00:13:17,410 --> 00:13:20,160
与我们计算公式
成绩加权如下。

338
00:13:20,160 --> 00:13:21,610
正确性值得最。

339
00:13:21,610 --> 00:13:23,010
设计是值得少一点。

340
00:13:23,010 --> 00:13:24,490
风格是值得少一点。

341
00:13:24,490 --> 00:13:26,950
而这一般
捕获的时间量

342
00:13:26,950 --> 00:13:29,800
即进入获取每个
这些轴的恰到好处。

343
00:13:29,800 --> 00:13:31,810
风格是超级容易，
应该是超级快，

344
00:13:31,810 --> 00:13:33,657
但它是一个简单的习惯
偷懒一下。

345
00:13:33,657 --> 00:13:35,490
正确性可能需要
你的大部分时间。

346
00:13:35,490 --> 00:13:38,990
追击了一些bug威力
采取额外小时或更长时间，

347
00:13:38,990 --> 00:13:41,737
因此，计分
最终捕获。

348
00:13:41,737 --> 00:13:43,070
所以，现在更严重的话。

349
00:13:43,070 --> 00:13:45,240
由于CS50有
区分，为了更好的

350
00:13:45,240 --> 00:13:47,440
或者更糟的是，被
也许是更好的认识

351
00:13:47,440 --> 00:13:50,065
与学术的问题
诚信比大多数其他任何课程。

352
00:13:50,065 --> 00:13:53,720
事实上，这是我的知识
我们送更多的学生，遗憾的是，

353
00:13:53,720 --> 00:13:56,690
为惩戒目的
每年作为结果。因此，

354
00:13:56,690 --> 00:13:59,040
在全兴趣
信息披露，让我们来简单谈谈

355
00:13:59,040 --> 00:14:02,820
关于什么在CS50，和你
可以做的，你可以什么铭记。

356
00:14:02,820 --> 00:14:05,530
>> 所以，在这里，因为2007年的时候，
我继承的过程中，

357
00:14:05,530 --> 00:14:07,870
是广告委员会的案件数量。

358
00:14:07,870 --> 00:14:10,690
AD板是哈佛大学的纪律
身体，还是现在的荣誉顾问，

359
00:14:10,690 --> 00:14:13,790
到案件移交时，
学生做一些课程的

360
00:14:13,790 --> 00:14:15,470
教学大纲认为是不合理的。

361
00:14:15,470 --> 00:14:17,220
有没有真正的模式
在这里，我想说的。

362
00:14:17,220 --> 00:14:19,530
它的波动比
年，但一般

363
00:14:19,530 --> 00:14:22,262
这是数
这被称为箱子。

364
00:14:22,262 --> 00:14:23,970
学生人数
所涉及到的？

365
00:14:23,970 --> 00:14:25,290
它也各不相同。

366
00:14:25,290 --> 00:14:27,930
通常情况下，去年
例如，29名学生在哈佛

367
00:14:27,930 --> 00:14:29,740
是广告登机，可以这么说。

368
00:14:29,740 --> 00:14:32,670
其中在校学生29，
他们俩之前的学生，

369
00:14:32,670 --> 00:14:35,610
谁是合作
在某些不良方式。

370
00:14:35,610 --> 00:14:38,400
然后在的条款
百分比，通常约为3％

371
00:14:38,400 --> 00:14:41,360
之类的，很遗憾，
使这些类型的决定。

372
00:14:41,360 --> 00:14:44,470
>> 所以，去年是3.5％
CS50的学生的身体

373
00:14:44,470 --> 00:14:46,820
这是广告登机，可以这么说。

374
00:14:46,820 --> 00:14:48,490
>> 那么，是什么这一切意味着什么呢？

375
00:14:48,490 --> 00:14:49,660
什么我们实际上做？

376
00:14:49,660 --> 00:14:52,930
>> 因此，对于充分披露，我们
绝对的，因为计算机科学家，

377
00:14:52,930 --> 00:14:57,620
有软件工具在我们的处置
它很容易让我们，为公平起见，

378
00:14:57,620 --> 00:15:00,980
其他的同学谁不
越过这些线跨越比较

379
00:15:00,980 --> 00:15:04,570
今年对每家每户提交
提交在过去的八年。

380
00:15:04,570 --> 00:15:05,445
软件做到这一点。

381
00:15:05,445 --> 00:15:07,440
而最终它的
人眼的决定

382
00:15:07,440 --> 00:15:11,410
是否要参照一些
此事作进一步审理，

383
00:15:11,410 --> 00:15:12,737
但软件有一定的帮助。

384
00:15:12,737 --> 00:15:15,820
而这，坦白地说，这就是为什么我认为
我们有这样大量的CS50。

385
00:15:15,820 --> 00:15:18,540
这不是因为CS50
学生或CS学生更多

386
00:15:18,540 --> 00:15:20,840
一般是任何减少诚实
比任何其他的学生，

387
00:15:20,840 --> 00:15:22,340
它只是我们有
工具和技术

388
00:15:22,340 --> 00:15:24,095
与借此第一遍。

389
00:15:24,095 --> 00:15:25,960
>> 但是我们继续关注
在所有这些事情

390
00:15:25,960 --> 00:15:30,340
同时，又在利益
认识到正在被投入工作

391
00:15:30,340 --> 00:15:32,397
在由绝对多数之类的。

392
00:15:32,397 --> 00:15:34,230
而课程的政策
学术诚信，

393
00:15:34,230 --> 00:15:37,021
即使它是一堆段落
长着一堆子弹

394
00:15:37,021 --> 00:15:40,490
那些希望可读性很好，它
确实归结为是合理的。

395
00:15:40,490 --> 00:15:44,000
和拇指的最佳规则
我们提供了教学大纲中

396
00:15:44,000 --> 00:15:46,020
是这样的，本质
所有的工作，你

397
00:15:46,020 --> 00:15:47,850
提交本课程必须是你自己。

398
00:15:47,850 --> 00:15:51,510
事实上，几乎所有这些
宗介纪律处分

399
00:15:51,510 --> 00:15:55,640
这是因为一些学生下旬的一个
晚上一般把他或她的代码

400
00:15:55,640 --> 00:15:58,130
在直接向一个同学，
谁再通过它

401
00:15:58,130 --> 00:16:00,840
其全部或
显著物。

402
00:16:00,840 --> 00:16:02,680
>> 不过说真的，这是确定。

403
00:16:02,680 --> 00:16:04,684
事实上，在办公室
纸小时，卡瓦

404
00:16:04,684 --> 00:16:07,850
你一直在流传，如果你来过办公室
小时上周鼓励之多。

405
00:16:07,850 --> 00:16:09,710
你绝对
欢迎和鼓励

406
00:16:09,710 --> 00:16:12,340
讨论习题集与同学。

407
00:16:12,340 --> 00:16:14,461
要绊倒的时候互相帮助。

408
00:16:14,461 --> 00:16:17,710
但一般经验法则应
是这样的，“当你寻求帮助，

409
00:16:17,710 --> 00:16:20,412
你可能会显示你的代码给其他人，
但你可能不认为他们的。“

410
00:16:20,412 --> 00:16:22,620
所以，换句话说，如果我
一些页P挣扎

411
00:16:22,620 --> 00:16:25,290
而我在坐在那里
食堂，或在图书馆，

412
00:16:25,290 --> 00:16:28,470
或在课堂上
试图找到一些故障，

413
00:16:28,470 --> 00:16:30,340
我可以肯定的显示
我的我的屏幕上的代码

414
00:16:30,340 --> 00:16:32,590
的人坐在旁边
对我来说，肯定是工作人员，

415
00:16:32,590 --> 00:16:33,600
又是同班同学。

416
00:16:33,600 --> 00:16:36,580
但是，如果解决方案，它
我的同学提供的是，哦，

417
00:16:36,580 --> 00:16:39,200
这里只是来看看什么
我这样做，是穿过线。

418
00:16:39,200 --> 00:16:43,120
>> 而且我敢说这是一般
一个合理的事情对大多数人

419
00:16:43,120 --> 00:16:45,030
很容易发现的行。

420
00:16:45,030 --> 00:16:47,195
所以，看大纲
对于更多的细节。

421
00:16:47,195 --> 00:16:49,070
而现在比较1
有争议的方面

422
00:16:49,070 --> 00:16:52,529
CS50大纲，我认为我
会说话的结论，在这里

423
00:16:52,529 --> 00:16:53,820
是所谓的遗憾子句。

424
00:16:53,820 --> 00:16:55,340
所以，这里的所有的小字。

425
00:16:55,340 --> 00:16:58,090
但总的来说，我们已经看到
在过去的8年以上

426
00:16:58,090 --> 00:17:01,510
如此，事实上，几乎所有的CS50的
学术造假案

427
00:17:01,510 --> 00:17:04,390
一直只是穷人的结果
决策深夜。

428
00:17:04,390 --> 00:17:07,144
应力，其结果的结果
缺乏饮食，睡眠不足，

429
00:17:07,144 --> 00:17:09,560
过多的P组，太多
最后期限，太多的承诺。

430
00:17:09,560 --> 00:17:13,520
应力凌晨一两点建立3:00
：00,4：00，有一个最后期限迫在眉睫。

431
00:17:13,520 --> 00:17:17,020
大多数学生在这些情况下，
刚刚做出了错误的决定

432
00:17:17,020 --> 00:17:20,619
他们很可能会后悔的
第二天早上如果不分钟后，

433
00:17:20,619 --> 00:17:25,490
但直到去年，没有
放气阀，这些学生可以

434
00:17:25,490 --> 00:17:29,140
实际上开辟实际解决
问题的头不用担心被

435
00:17:29,140 --> 00:17:30,850
从大学完全启动。

436
00:17:30,850 --> 00:17:33,260
>> 而且，事实上，我们推出
这个遗憾节最后一年，

437
00:17:33,260 --> 00:17:35,970
它说，如果在
72小时后，三天，

438
00:17:35,970 --> 00:17:37,970
穿越一些线
在规定的教学大纲

439
00:17:37,970 --> 00:17:41,178
你出面了课程之一
头，我们将有一个关于它的聊天。

440
00:17:41,178 --> 00:17:43,720
目前还有一些
结果，违背了什么

441
00:17:43,720 --> 00:17:44,990
据报道，与此相反。

442
00:17:44,990 --> 00:17:49,190
还有一些结果是
是可操作的由课程，

443
00:17:49,190 --> 00:17:51,611
一般归零在P组
或者采取一些其他的措施，

444
00:17:51,611 --> 00:17:53,610
但我们会，事实上，
处理它自己，而不是

445
00:17:53,610 --> 00:17:58,460
指其较高的是结果
可能是更严重的。

446
00:17:58,460 --> 00:18:01,810
而且，事实上，分享发生了什么
去年，在八年，现在

447
00:18:01,810 --> 00:18:04,950
九年，本课程教学
并与各旋钮摆弄后，

448
00:18:04,950 --> 00:18:07,866
过去转弯各种刻度盘
几年来学术诚信，

449
00:18:07,866 --> 00:18:11,920
和每数据没有明显看到
影响甚至这样的演讲，

450
00:18:11,920 --> 00:18:15,490
这是手了最好的东西
我们教学上推出

451
00:18:15,490 --> 00:18:18,090
八年来顺
这些线路在CS50。

452
00:18:18,090 --> 00:18:21,010
>> 19名学生上前
根据本条款的最后一年。

453
00:18:21,010 --> 00:18:23,389
我们没有采取行动
7这些学生，

454
00:18:23,389 --> 00:18:25,430
确定它们是
不必要的担心。

455
00:18:25,430 --> 00:18:27,304
他们没有，事实上，
越过一条线，但它

456
00:18:27,304 --> 00:18:28,960
是一个很好的聊天都不过。

457
00:18:28,960 --> 00:18:31,190
我们归零的分数11
该提交。

458
00:18:31,190 --> 00:18:33,840
而在一种情况下，我们问了
学生做习题集。

459
00:18:33,840 --> 00:18:36,370
但更引人注目的，
说实话，这些19的聊天记录，

460
00:18:36,370 --> 00:18:39,020
这是方式比我
预计将有，他们每个人

461
00:18:39,020 --> 00:18:41,370
10分钟或许一个
小时多头，也带来了

462
00:18:41,370 --> 00:18:44,920
点燃有关的一些问题
家庭问题，朋友的问题，

463
00:18:44,920 --> 00:18:46,940
心理健康问题
我们再搞，

464
00:18:46,940 --> 00:18:50,200
与学生的祝福，居民
院长，或朋友，或任何其它号码

465
00:18:50,200 --> 00:18:51,450
支持资源。

466
00:18:51,450 --> 00:18:54,454
所以，这是迄今为止1
我们这个时代的最佳用途

467
00:18:54,454 --> 00:18:55,870
和最佳干预措施之一。

468
00:18:55,870 --> 00:18:58,870
>> 随着中说，它没有
输入上检测的速率

469
00:18:58,870 --> 00:19:00,909
学术造假的更普遍。

470
00:19:00,909 --> 00:19:02,950
我敢说，这个子集
学生去年

471
00:19:02,950 --> 00:19:06,350
是一个人口我们
以前以前从未确定

472
00:19:06,350 --> 00:19:08,140
和从未与之前连接。

473
00:19:08,140 --> 00:19:10,020
所以，这些人
精彩的成功案例

474
00:19:10,020 --> 00:19:13,390
即使他们被带到光
在低于最佳情况。

475
00:19:13,390 --> 00:19:15,640
所以，记住这一点
当你做，也许，

476
00:19:15,640 --> 00:19:17,390
一些贫困的决定
自己在深夜，

477
00:19:17,390 --> 00:19:20,151
有追索这么久
作为学生在这种情况

478
00:19:20,151 --> 00:19:23,400
自己并出面使我们能
有那种聊天，并处理它

479
00:19:23,400 --> 00:19:27,310
的方式，是教育，然后
我们可以把它在我们身后的第二天。

480
00:19:27,310 --> 00:19:30,335
>> 因此，事不宜迟，取
缘灭这次谈话中，

481
00:19:30,335 --> 00:19:35,080
小狗是上升的原因
只是为了打破僵局了一会儿。

482
00:19:35,080 --> 00:19:39,560
不幸的是，他们都睡觉，
但什么是应该发生在这里

483
00:19:39,560 --> 00:19:41,760
是每个人都应该
以敬畏和一种放松

484
00:19:41,760 --> 00:19:43,910
在那之后很沉重的谈话。

485
00:19:43,910 --> 00:19:46,930
但显然我把
小狗睡觉。

486
00:19:46,930 --> 00:19:50,070
但是，如果你去到CS50的
网站斜线小狗，

487
00:19:50,070 --> 00:19:51,610
你可以整天看着他们。

488
00:19:51,610 --> 00:19:55,280
特别是，也许2:00，或
3:00，或4:00，晚上

489
00:19:55,280 --> 00:19:57,480
看到一个小的压力缓解那里。

490
00:19:57,480 --> 00:19:58,805
所以这是凶多吉少小狗。

491
00:19:58,805 --> 00:20:01,700

492
00:20:01,700 --> 00:20:02,200
好吧。

493
00:20:02,200 --> 00:20:03,020
是不是很好玩？

494
00:20:03,020 --> 00:20:04,200
行。

495
00:20:04,200 --> 00:20:07,140
所以，回到一些电脑
科学，如果我可以。

496
00:20:07,140 --> 00:20:10,600
>> 所以，记得上次我们开始
看着不只是在主，这

497
00:20:10,600 --> 00:20:13,930
是默认的功能，当
绿旗点击当量，

498
00:20:13,930 --> 00:20:16,999
但是，我们也开始简要
写我们自己的一些功能。

499
00:20:16,999 --> 00:20:20,040
因此到目前为止没有这些功能
已经特别大或肉。

500
00:20:20,040 --> 00:20:24,570
你会惹上这些大
功能可能，P组2，P组3，

501
00:20:24,570 --> 00:20:26,410
肯定P设定4及以后。

502
00:20:26,410 --> 00:20:29,340
现在大部分的节目，
如果不是所有的人，肯定对p

503
00:20:29,340 --> 00:20:31,550
集1可以在主全部完成。

504
00:20:31,550 --> 00:20:33,810
如果你的程序是唯一
五类线，10号线，

505
00:20:33,810 --> 00:20:37,070
甚至20日线长，完美
合理的把它写

506
00:20:37,070 --> 00:20:40,930
所有的主，不要过分复杂
你的代码，但我们正在做什么今天

507
00:20:40,930 --> 00:20:44,360
及以后试图也
介绍一些好的设计技巧

508
00:20:44,360 --> 00:20:48,660
这样，当你的代码变得更
复杂和作为问题

509
00:20:48,660 --> 00:20:51,690
你想解决越来越困难和
更有趣的你有几分，

510
00:20:51,690 --> 00:20:55,850
在你的工具箱中的工具，其作用
设计良好的解决这些。

511
00:20:55,850 --> 00:21:01,210
>> 所以，让我们快速回顾一下
这个节目从我的最后一周，这

512
00:21:01,210 --> 00:21:06,550
是函数零点点。和
请注意，很简单，

513
00:21:06,550 --> 00:21:10,310
它看起来像这样有两个
功能，主要和打印的名字。

514
00:21:10,310 --> 00:21:13,160
而回想或者
今天逆向工程，

515
00:21:13,160 --> 00:21:16,880
究竟是什么动机引入
在第28行称为函数，

516
00:21:16,880 --> 00:21:18,180
打印的名字吗？

517
00:21:18,180 --> 00:21:21,745
或者是什么这的一个例子
宗旨或外卖方面，

518
00:21:21,745 --> 00:21:22,605
如果你会的。

519
00:21:22,605 --> 00:21:26,560

520
00:21:26,560 --> 00:21:27,300
一些杂音。

521
00:21:27,300 --> 00:21:28,830
什么？

522
00:21:28,830 --> 00:21:32,210
>> 是啊等等功能分解
是怎么样的说法了奇特的方式，

523
00:21:32,210 --> 00:21:34,690
分解你的程序
成其组成部分

524
00:21:34,690 --> 00:21:37,530
然后使用这些部件
组装一个整体。

525
00:21:37,530 --> 00:21:39,620
所以，这也仅仅是一种
已经一口，

526
00:21:39,620 --> 00:21:42,050
但是这也许是连
的东西更好的例子

527
00:21:42,050 --> 00:21:43,081
只是所谓的抽象。

528
00:21:43,081 --> 00:21:43,580
对？

529
00:21:43,580 --> 00:21:46,950
抽象是要为一个
反复出现的主题CS50的

530
00:21:46,950 --> 00:21:49,085
而且计算机科学
更普遍的，因为它是

531
00:21:49,085 --> 00:21:53,060
一种技术，使用它可以解决
问题更有效，因为你

532
00:21:53,060 --> 00:21:56,807
可以编写解决方案的更多
直观的方式，缩放

533
00:21:56,807 --> 00:21:58,390
并且是可以理解其他人。

534
00:21:58,390 --> 00:21:59,860
我怎么意思？

535
00:21:59,860 --> 00:22:04,340
>> 因此，可以说这是更具可读性
看这样的节目，

536
00:22:04,340 --> 00:22:05,990
超短虽然它是。

537
00:22:05,990 --> 00:22:10,050
当您在22行看到，有
一个调用的函数，打印的名字。

538
00:22:10,050 --> 00:22:12,620
单单这名字就做什么。

539
00:22:12,620 --> 00:22:15,780
这个功能显然需要
它的括号内输入，

540
00:22:15,780 --> 00:22:18,600
显然做一些事情，
想必打印的名称。

541
00:22:18,600 --> 00:22:20,880
因此，尽管我们
绝对可以有

542
00:22:20,880 --> 00:22:25,280
做什么我们做了一个星期前，这是
只是把这个代码的实际行，

543
00:22:25,280 --> 00:22:28,710
摆脱了这一点，并获得
摆脱这一切在一起，

544
00:22:28,710 --> 00:22:31,436
我们之类的抽象出来
打印名的概念。

545
00:22:31,436 --> 00:22:33,060
如果你使用的打印清晰度我不在乎。

546
00:22:33,060 --> 00:22:35,601
我不在乎，如果你有一个
％的S和一个反斜杠N.这些

547
00:22:35,601 --> 00:22:37,270
是令人难以置信的神秘细节。

548
00:22:37,270 --> 00:22:40,090
我所关心的一个
程序员正在打印一个名称。

549
00:22:40,090 --> 00:22:43,414
所以，要做什么更好的方式，
不是通过调用一个函数，打印的名字吗？

550
00:22:43,414 --> 00:22:46,330
因此，这是动机之一
做这样的事情。

551
00:22:46,330 --> 00:22:50,370
使代码更易读，更
可重复使用的，并具有自描述性的。

552
00:22:50,370 --> 00:22:52,120
现在，让我们一起来看看
在另一实例中，

553
00:22:52,120 --> 00:22:56,220
这是一个功能，
这是我们不得不在这里。

554
00:22:56,220 --> 00:23:00,367
>> 所以，这一次或许更
引人注目的，因为，在这种情况下，

555
00:23:00,367 --> 00:23:01,700
我不希望只是得到一个int。

556
00:23:01,700 --> 00:23:03,320
我希望得到一个积极的INT。

557
00:23:03,320 --> 00:23:06,470
而事实证明，得到了肯定
诠释你所要做的一帮跑腿。

558
00:23:06,470 --> 00:23:06,969
对？

559
00:23:06,969 --> 00:23:09,600
这不是一个简单的一行
调用诸如打印的名字，

560
00:23:09,600 --> 00:23:11,480
这是无可否认的那么迫切。

561
00:23:11,480 --> 00:23:16,000
>> 为了得到一个积极的INT，logically--
让我滚动回落隐藏此。

562
00:23:16,000 --> 00:23:18,887
你有什么做的？

563
00:23:18,887 --> 00:23:20,720
像所有的工具，我们
目前所面对的是

564
00:23:20,720 --> 00:23:24,440
像从标准打印高清
图书馆，也从CS50库

565
00:23:24,440 --> 00:23:26,990
我们有获取int和获取浮动，
获得长隆，获取字符串，

566
00:23:26,990 --> 00:23:29,260
但只有一个，锗，
现在的问题是得到诠释。

567
00:23:29,260 --> 00:23:32,970
所以，如果唯一的工具，你有
在你的工具盒是获取智力，

568
00:23:32,970 --> 00:23:35,505
我们怎么去实现
它得到积极的诠释？

569
00:23:35,505 --> 00:23:35,929
>> 听众：创建一个记录，并检查
是否，他们给输入

570
00:23:35,929 --> 00:23:36,762
为正。

571
00:23:36,762 --> 00:23:39,390

572
00:23:39,390 --> 00:23:40,640
>> 扬声器1：完美。

573
00:23:40,640 --> 00:23:41,200
没错。

574
00:23:41,200 --> 00:23:43,950
我们在另一个工具我们
从两个星期前的工具箱

575
00:23:43,950 --> 00:23:45,419
仅仅是循环结构。

576
00:23:45,419 --> 00:23:48,210
所以，是的，如果我们使用了一段时间
循环或do while循环，或脱颖而出

577
00:23:48,210 --> 00:23:50,850
循环中，我们也许可以蒙混过关
任何那些某种形式的。

578
00:23:50,850 --> 00:23:55,140
我们可以实现获取的概念
积极的INT，只需使用Get诠释，

579
00:23:55,140 --> 00:23:57,830
然后自顾自地调用它
再次，保持缠着用户

580
00:23:57,830 --> 00:24:00,320
直到他或她实际上
为我们提供了我们想要的。

581
00:24:00,320 --> 00:24:03,260
>> 所以现在，这个
该方法的抽象

582
00:24:03,260 --> 00:24:05,680
中得到肯定的INT
到称为函数

583
00:24:05,680 --> 00:24:08,930
得到正int是多一点
引人注目的，因为看这个。

584
00:24:08,930 --> 00:24:10,990
这就像10加
行代码的

585
00:24:10,990 --> 00:24:15,090
参与得到肯定的整型，
我真的不关心你是怎么做的。

586
00:24:15,090 --> 00:24:17,850
所有我关心的是你
能做到这一点，所以我已经

587
00:24:17,850 --> 00:24:21,660
隐藏所有后面的这些细节
函数调用得到正int值，

588
00:24:21,660 --> 00:24:23,430
事实上，有这个do while循环。

589
00:24:23,430 --> 00:24:27,660
>> 而看到上周的语法
在那里，但它只是宣告N，

590
00:24:27,660 --> 00:24:29,800
并打印出
指令给用户。

591
00:24:29,800 --> 00:24:33,330
它要求得到诠释，然后检查
再次此条件，并再次，

592
00:24:33,330 --> 00:24:35,230
并再次直到用户协作。

593
00:24:35,230 --> 00:24:38,000
>> 所以，现在，几个完整性检查。

594
00:24:38,000 --> 00:24:40,370
对于那些也许熟悉
有一定编程，

595
00:24:40,370 --> 00:24:46,410
为什么为N声明，为什么我创造
在do while循环氮之外？

596
00:24:46,410 --> 00:24:50,370
为什么第29行，而不是
像33，例如。

597
00:24:50,370 --> 00:24:53,529
>> 听众：因为当你
一种外部声明，它

598
00:24:53,529 --> 00:24:56,688
的更多，较大scope--

599
00:24:56,688 --> 00:24:58,146
>> 扬声器1：好。

600
00:24:58,146 --> 00:24:59,604
>> 听众： - 并且如果你声明
它的循环中，[听不清]

601
00:24:59,604 --> 00:25:00,979
因为它不知道这件事。

602
00:25:00,979 --> 00:25:02,819

603
00:25:02,819 --> 00:25:03,610
扬声器1：没错。

604
00:25:03,610 --> 00:25:06,330
如果我能simplify--
它的范围的问题。

605
00:25:06,330 --> 00:25:11,530
和范围是指在上下文
其中一个变量存在或可用。

606
00:25:11,530 --> 00:25:15,050
和拇指这里的好的规则是，
通常当你声明或创建

607
00:25:15,050 --> 00:25:21,642
一个变量，你只能内部使用
最亲密的拥抱花括号。

608
00:25:21,642 --> 00:25:22,600
那么，是什么意思呢？

609
00:25:22,600 --> 00:25:26,551
如果我，相反，撤消此去与
东西，感觉有点简单。

610
00:25:26,551 --> 00:25:27,050
对？

611
00:25:27,050 --> 00:25:29,360
>> 第32行只是看起来更清洁现在对我。

612
00:25:29,360 --> 00:25:31,500
我正在做两件事在
一次，然后分配

613
00:25:31,500 --> 00:25:33,070
右手到左手。

614
00:25:33,070 --> 00:25:35,180
现在的问题的基础上
范围的界定

615
00:25:35,180 --> 00:25:41,130
是，N能在线路上使用
31和32这循环内，

616
00:25:41,130 --> 00:25:45,100
但如果根据这一定义
可它不能用？

617
00:25:45,100 --> 00:25:45,660
在行是什么？

618
00:25:45,660 --> 00:25:46,160
是啊。

619
00:25:46,160 --> 00:25:47,490
>> 听众：35。

620
00:25:47,490 --> 00:25:49,180
>> 扬声器1：35。

621
00:25:49,180 --> 00:25:50,480
绝对不是35。

622
00:25:50,480 --> 00:25:52,349
而且还还有什么地方？

623
00:25:52,349 --> 00:25:52,890
听众：34。

624
00:25:52,890 --> 00:25:55,040
扬声器1：即使34
有问题的，因为它是

625
00:25:55,040 --> 00:25:56,450
外面的大括号。

626
00:25:56,450 --> 00:25:58,200
所以事实上，让我们看看会发生什么。

627
00:25:58,200 --> 00:25:58,700
对？

628
00:25:58,700 --> 00:26:00,722
这似乎有点
直观的，也可能不是，

629
00:26:00,722 --> 00:26:02,680
但是让我们看看有什么
编译器的时候说

630
00:26:02,680 --> 00:26:04,730
我们进入今天的源目录。

631
00:26:04,730 --> 00:26:08,950
让功能之一。

632
00:26:08,950 --> 00:26:11,231
哦，我的上帝。

633
00:26:11,231 --> 00:26:12,980
好吧，我终于完成
这，顺便说一句。

634
00:26:12,980 --> 00:26:14,030
好吧。

635
00:26:14,030 --> 00:26:15,510
这有什么问题吗？

636
00:26:15,510 --> 00:26:17,430
很神秘的来看待。

637
00:26:17,430 --> 00:26:19,570
但这里是我typed--
使功能之一。

638
00:26:19,570 --> 00:26:21,640
下面是做诱导，
这实际上是

639
00:26:21,640 --> 00:26:23,705
使用编译器铛
用那些标志

640
00:26:23,705 --> 00:26:25,080
我们将不久再次看到。

641
00:26:25,080 --> 00:26:26,829
再次，总是期待
在第一个错误，

642
00:26:26,829 --> 00:26:30,540
因为它可能只是一个级联
其他线路毫无意义的作用。

643
00:26:30,540 --> 00:26:34,410
>> 所以，这是什么意思的是，
问题是在功能1.C.

644
00:26:34,410 --> 00:26:36,890
它是线32。

645
00:26:36,890 --> 00:26:39,712
而且它在列或字符，13。

646
00:26:39,712 --> 00:26:42,670
所以，当你的文本编辑器，可以
帮助您确定的问题是。

647
00:26:42,670 --> 00:26:47,079
所以，如果我向上滚动，什么是第32行？

648
00:26:47,079 --> 00:26:49,120
这的确是这个
这已经凸显

649
00:26:49,120 --> 00:26:50,607
右这里 - 未使用的变量n。

650
00:26:50,607 --> 00:26:51,440
但它不是使用。

651
00:26:51,440 --> 00:26:52,320
我使用它。

652
00:26:52,320 --> 00:26:56,110
但是编译器的迷惑，因为
它只存在这个范围内。

653
00:26:56,110 --> 00:26:57,727
所以我不能在这里使用它。

654
00:26:57,727 --> 00:26:58,560
我不能在这里使用它。

655
00:26:58,560 --> 00:27:01,320
和编译器，因此，
甚至不关心我尝试。

656
00:27:01,320 --> 00:27:03,940
这似乎是不使用的
在其实际范围。

657
00:27:03,940 --> 00:27:08,854
>> 因此，我们可以通过做扩大范围
正是我们开始with--诠释ñ。

658
00:27:08,854 --> 00:27:11,020
即使它不
看起来优雅，也许，

659
00:27:11,020 --> 00:27:15,110
我们正在做一个额外的行
在这里，现在它的范围无处不在。

660
00:27:15,110 --> 00:27:15,970
因此，让我们再试一次。

661
00:27:15,970 --> 00:27:19,040
因此，请功能之一。

662
00:27:19,040 --> 00:27:19,610
美观大方。

663
00:27:19,610 --> 00:27:23,370
而现在，如果我，如果我运行功能
之一，让我们给它的负10，

664
00:27:23,370 --> 00:27:27,170
负1，0，1，它确实工作。

665
00:27:27,170 --> 00:27:28,610
>> 所以在这里另一种解决方案。

666
00:27:28,610 --> 00:27:29,280
你知道吗？

667
00:27:29,280 --> 00:27:31,230
如果我真的摔跤呢？

668
00:27:31,230 --> 00:27:33,140
我不知道在哪里
N为应该去。

669
00:27:33,140 --> 00:27:33,723
你知道吗？

670
00:27:33,723 --> 00:27:39,220
我只是把它所有的
在我的文件的顶部，在这里的方式。

671
00:27:39,220 --> 00:27:42,835
什么该做，你觉得呢？

672
00:27:42,835 --> 00:27:43,335
是吗？

673
00:27:43,335 --> 00:27:44,251
>> 听众：[听不清]。

674
00:27:44,251 --> 00:27:47,964

675
00:27:47,964 --> 00:27:48,630
扬声器1：是啊。

676
00:27:48,630 --> 00:27:50,560
所以，我做了它全球性的，可以这么说。

677
00:27:50,560 --> 00:27:54,430
如果你有一个变量的外
所有的功能是允许的，

678
00:27:54,430 --> 00:27:58,780
和代码应编译，和n
现在将访问不仅在获取

679
00:27:58,780 --> 00:28:02,490
正整型，而且在main--其中
有点令人担忧，因为有

680
00:28:02,490 --> 00:28:04,864
已经是N的主，所以更
对，在短短一个moment--

681
00:28:04,864 --> 00:28:06,530
但是这会被认为是不好的设计。

682
00:28:06,530 --> 00:28:06,910
好吧。

683
00:28:06,910 --> 00:28:08,570
如果你不得不求助于
有点像，哦，我会

684
00:28:08,570 --> 00:28:10,125
只要把它在这里，因为
代码看起来编译

685
00:28:10,125 --> 00:28:12,180
一般不是最好的做法。

686
00:28:12,180 --> 00:28:14,590
而你要选择
最窄的可能范围

687
00:28:14,590 --> 00:28:18,720
为你的变量，这将意味着
与我们最初的设计，将其

688
00:28:18,720 --> 00:28:19,920
就在这里。

689
00:28:19,920 --> 00:28:24,400
>> 现在，顺便说一句，如果你确实有
一个同名的变量在这里，

690
00:28:24,400 --> 00:28:27,750
的C方式将处理this--
虽然这不会发生太大often--

691
00:28:27,750 --> 00:28:30,150
是，这是仍
完全没有在这里。

692
00:28:30,150 --> 00:28:35,000
但N的线的定义
22将跟随全球之一。

693
00:28:35,000 --> 00:28:38,190
所以这个一会工夫内
主要和全球性

694
00:28:38,190 --> 00:28:41,670
当你将实际应用
得到肯定的INT但更多介绍

695
00:28:41,670 --> 00:28:43,890
还有一次，只是
对于那些好奇。

696
00:28:43,890 --> 00:28:45,970
>> 因此，在短期，我们解决这个问题在这里。

697
00:28:45,970 --> 00:28:49,220
现在，让我们梳理出另外两件
我们来看一个代码最后一行之前

698
00:28:49,220 --> 00:28:50,170
在这个程序。

699
00:28:50,170 --> 00:28:52,170
获得积极的INT。

700
00:28:52,170 --> 00:28:54,450
上的左侧
它的字是字INT。

701
00:28:54,450 --> 00:28:56,860
这是什么意味着你觉得呢？

702
00:28:56,860 --> 00:28:58,900
到目前为止，我们已经多见无效。

703
00:28:58,900 --> 00:28:59,400
是吗？

704
00:28:59,400 --> 00:29:01,810
>> 听众：这类型的
你问有关的变量。

705
00:29:01,810 --> 00:29:04,550
>> 扬声器1：是啊这是类型，让我
不是说变，但值的类型

706
00:29:04,550 --> 00:29:05,990
那我问回来。

707
00:29:05,990 --> 00:29:08,070
事实上，这是
直观这里，希望。

708
00:29:08,070 --> 00:29:08,200
对？

709
00:29:08,200 --> 00:29:10,250
如果你想获得一个
积极的INT，你有什么事

710
00:29:10,250 --> 00:29:12,920
要像function--我们
从上周的志愿者

711
00:29:12,920 --> 00:29:15,720
交给你回来一块
纸，上面有一个int？

712
00:29:15,720 --> 00:29:19,190
所以，我们指定的
此功能的所谓的返回类型

713
00:29:19,190 --> 00:29:20,450
为得到正的int。

714
00:29:20,450 --> 00:29:22,990
如果我们不希望它
返回任何东西，你说无效。

715
00:29:22,990 --> 00:29:25,270
如果你希望它返回
一个字符串，你说的字符串。

716
00:29:25,270 --> 00:29:27,310
如果你希望它返回
浮子，你说的浮动。

717
00:29:27,310 --> 00:29:30,440
但是，这适用于这里只有一个
从逻辑上讲，因为我使用GET INT，

718
00:29:30,440 --> 00:29:34,130
即使我限制它
正值，是返回一个int。

719
00:29:34,130 --> 00:29:38,380
>> 那么反过来说，这是什么意思
这有一个在括号中的空白？

720
00:29:38,380 --> 00:29:40,130
做什么括号
一般定义？

721
00:29:40,130 --> 00:29:40,588
是吗？

722
00:29:40,588 --> 00:29:42,880
>> 听众：这意味着该功能的
没有真正得到它。

723
00:29:42,880 --> 00:29:44,650
>> 扬声器1：表示该功能的
实际上没有得到什么？

724
00:29:44,650 --> 00:29:45,430
>> 听众：输入。

725
00:29:45,430 --> 00:29:46,763
>> 扬声器1：输入任何责任。

726
00:29:46,763 --> 00:29:49,870
因此，事实上，如果括号
在这里你指定无效，

727
00:29:49,870 --> 00:29:51,650
这只是意味着我不希望任何输入。

728
00:29:51,650 --> 00:29:53,269
我会解决自己的问题。

729
00:29:53,269 --> 00:29:55,810
事实上，你不必
告诉得到积极的INT什么。

730
00:29:55,810 --> 00:29:59,630
你刚才说的，得到积极的INT，那
功能将熄灭，做它的事。

731
00:29:59,630 --> 00:30:02,970
>> 但有过一个小窍门，我已经
一直在这里玩这个整个时间

732
00:30:02,970 --> 00:30:04,970
以确保该代码编译。

733
00:30:04,970 --> 00:30:09,620
请注意，int--得到正
INT void--是第27行。

734
00:30:09,620 --> 00:30:14,530
但是，对于一些看似奇怪的原因
这也是在这里第16行。

735
00:30:14,530 --> 00:30:18,530
而刚刚好措施，我会重复
此所以这是完全一样的。

736
00:30:18,530 --> 00:30:21,640
我已经说过原型
有点单行注释。

737
00:30:21,640 --> 00:30:28,850
如果我删除了，会发生什么，以及
现在重新运行使功能1，进入。

738
00:30:28,850 --> 00:30:29,350
哎呦。

739
00:30:29,350 --> 00:30:32,527

740
00:30:32,527 --> 00:30:33,110
等待一分钟。

741
00:30:33,110 --> 00:30:34,764
哪里是我的卡？

742
00:30:34,764 --> 00:30:35,263
咦？

743
00:30:35,263 --> 00:30:37,969

744
00:30:37,969 --> 00:30:39,620
支持。

745
00:30:39,620 --> 00:30:41,570
让功能1。

746
00:30:41,570 --> 00:30:42,150
在那里，我们走了。

747
00:30:42,150 --> 00:30:42,310
行。

748
00:30:42,310 --> 00:30:43,400
好久没救了它正常。

749
00:30:43,400 --> 00:30:45,220
所以，我觉得有一点
这里臭虫，我不是

750
00:30:45,220 --> 00:30:46,636
看到此刻的选项卡名称。

751
00:30:46,636 --> 00:30:47,940
那么，什么是怎么回事？

752
00:30:47,940 --> 00:30:52,210
函数隐式声明
得到肯定的int是在C99无效。

753
00:30:52,210 --> 00:30:53,940
如此混乱了。

754
00:30:53,940 --> 00:30:55,200
所以，这是什么指示？

755
00:30:55,200 --> 00:30:57,287
嗯，事实证明，
C是非常愚蠢的。

756
00:30:57,287 --> 00:30:59,912
那么，它的编程
语言，或者说编译器。

757
00:30:59,912 --> 00:31:02,940
它只知道你有什么
教它，它只是

758
00:31:02,940 --> 00:31:05,640
要知道的事
如果你以前教它。

759
00:31:05,640 --> 00:31:07,960
换句话说，在
主要的那一刻，我

760
00:31:07,960 --> 00:31:10,900
试图调用一个函数
所谓得到积极int类型。

761
00:31:10,900 --> 00:31:14,120
但是，编译器是不会
注意到，获得积极的INT

762
00:31:14,120 --> 00:31:16,500
一直存在，直到第26行。

763
00:31:16,500 --> 00:31:21,360
还等什么，编译器不只是
错误一旦它进入第17行，

764
00:31:21,360 --> 00:31:23,700
他说隐式声明
中得到积极int，它

765
00:31:23,700 --> 00:31:27,740
是的说法只是一种奇特的方式，我不
知道什么得到积极int是呢。

766
00:31:27,740 --> 00:31:31,240
>> 其他语言如Java和
Python和Ruby可能向前看。

767
00:31:31,240 --> 00:31:32,240
C没有。

768
00:31:32,240 --> 00:31:35,110
这样一来，我们的方法解决
这是两种方法之一。

769
00:31:35,110 --> 00:31:40,160
任一个，如果问题是，得到
积极INT一直没有见过的，

770
00:31:40,160 --> 00:31:42,150
好了，让我将它移动到顶部。

771
00:31:42,150 --> 00:31:43,650
这将解决这个问题。

772
00:31:43,650 --> 00:31:46,790
但是总体来说，这是
考虑更好的技术

773
00:31:46,790 --> 00:31:50,220
把你的主要功能在很
顶部，这样一个人阅读你的代码

774
00:31:50,220 --> 00:31:52,710
知道该程序的功能，
因为主要是不埋没全部

775
00:31:52,710 --> 00:31:53,960
的方式在底部或在中间。

776
00:31:53,960 --> 00:31:55,130
这是在最高层。

777
00:31:55,130 --> 00:31:56,410
这样就不会觉得理想。

778
00:31:56,410 --> 00:31:58,326
你可以真正得到
成的情况下

779
00:31:58,326 --> 00:32:00,820
如果一个函数调用
另外，它调用了另一个，

780
00:32:00,820 --> 00:32:04,630
你可以成为一个问题，即没有
可以去上面的其它，逻辑上。

781
00:32:04,630 --> 00:32:05,920
这是不可能的。

782
00:32:05,920 --> 00:32:09,290
>> 因此在上班的路上
解决办法是只取

783
00:32:09,290 --> 00:32:13,200
函数的签名，所以要speak--
第一行，其中它的declared--

784
00:32:13,200 --> 00:32:16,850
而只是复制，粘贴在
顶，但不与卷曲braces--

785
00:32:16,850 --> 00:32:17,980
只是一个分号。

786
00:32:17,980 --> 00:32:20,840
这就像一个小提示
是什么来。

787
00:32:20,840 --> 00:32:26,630
而事实上，这一切的时候，我们
已经看到的东西像标准io.h

788
00:32:26,630 --> 00:32:33,040
和cs50.h，类似地，在那些点
.h文件有没有其他的原型。

789
00:32:33,040 --> 00:32:35,250
我们会看到不久。

790
00:32:35,250 --> 00:32:39,340
>> 因此，在短期，当你有一个程序
在具有多种功​​能的文件

791
00:32:39,340 --> 00:32:42,300
除了主要的，你几乎
总是要声明它们

792
00:32:42,300 --> 00:32:45,360
只是他们的第一个方式
行，后跟一个分号，

793
00:32:45,360 --> 00:32:48,410
在该文件的顶部。

794
00:32:48,410 --> 00:32:50,460
这是一个很大的一次。

795
00:32:50,460 --> 00:32:53,130
任何问题？

796
00:32:53,130 --> 00:32:53,920
任何问题？

797
00:32:53,920 --> 00:32:54,530
好吧。

798
00:32:54,530 --> 00:32:59,760
>> 因此，让我们继续前进，然后
为类似咳嗽。

799
00:32:59,760 --> 00:33:00,260
呵呵。

800
00:33:00,260 --> 00:33:00,570
如何装修。

801
00:33:00,570 --> 00:33:01,220
好吧。

802
00:33:01,220 --> 00:33:02,260
咳嗽。

803
00:33:02,260 --> 00:33:05,080
因此，这里是一个C
实施方案的

804
00:33:05,080 --> 00:33:07,560
我们在做了一天
从头开始的很干脆只

805
00:33:07,560 --> 00:33:08,691
说咳，咳，咳。

806
00:33:08,691 --> 00:33:09,190
好吧。

807
00:33:09,190 --> 00:33:11,136
有一个人说了几句
日前，有​​是

808
00:33:11,136 --> 00:33:12,760
可以说已经清理这些代码起来。

809
00:33:12,760 --> 00:33:12,880
好吧？

810
00:33:12,880 --> 00:33:15,440
当你复制和
粘贴可能糟糕的设计。

811
00:33:15,440 --> 00:33:18,725
至少有一次，我们到了四，五
或20咳嗽，感觉不好的做法。

812
00:33:18,725 --> 00:33:19,850
我们只是一味地复制，粘贴。

813
00:33:19,850 --> 00:33:22,213
什么是显而易见的解决方案
要清理这个计划吗？

814
00:33:22,213 --> 00:33:23,120
>> 听众：循环。

815
00:33:23,120 --> 00:33:23,350
>> 扬声器1：是啊。

816
00:33:23,350 --> 00:33:24,070
因此，使用循环。

817
00:33:24,070 --> 00:33:27,697
我们可以用一个for循环，一段时间
循环，任何数量的方法。

818
00:33:27,697 --> 00:33:29,780
事实上，这就是
我们做一个版本在这里。

819
00:33:29,780 --> 00:33:32,250
我不是重写它
在一个版本cough.c的

820
00:33:32,250 --> 00:33:35,170
是一个for循环中只是咳嗽。

821
00:33:35,170 --> 00:33:38,240
好了，但有一个
现在机会来样开始

822
00:33:38,240 --> 00:33:41,630
设计这个有点像
教训我们教刚才，

823
00:33:41,630 --> 00:33:46,190
这是this--假设，我想
创建一个名为止咳的功能，

824
00:33:46,190 --> 00:33:49,730
让我们考虑的只是一瞬间
它是怎么回事的样子。

825
00:33:49,730 --> 00:33:51,900
所以，如果我想要的东西
咳，我只需要

826
00:33:51,900 --> 00:33:53,800
使用打印f显示函数内。

827
00:33:53,800 --> 00:33:55,030
事实上我。

828
00:33:55,030 --> 00:33:56,990
而事实上，这一切
时间，任何时候你

829
00:33:56,990 --> 00:33:59,000
打印的东西
屏幕，程序员

830
00:33:59,000 --> 00:34:00,610
将调用的副作用。

831
00:34:00,610 --> 00:34:02,990
这不是我递过
回别人的值。

832
00:34:02,990 --> 00:34:06,170
这是我采取一些行动
这可能是视觉上明显的。

833
00:34:06,170 --> 00:34:10,672
但是，这个功能的咳嗽，它返回
任何基于它的第一线？

834
00:34:10,672 --> 00:34:12,880
没有，因为它的返回类型
是无效的，这只是意味着

835
00:34:12,880 --> 00:34:14,250
它不是递过来任何东西。

836
00:34:14,250 --> 00:34:16,791
它可能会做什么
在视觉上，但它不是递过来

837
00:34:16,791 --> 00:34:18,639
背一纸像上周。

838
00:34:18,639 --> 00:34:21,310
>> 是否需要任何投入？

839
00:34:21,310 --> 00:34:21,810
第

840
00:34:21,810 --> 00:34:23,134
所以它的无效这里。

841
00:34:23,134 --> 00:34:25,600
所以这也是一种
过工程这一问题。

842
00:34:25,600 --> 00:34:26,099
对？

843
00:34:26,099 --> 00:34:28,820
我做了计划的更多
复杂的，多行代码，

844
00:34:28,820 --> 00:34:31,889
我没有作任何
多个功能，但是这

845
00:34:31,889 --> 00:34:34,210
将是一个敲门砖，
也许，对于更广泛的

846
00:34:34,210 --> 00:34:36,830
上下文与更复杂的代码。

847
00:34:36,830 --> 00:34:38,150
可是你知道吗？

848
00:34:38,150 --> 00:34:42,050
我有什么done--只是瞥一眼
这不看评论

849
00:34:42,050 --> 00:34:46,076
在file--什么都有的最顶端
我根本在这里完成我的咳嗽

850
00:34:46,076 --> 00:34:47,409
实现这有什么不同？

851
00:34:47,409 --> 00:34:48,327
是啊，在后面？

852
00:34:48,327 --> 00:34:51,384
>> 听众：让它这样你就可以
有一个字符关闭。

853
00:34:51,384 --> 00:34:52,050
扬声器1：是啊。

854
00:34:52,050 --> 00:34:53,270
所以，这种感觉挺有意思。

855
00:34:53,270 --> 00:34:53,389
对？

856
00:34:53,389 --> 00:34:56,600
这就像增加一个功能，您
程序或功能，在这种情况下。

857
00:34:56,600 --> 00:34:57,830
它仍然没有返回值。

858
00:34:57,830 --> 00:35:00,538
它可能具有一个视觉副作用，
因为它调用打印F。

859
00:35:00,538 --> 00:35:02,800
但现在我已经参数化
的功能，这

860
00:35:02,800 --> 00:35:06,470
意味着我指定取
int类型的输入，并把它称为N，

861
00:35:06,470 --> 00:35:08,510
但我可以把它叫做什么，我想要的。

862
00:35:08,510 --> 00:35:11,550
事实上，它可能只是
次，以更加明确。

863
00:35:11,550 --> 00:35:13,310
然后，我可能只是在这里改变这一点。

864
00:35:13,310 --> 00:35:16,450
但问题是，这就是我
创建一个函数，该函数的输入。

865
00:35:16,450 --> 00:35:19,530
如果你还记得翻转
通过在一个或者在线

866
00:35:19,530 --> 00:35:23,000
中穿行时，
第四个也是最后咳嗽例如，

867
00:35:23,000 --> 00:35:27,150
你会发现在这里，我概括
我的代码further--那种抽象

868
00:35:27,150 --> 00:35:27,690
它进一步。

869
00:35:27,690 --> 00:35:31,390
像咳嗽，喷嚏，都是
关于好像说什么或做

870
00:35:31,390 --> 00:35:32,330
某种声音。

871
00:35:32,330 --> 00:35:34,725
保存将是
相应的划痕块。

872
00:35:34,725 --> 00:35:37,350
所以我在这个版本中那样，
而我们只要看一眼，

873
00:35:37,350 --> 00:35:43,170
咳嗽就像是说，[咳嗽]
咳嗽，同时，打喷嚏是

874
00:35:43,170 --> 00:35:44,570
就好比说，[ACHOO]。

875
00:35:44,570 --> 00:35:46,900
所以我概括
这些实施

876
00:35:46,900 --> 00:35:48,970
现在实施
这个通用功能，

877
00:35:48,970 --> 00:35:51,490
说，这是有趣的
对于今天的目的

878
00:35:51,490 --> 00:35:54,300
不仅是因​​为它仍然
不具有返回类型。

879
00:35:54,300 --> 00:35:56,398
但是，有多少投入它有？

880
00:35:56,398 --> 00:35:56,981
听众：两个。

881
00:35:56,981 --> 00:35:57,430
扬声器1：两个。

882
00:35:57,430 --> 00:35:59,263
所以，如果你想
参加两个参数，

883
00:35:59,263 --> 00:36:00,710
只是将它们分开用逗号隔开。

884
00:36:00,710 --> 00:36:03,110
如果你要那么
调用该函数，

885
00:36:03,110 --> 00:36:05,800
请注意，您刚才
来电说，报价，引文结束，

886
00:36:05,800 --> 00:36:09,090
第一个参数，常见的
N，第二个参数。

887
00:36:09,090 --> 00:36:12,130
所以，再一次，我们只是现在
积木，使我们实际上可以

888
00:36:12,130 --> 00:36:15,686
实现我们自己的一些功能。

889
00:36:15,686 --> 00:36:16,570
好吧。

890
00:36:16,570 --> 00:36:19,690
对这些有问题吗？

891
00:36:19,690 --> 00:36:22,400
>> 所以，现在，让我们剥开一层，如果左右。

892
00:36:22,400 --> 00:36:24,840
和目标，最终
是下周的习题集

893
00:36:24,840 --> 00:36:27,710
将是对cryptogrophy--
艺术扰码信息。

894
00:36:27,710 --> 00:36:30,640
和具体地，信息
将你加密或解密

895
00:36:30,640 --> 00:36:31,605
将是文字。

896
00:36:31,605 --> 00:36:33,980
所以那种的邀请
今天的问题一样好，

897
00:36:33,980 --> 00:36:38,480
到底是怎么回事引擎盖下
文字超越ASCII从零一周，

898
00:36:38,480 --> 00:36:40,730
以及我们如何真正能
开始操作它？

899
00:36:40,730 --> 00:36:43,070
因此，这里是Zamyla的名字。

900
00:36:43,070 --> 00:36:47,380
和文本中，这可能是输入
到像的get字符串函数。

901
00:36:47,380 --> 00:36:52,540
而从现在开始，当你看到一个
串像this-- Z-A-M-Y-L-A--

902
00:36:52,540 --> 00:36:56,550
开始想到它，就好像每个
这些字符是在一个盒子的其

903
00:36:56,550 --> 00:36:57,050
自己的。

904
00:36:57,050 --> 00:36:59,460
事实上，在一个星期左右的
时间，每个这些框

905
00:36:59,460 --> 00:37:04,280
是要代表非常明确
memory--内存咬块。

906
00:37:04,280 --> 00:37:07,050
因此，每个这些信件，
最终，将代表8位。

907
00:37:07,050 --> 00:37:10,560
我们将真正看到这是怎么回事
在我的电脑的引擎盖下。

908
00:37:10,560 --> 00:37:13,440
>> 但不是足够
只是为了看Zamyla

909
00:37:13,440 --> 00:37:17,520
从这个角度，即每
这些信件是在自己的箱子。

910
00:37:17,520 --> 00:37:22,697
并很好地足够的C语言，我们可以
访问每个直接这些箱子。

911
00:37:22,697 --> 00:37:25,530
所以，如果你想获得第一
信中她的名字，在C超方便

912
00:37:25,530 --> 00:37:28,410
如果你想获得最后的
信中，超级方便以及

913
00:37:28,410 --> 00:37:30,240
用一块新的语法。

914
00:37:30,240 --> 00:37:36,250
>> 所以我要继续前进到CS50
IDE和开拓串零点C.

915
00:37:36,250 --> 00:37:40,270
并且在这里此例中，有
一些新的东西怎么回事。

916
00:37:40,270 --> 00:37:44,360
因此，先在第19行，我们已经
看到了这一点before-- GET字符串。

917
00:37:44,360 --> 00:37:49,840
因此，正如一个快速的完整性检查，
如果有人可以提供高达口头

918
00:37:49,840 --> 00:37:52,662
一个外行的解释
这是怎么回事在19行。

919
00:37:52,662 --> 00:37:55,370
像刚才把它理解
英语在CS50一个室友不

920
00:37:55,370 --> 00:37:56,416
可以理解的。

921
00:37:56,416 --> 00:37:56,916
是啊。

922
00:37:56,916 --> 00:37:59,749
>> 听众：让用户输入
字符串，并将其存储在一个变量s。

923
00:37:59,749 --> 00:38:01,934

924
00:38:01,934 --> 00:38:02,600
扬声器1：好。

925
00:38:02,600 --> 00:38:05,579
有用户输入的字符串
并将其存储在一个变量s。

926
00:38:05,579 --> 00:38:06,120
那很棒。

927
00:38:06,120 --> 00:38:08,090
因此，在右侧
方面，我们调用get字符串。

928
00:38:08,090 --> 00:38:10,340
返回一个值
未获得分配

929
00:38:10,340 --> 00:38:14,230
从右手侧到左手
侧入变量称为S这

930
00:38:14,230 --> 00:38:15,950
设计用来存储串。

931
00:38:15,950 --> 00:38:16,800
没错。

932
00:38:16,800 --> 00:38:20,000
>> 所以，现在22行，每
在第21行的注释，

933
00:38:20,000 --> 00:38:22,780
显然打印出字符串
每行一个字符。

934
00:38:22,780 --> 00:38:23,740
但如何？

935
00:38:23,740 --> 00:38:27,040
所以首先，我们初始化我为0。

936
00:38:27,040 --> 00:38:31,061
然后我们怎么来
的Zamyla名结束了吗？

937
00:38:31,061 --> 00:38:32,810
那么，在年底
Zamyla的名字，我可以

938
00:38:32,810 --> 00:38:38,151
手动输入的最后一个字符
她的名字在某种程度上，或者它的数量。

939
00:38:38,151 --> 00:38:38,650
对？

940
00:38:38,650 --> 00:38:43,500
如果我们回到这里 -  Z-A-M-L--
Y型L-A--所以我可以输入内容。

941
00:38:43,500 --> 00:38:47,340
什么是指数
Zamyla的最后一封信？

942
00:38:47,340 --> 00:38:52,517
如果这是0--讲像
programmer-- 0，1，2，3，4，5，

943
00:38:52,517 --> 00:38:56,570
我heard--所以事实上，最后一个字母
在Zamyla的名字是第六，

944
00:38:56,570 --> 00:38:58,890
但如果我们从0数，
这将是5号。

945
00:38:58,890 --> 00:39:01,320
所以记住这一点在这里。

946
00:39:01,320 --> 00:39:04,929
>> 原来有一个函数
C中调用strlen的，并在当天回

947
00:39:04,929 --> 00:39:06,720
并以这一天还在，
很多程序员

948
00:39:06,720 --> 00:39:09,524
选择同步的名称为自己
听起来词功能

949
00:39:09,524 --> 00:39:10,440
他们正试图说。

950
00:39:10,440 --> 00:39:12,590
所以strlen的是字符串的长度。

951
00:39:12,590 --> 00:39:18,168
所以会是什么的字符串长度
回归时Zamyla是输入？

952
00:39:18,168 --> 00:39:19,569
>> 听众：五。

953
00:39:19,569 --> 00:39:22,090
>> 扬声器1：Z-A-M-Y-L。六。

954
00:39:22,090 --> 00:39:22,590
对？

955
00:39:22,590 --> 00:39:23,940
什么是对Zamyla姓名的长度？

956
00:39:23,940 --> 00:39:24,440
对？

957
00:39:24,440 --> 00:39:26,240
而就在现实中，六个字母。

958
00:39:26,240 --> 00:39:26,740
对？

959
00:39:26,740 --> 00:39:28,940
所以，这是什么意思为我们的循环？

960
00:39:28,940 --> 00:39:32,130
我们打​​算从去
0多达六个，这

961
00:39:32,130 --> 00:39:33,650
将会给我们五次迭代。

962
00:39:33,650 --> 00:39:34,890
我们该怎么办在每次迭代？

963
00:39:34,890 --> 00:39:36,870
好了，百分之C，人
日前猜到了，

964
00:39:36,870 --> 00:39:38,710
是指一个占位符是什么？

965
00:39:38,710 --> 00:39:39,335
>> 听众：字符。

966
00:39:39,335 --> 00:39:40,293
扬声器1：只是一个字符。

967
00:39:40,293 --> 00:39:42,877
因此，一个单一的character--不
多个字符，像一个字符串。

968
00:39:42,877 --> 00:39:45,251
然后这里的新生产线
我们已经得到了打印输出。

969
00:39:45,251 --> 00:39:46,580
然后这里的新语法。

970
00:39:46,580 --> 00:39:51,130
如果你想打印出的第i个
字符字符串s，可以这么说，

971
00:39:51,130 --> 00:39:54,060
你可以简单地说，
带S的命名，

972
00:39:54,060 --> 00:39:58,230
然后打开括号，然后
然后关闭括号，与我

973
00:39:58,230 --> 00:39:58,780
中间。

974
00:39:58,780 --> 00:40:01,430
而且它是一种很好的在
那种它看起来像一个正方形

975
00:40:01,430 --> 00:40:06,210
就像正方形中Zamyla的
文字上的图片存在。

976
00:40:06,210 --> 00:40:09,970
>> 所以，如果我实际运行这个
现在，让我们看看会发生什么。

977
00:40:09,970 --> 00:40:15,190
使串0点斜线
字符串0，然后我

978
00:40:15,190 --> 00:40:16,720
要在Zamyla的名字输入。

979
00:40:16,720 --> 00:40:19,428
有没有提示，因为我没有
使用打印女，但是这很好。

980
00:40:19,428 --> 00:40:20,660
我知道该怎么做。

981
00:40:20,660 --> 00:40:23,240
事实上，它打印出
Zamyla的名字，每行一个。

982
00:40:23,240 --> 00:40:25,760
>> 现在，让我们有点鲁莽。

983
00:40:25,760 --> 00:40:28,461
假设我不知道
有关strlen的，我算了一下，

984
00:40:28,461 --> 00:40:31,460
所有的权利，没有人将有一个
名称大于像50个字符。

985
00:40:31,460 --> 00:40:36,360
让我们继续前进，重新编译这
并重新运行它，然后键入Zamyla

986
00:40:36,360 --> 00:40:37,160
再次。

987
00:40:37,160 --> 00:40:40,850
从逻辑上讲，什么是
程序将尝试打印？

988
00:40:40,850 --> 00:40:49,545
Z-A-M-Y-L-A然后像45
未知字节的内存。

989
00:40:49,545 --> 00:40:51,670
事实上，我们会回来的
这种想法的记忆。

990
00:40:51,670 --> 00:40:54,180
但是，仅仅从逻辑上讲，如果
Zamyla的名字是这样长，

991
00:40:54,180 --> 00:40:56,450
按照图片
在这里，我们在说什么

992
00:40:56,450 --> 00:40:59,810
就是继续打印，保留打印，保存
印刷，保持印花，保持印花，

993
00:40:59,810 --> 00:41:03,781
一路第50字符，
这谁知道会发生什么。

994
00:41:03,781 --> 00:41:05,030
因此，让我们实际来看看。

995
00:41:05,030 --> 00:41:06,720
让我们输入Zamyla。

996
00:41:06,720 --> 00:41:07,250
有趣的。

997
00:41:07,250 --> 00:41:08,190
我们很幸运。

998
00:41:08,190 --> 00:41:09,700
只是一大堆的空白。

999
00:41:09,700 --> 00:41:09,930
呵呵。

1000
00:41:09,930 --> 00:41:11,120
还有一个时髦的人物。

1001
00:41:11,120 --> 00:41:14,577
它看起来有点像一个奇怪的问题
标记存在，但有Zamyla的名字。

1002
00:41:14,577 --> 00:41:15,660
让我们真的很鲁莽。

1003
00:41:15,660 --> 00:41:20,000
怎么样，我们打印出500
块到未知？

1004
00:41:20,000 --> 00:41:24,380
让我们继续前进，使这个
以及，然后重新运行。

1005
00:41:24,380 --> 00:41:27,980
而且，我们全屏幕，​​因为
我们需要看到更多的空间。

1006
00:41:27,980 --> 00:41:30,460
Zamyla。

1007
00:41:30,460 --> 00:41:31,830
又是幸运的。

1008
00:41:31,830 --> 00:41:33,070
>> 敢我们得到更加肆无忌惮？

1009
00:41:33,070 --> 00:41:36,070
让我们更加肆无忌惮。

1010
00:41:36,070 --> 00:41:39,350
50000字。

1011
00:41:39,350 --> 00:41:41,390
这是最肯定不是一个好主意。

1012
00:41:41,390 --> 00:41:41,890
好吧。

1013
00:41:41,890 --> 00:41:42,990
使串0。

1014
00:41:42,990 --> 00:41:44,720
这将是我们最后的演示。

1015
00:41:44,720 --> 00:41:47,261
Zamyla。

1016
00:41:47,261 --> 00:41:48,632
唉。

1017
00:41:48,632 --> 00:41:50,010
唉。

1018
00:41:50,010 --> 00:41:50,680
行。

1019
00:41:50,680 --> 00:41:54,407
所以，我的记忆真的是空的，现在，
这是一种真正方便。

1020
00:41:54,407 --> 00:41:55,990
我试图让用于：没事。

1021
00:41:55,990 --> 00:41:57,614
而现在我只是要得到鲁莽。

1022
00:41:57,614 --> 00:41:58,570
500,000。

1023
00:41:58,570 --> 00:42:03,860
Make--让全屏它。

1024
00:42:03,860 --> 00:42:04,990
输入。

1025
00:42:04,990 --> 00:42:05,490
Zamyla。

1026
00:42:05,490 --> 00:42:12,050

1027
00:42:12,050 --> 00:42:13,390
在那里，我们走了。

1028
00:42:13,390 --> 00:42:15,610
我不知道那是什么
是的，但它听起来很糟糕。

1029
00:42:15,610 --> 00:42:16,110
好吧。

1030
00:42:16,110 --> 00:42:20,322
而事实上，很快，如果你是中
在办公时间幸运的少数人

1031
00:42:20,322 --> 00:42:22,780
而在问题设置一个，你
很可能会遇到这样的。

1032
00:42:22,780 --> 00:42:25,490
段错误实际上做
具有良好定义的含义。

1033
00:42:25,490 --> 00:42:28,450
这意味着一些错误
有关的存储器段。

1034
00:42:28,450 --> 00:42:30,490
而在通俗地说，
这意味着我们感动

1035
00:42:30,490 --> 00:42:34,780
memory--我们使用的RAM在我的电脑
我不应该有访问。

1036
00:42:34,780 --> 00:42:37,050
这就是既是
功能强大，也很危险

1037
00:42:37,050 --> 00:42:39,910
关于C实际上是你
自由访问

1038
00:42:39,910 --> 00:42:45,910
你的程序的内存的全部
或字节或RAM，更具体。

1039
00:42:45,910 --> 00:42:49,510
>> 因此，即使Zamyla的名字
只有六个字符，

1040
00:42:49,510 --> 00:42:51,450
我还可以去任何地方
在内存我想要的。

1041
00:42:51,450 --> 00:42:53,491
而作为顺便说一句，如果你
读过一些文章

1042
00:42:53,491 --> 00:42:55,610
在一些多年
服务器或某些节目

1043
00:42:55,610 --> 00:42:58,654
盗取或砍死那
东西冤大头

1044
00:42:58,654 --> 00:43:00,820
所谓的缓冲区溢出
利用这一点，我们会真正

1045
00:43:00,820 --> 00:43:04,970
谈谈在几个星期，这是
通常是指以某种方式欺骗

1046
00:43:04,970 --> 00:43:09,090
一台电脑变成进展顺利
以外的存储器的边界

1047
00:43:09,090 --> 00:43:11,410
它应该有，与
找到的东西多汁

1048
00:43:11,410 --> 00:43:13,530
在memory--一个
密码，也许，一种方法

1049
00:43:13,530 --> 00:43:16,990
绕过一些序列号的
检查，或者只是一般都能

1050
00:43:16,990 --> 00:43:20,360
诱骗计算机正在执行
代码并不打算。

1051
00:43:20,360 --> 00:43:22,360
但是，让我们回过头来
现实只是一瞬间

1052
00:43:22,360 --> 00:43:24,550
其中，该计划是
与strlen的实施，

1053
00:43:24,550 --> 00:43:26,110
并引入一件事在这里。

1054
00:43:26,110 --> 00:43:30,030
什么是这些顶级三条线之间新的？

1055
00:43:30,030 --> 00:43:30,910
>> 因此，串点小时。

1056
00:43:30,910 --> 00:43:35,490
原来有这个库被称为
串点H，或字符串库，

1057
00:43:35,490 --> 00:43:38,490
它的头文件，可以这么说，
是串点h上给我

1058
00:43:38,490 --> 00:43:40,860
访问该strlen函数。

1059
00:43:40,860 --> 00:43:43,841
如果我省略，编译器
要我大声喊叫以某种形式。

1060
00:43:43,841 --> 00:43:44,590
但是，你知道吗？

1061
00:43:44,590 --> 00:43:46,090
现在让我们真的很细致入微。

1062
00:43:46,090 --> 00:43:50,820
在第22行，有什么样的
的inefficient--设计糟糕，

1063
00:43:50,820 --> 00:43:53,990
arguably--关于这行代码。

1064
00:43:53,990 --> 00:43:56,280
回想一下如何
for循环中实现

1065
00:43:56,280 --> 00:44:00,140
什么步骤再次发生，
再次again--初始化，

1066
00:44:00,140 --> 00:44:04,110
的情况下，代码
得到执行，那么增量

1067
00:44:04,110 --> 00:44:07,880
或变更，则条件，
然后该代码，则改变，那么

1068
00:44:07,880 --> 00:44:11,280
的条件，则代码，
然后将改变，等等。

1069
00:44:11,280 --> 00:44:15,320
那么，什么可能有点
令人担忧的还是在这里做得不好？

1070
00:44:15,320 --> 00:44:16,387
是啊，在蓝色。

1071
00:44:16,387 --> 00:44:18,220
听众：strlen的是
所谓的很多很多次。

1072
00:44:18,220 --> 00:44:20,654

1073
00:44:20,654 --> 00:44:21,320
扬声器1：是啊。

1074
00:44:21,320 --> 00:44:23,700
所以strlen的被称为
很多次，但什么是

1075
00:44:23,700 --> 00:44:27,113
的Zamyla的名字长度
第一次循环执行？

1076
00:44:27,113 --> 00:44:27,860
>> 听众：六。

1077
00:44:27,860 --> 00:44:28,110
>> 扬声器1：六。

1078
00:44:28,110 --> 00:44:30,976
那么，什么是她的名字长度
代码执行第二次？

1079
00:44:30,976 --> 00:44:31,432
>> 听众：六。

1080
00:44:31,432 --> 00:44:31,890
>> 扬声器1：所有权利。

1081
00:44:31,890 --> 00:44:32,720
它仍然是六人。

1082
00:44:32,720 --> 00:44:33,220
对？

1083
00:44:33,220 --> 00:44:35,260
Zarla的名字还没有
改变，即使我在寻找

1084
00:44:35,260 --> 00:44:38,240
在她的名字的字母的一部分。

1085
00:44:38,240 --> 00:44:41,349
这样一来，其实我是有效的
问这个问题，什么是

1086
00:44:41,349 --> 00:44:44,640
Zamyla的长度，有什么长度
Zamyla的，什么是Zamyla的长度，

1087
00:44:44,640 --> 00:44:47,990
六个独立倍，或
七连，仅仅是愚蠢的，

1088
00:44:47,990 --> 00:44:50,390
因为这是不变的答案。

1089
00:44:50,390 --> 00:44:53,550
所以，我居然可以
做的是this--在串的一个

1090
00:44:53,550 --> 00:44:55,680
我有一个稍微好一些的版本在这里。

1091
00:44:55,680 --> 00:45:00,110
那里 -  whoops--线二我有
一个稍微更好的版本，其中

1092
00:45:00,110 --> 00:45:05,010
我做this--，而不是仅仅
我初始化为0，我也用逗号

1093
00:45:05,010 --> 00:45:07,990
声明一个叫做第二个变量
N--我没有再说INT。

1094
00:45:07,990 --> 00:45:09,220
我不应该，事实上。

1095
00:45:09,220 --> 00:45:10,380
但是我要说ñ。

1096
00:45:10,380 --> 00:45:13,610
然后我初始化n至
n的strlen的，所以现在

1097
00:45:13,610 --> 00:45:17,110
多少次的strlen
共得到执行？

1098
00:45:17,110 --> 00:45:17,610
就一次。

1099
00:45:17,610 --> 00:45:20,257
所以，这就是我们所说的
早期有关更好的设计。

1100
00:45:20,257 --> 00:45:23,090
实际上，一旦你的代码是正确的，
回去和思考通过，

1101
00:45:23,090 --> 00:45:26,820
我是使用尽可能少
存储器或几秒钟

1102
00:45:26,820 --> 00:45:30,409
电脑的时间或毫秒为单位
可以实现一些问题？

1103
00:45:30,409 --> 00:45:32,200
而且我要滚动
并只提

1104
00:45:32,200 --> 00:45:34,283
还有就是这个提
在这个版本空的，

1105
00:45:34,283 --> 00:45:36,390
但我们会回来的，不久。

1106
00:45:36,390 --> 00:45:41,010
因为现在，让我们来看看
在其中，这会引导我们。

1107
00:45:41,010 --> 00:45:44,110
所以之一，事实证明，
现在我们有能力

1108
00:45:44,110 --> 00:45:46,860
看单个字符，
我们可以利用的东西

1109
00:45:46,860 --> 00:45:50,807
从0星期是非常神秘和
那种无趣的时间。

1110
00:45:50,807 --> 00:45:53,390
但现在，尤其是当我们
我在一周密码学，

1111
00:45:53,390 --> 00:45:54,820
这将是非常强大的。

1112
00:45:54,820 --> 00:45:57,450
事实证明，一些
数据types--整型和浮点

1113
00:45:57,450 --> 00:46:00,300
和字符和字符串和
其他things--他们中的一些

1114
00:46:00,300 --> 00:46:02,800
可以很容易地转化为另一种。

1115
00:46:02,800 --> 00:46:05,840
>> 例如，当我们谈到
有关ASCII一段时间ago--这里

1116
00:46:05,840 --> 00:46:07,796
资本字母A
通过并购，点，点，

1117
00:46:07,796 --> 00:46:12,530
dot--我们说有一个映射
这些字母和数字之间。

1118
00:46:12,530 --> 00:46:14,970
而事实上，它也适用
小写字母以及。

1119
00:46:14,970 --> 00:46:17,470
小写a是97，资本为65。

1120
00:46:17,470 --> 00:46:20,860
而且有一些在ASCII码，
这仅仅是这种映射

1121
00:46:20,860 --> 00:46:23,240
系统的所有这些其他字母。

1122
00:46:23,240 --> 00:46:25,030
那么，是什么意思呢？

1123
00:46:25,030 --> 00:46:28,390
好了，我要继续前进，开
达实快一些所谓

1124
00:46:28,390 --> 00:46:31,240
ASCII 0，其中大部分是注释。

1125
00:46:31,240 --> 00:46:33,860
并再次在网上可以随时
翻阅了意见。

1126
00:46:33,860 --> 00:46:36,180
>> 看一看什么
这是要干什么。

1127
00:46:36,180 --> 00:46:38,410
所以它有一个主要功能。

1128
00:46:38,410 --> 00:46:41,490
我硬编码的数字只为
现在，因为我知道我在做什么。

1129
00:46:41,490 --> 00:46:42,950
我知道我想在这里看到。

1130
00:46:42,950 --> 00:46:45,220
而且我初始化我65岁。

1131
00:46:45,220 --> 00:46:48,490
而且我计数
通过26个字母总额。

1132
00:46:48,490 --> 00:46:52,990
而我怎么来
一次打印一行

1133
00:46:52,990 --> 00:46:54,930
如果你能理解
这个突出的线路？

1134
00:46:54,930 --> 00:46:55,970
什么被印？

1135
00:46:55,970 --> 00:46:56,797
是啊。

1136
00:46:56,797 --> 00:46:57,264
>> 听众：你要
打印的信

1137
00:46:57,264 --> 00:46:59,805
对应的地图
信中值和整数值？

1138
00:46:59,805 --> 00:47:01,199

1139
00:47:01,199 --> 00:47:01,990
扬声器1：没错。

1140
00:47:01,990 --> 00:47:04,740
我要打印的信
对应于该整数值，

1141
00:47:04,740 --> 00:47:06,131
反之，如下所示。

1142
00:47:06,131 --> 00:47:08,880
嗯，这，有人早些时候说，
只是一个占位符字符。

1143
00:47:08,880 --> 00:47:09,490
它仍然是。

1144
00:47:09,490 --> 00:47:12,280
当然，这是一个占位符
对于int--不是一个新的生产线。

1145
00:47:12,280 --> 00:47:18,140
现在发现，我的第一个值
我堵在该占位符

1146
00:47:18,140 --> 00:47:22,320
不只是我。我是说，
括号，字符我，

1147
00:47:22,320 --> 00:47:26,700
其中括号字符是
告诉编译器，把我

1148
00:47:26,700 --> 00:47:28,490
不是作为它是什么，这是一个数字。

1149
00:47:28,490 --> 00:47:30,490
把它作为一个实际的字符。

1150
00:47:30,490 --> 00:47:34,490
而第二个值我堵
in--我 - 应该只是一个数字。

1151
00:47:34,490 --> 00:47:38,140
>> 所以，如果我编译这个program--
所以这是使ASCII 0，

1152
00:47:38,140 --> 00:47:41,720
点斜线ASCII 0--我只是得到
这个方便的小图表

1153
00:47:41,720 --> 00:47:44,950
我显示了所有可能的
映射，而不必认为它

1154
00:47:44,950 --> 00:47:46,450
通过或数字出来我自己。

1155
00:47:46,450 --> 00:47:48,783
而且我还打印出，
注意小写字母，

1156
00:47:48,783 --> 00:47:51,410
因为几行后，我
同时打印出这个映射

1157
00:47:51,410 --> 00:47:53,737
还有，这仅仅是
说，一旦你明白

1158
00:47:53,737 --> 00:47:55,570
下面是怎么回事
引擎盖，你能

1159
00:47:55,570 --> 00:47:57,111
自动来回转换。

1160
00:47:57,111 --> 00:48:00,160
而事实上，如果哪
做过这个在小学

1161
00:48:00,160 --> 00:48:03,490
或听说过有人
神话般服用记

1162
00:48:03,490 --> 00:48:05,620
并将其传递给他的
或她在课堂上的朋友，

1163
00:48:05,620 --> 00:48:08,300
但你炒的
按字母如A变成B，

1164
00:48:08,300 --> 00:48:11,240
和B变成C，或某事
复杂多了，好了，

1165
00:48:11,240 --> 00:48:13,410
你会怎么去
实现了作为一个孩子？

1166
00:48:13,410 --> 00:48:16,340
嗯，你刚才那种知道
A成为B，B变成C，

1167
00:48:16,340 --> 00:48:19,700
但在数学上，
什么那小子做什么？

1168
00:48:19,700 --> 00:48:22,050
什么是你增加了每个字母？

1169
00:48:22,050 --> 00:48:23,340
实际上，1。

1170
00:48:23,340 --> 00:48:27,740
>> 因此，当你改变A到B，这是
有点像改变65到66，

1171
00:48:27,740 --> 00:48:29,590
其中数学意味着只需添加1。

1172
00:48:29,590 --> 00:48:33,300
所以，如果你要实现
那小小的欺骗手段

1173
00:48:33,300 --> 00:48:36,380
在代码中你的老师，你
可能会做的正是刚刚

1174
00:48:36,380 --> 00:48:38,552
通过增加一个字母在一起。

1175
00:48:38,552 --> 00:48:40,260
那么过不了多久，我们
要看到我们如何

1176
00:48:40,260 --> 00:48:43,300
可以利用这一点来实际
真正的加密和解密

1177
00:48:43,300 --> 00:48:43,991
信息。

1178
00:48:43,991 --> 00:48:47,240
在此期间，要知道我们已经开始
引进一对夫妇的其他图书馆

1179
00:48:47,240 --> 00:48:48,990
一个今天这里 - 字符串。

1180
00:48:48,990 --> 00:48:51,180
而一个非常有用的网站
希望你会发现

1181
00:48:51,180 --> 00:48:55,010
被称为reference.cs50.net，这
教学人员都放在一起，

1182
00:48:55,010 --> 00:48:57,510
因此，如果你想
仰望strlen的是如何工作，

1183
00:48:57,510 --> 00:48:59,300
你可以开始输入
函数的名字，

1184
00:48:59,300 --> 00:49:02,890
点击strlen的存在，然后
一个不太舒服的解释

1185
00:49:02,890 --> 00:49:03,700
将要出现。

1186
00:49:03,700 --> 00:49:06,880
或者，如果你想正式
基于Linux的说明中，

1187
00:49:06,880 --> 00:49:08,945
您可以点击更舒适
在右上角，它

1188
00:49:08,945 --> 00:49:12,070
将呈现相同的信息，
但在更复杂的条件。

1189
00:49:12,070 --> 00:49:15,070
这是一个有用的资源
实际上知道什么都做。

1190
00:49:15,070 --> 00:49:17,320
>> 我们要下一次
看看阿华田

1191
00:49:17,320 --> 00:49:20,070
多，自荐
密码学世界。

1192
00:49:20,070 --> 00:49:21,930
在此之前，我们会看到
您在本周晚些时候。

1193
00:49:21,930 --> 00:49:23,390
而现在，科尔顿奥格登。

1194
00:49:23,390 --> 00:49:26,730
星期三见。

1195
00:49:26,730 --> 00:49:30,216
>> [音乐播放]

1196
00:49:30,216 --> 00:49:33,702
>> [音乐播放]

1197
00:49:33,702 --> 00:49:38,682

1198
00:49:38,682 --> 00:49:42,200
>> 扬声器1：什么
[哔]你在干什么？

1199
00:49:42,200 --> 00:49:45,720
>> 扬声器1：我吃我的甜点？

1200
00:49:45,720 --> 00:49:47,160
你怎么吃？

1201
00:49:47,160 --> 00:49:47,860
用你的手？

1202
00:49:47,860 --> 00:49:54,050

1203
00:49:54,050 --> 00:49:57,940
>> [音乐播放]

1204
00:49:57,940 --> 00:50:03,453